print("Found %s word vectors." % len(embeddings_index))
embedding_dim = 200
# 200 dimensional vectors for 10000 words in vocab
embedding_matrix = np.zeros((vocab_size, embedding_dim))
for word, i in wordtoix.items():
# if i < max_words:
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
# Words not found in the embedding index will be all zeros
embedding_matrix[i] = embedding_vector
# Model Building
inputs1 = Input(shape=(2048, ))
fe1 = Dropout(0.5)(inputs1)
fe2 = Dense(256, activation="relu")(fe1)
inputs2 = Input(shape=(max_length, ))
se1 = Embedding(vocab_size, embedding_dim, mask_zero=True)(inputs2)
se2 = Dropout(0.5)(se1)
se3 = LSTM(256)(se2)
decoder1 = add([fe2, se3])
decoder2 = Dense(256, activation="relu")(decoder1)
outputs = Dense(vocab_size, activation="softmax")(decoder2)
model = Model(inputs=[inputs1, inputs2], outputs=outputs)
# Model Summary
print(model.summary())
model.layers[2].set_weights([embedding_matrix])
def __init__(self,
X_train,
y_train,
n_hidden,
n_epochs=40,
normalize=False,
tau=1.0,
dropout=0.05):
"""
Constructor for the class implementing a Bayesian neural network
trained with the probabilistic back propagation method.
@param X_train Matrix with the features for the training data.
@param y_train Vector with the target variables for the
training data.
@param n_hidden Vector with the number of neurons for each
hidden layer.
@param n_epochs Numer of epochs for which to train the
network. The recommended value 40 should be
enough.
@param normalize Whether to normalize the input features. This
is recommended unles the input vector is for
example formed by binary features (a
fingerprint). In that case we do not recommend
to normalize the features.
@param tau Tau value used for regularization
@param dropout Dropout rate for all the dropout layers in the
network.
"""
# We normalize the training data to have zero mean and unit standard
# deviation in the training set if necessary
if normalize:
self.std_X_train = np.std(X_train, 0)
self.std_X_train[self.std_X_train == 0] = 1
self.mean_X_train = np.mean(X_train, 0)
else:
self.std_X_train = np.ones(X_train.shape[1])
self.mean_X_train = np.zeros(X_train.shape[1])
X_train = (X_train - np.full(X_train.shape, self.mean_X_train)) / \
np.full(X_train.shape, self.std_X_train)
self.mean_y_train = np.mean(y_train)
self.std_y_train = np.std(y_train)
y_train_normalized = (y_train - self.mean_y_train) / self.std_y_train
y_train_normalized = np.array(y_train_normalized, ndmin=2).T
# We construct the network
N = X_train.shape[0]
batch_size = 128
lengthscale = 1e-2
reg = lengthscale**2 * (1 - dropout) / (2. * N * tau)
inputs = Input(shape=(X_train.shape[1], ))
inter = Dropout(dropout)(inputs, training=True)
inter = Dense(n_hidden[0], activation='relu',
W_regularizer=l2(reg))(inter)
for i in range(len(n_hidden) - 1):
inter = Dropout(dropout)(inter, training=True)
inter = Dense(n_hidden[i + 1],
activation='relu',
W_regularizer=l2(reg))(inter)
inter = Dropout(dropout)(inter, training=True)
outputs = Dense(y_train_normalized.shape[1],
W_regularizer=l2(reg))(inter)
model = Model(inputs, outputs)
model.compile(loss='mean_squared_error', optimizer='adam')
# We iterate the learning process
start_time = time.time()
model.fit(X_train,
y_train_normalized,
batch_size=batch_size,
nb_epoch=n_epochs,
verbose=0)
self.model = model
self.tau = tau
self.running_time = time.time() - start_time
def sequence_padding(inputs, padding=0):
pad_width = (window_size, window_size)
outputs = []
for x in inputs:
x = np.pad(x, pad_width, 'constant', constant_values=padding)
outputs.append(x)
return outputs
x = [sent2id(sent) for sent in sentences]
x = sequence_padding(x)
dataset = Dataset(x)
gen = DataGenerator(dataset, batch_size=batch_size, shuffle=True)
x_in = Input(shape=(1, ), dtype='int32')
y_true = Input(shape=(window_size * 2, ), dtype='int32')
y_out = skip_gram(x_in, vocub_size, word_dim, window_size)
y_out = Skip_Gram_Loss(output_axis=[i + 1 for i in range(window_size * 2)])([y_true, *y_out])
model = Model([y_true, x_in], y_out)
optimizer = Adam(learning_rate=init_lr)
model.compile(optimizer)
class Evaluator(Callback):
def __init__(self):
super(Evaluator, self).__init__()
self.best_loss = math.inf
def on_epoch_end(self, epoch, logs=None):
if logs['loss'] < self.best_loss:
model.save_weights('skip_gram_best_wts.weights')
def default_classification_model(input_shape=None,
input_tensor=None,
num_classes=7,
num_dense_layers=2,
num_dense_units=256,
dropout_rate=0.,
pooling=None,
use_output_activation=True,
kernel_regularizer=None):
"""
:param kernel_regularizer: l1 or l2 or none regularization
:param num_classes: # of classes to predict a score for each feature level.
:param input_shape: Input shape
:param input_tensor: Input tensor
:param num_dense_layers: Number of dense layers before the output layer
:param num_dense_units: The number of filters to use in the layers in the classification submodel.
:param dropout_rate: Dropout Rate
:param pooling: which pooling to use at conv output
:param use_output_activation: whether to use output activation
:return: A keras.model.Model that predicts class
"""
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
assert kernel_regularizer in [None, 'L1', 'L2', 'L1-L2'], \
'Unknown regularizer %s' % kernel_regularizer
if kernel_regularizer == 'L1':
kernel_regularizer = regularizers.l1(1e-4)
elif kernel_regularizer == 'L2':
kernel_regularizer = regularizers.l2(1e-3)
elif kernel_regularizer == 'L1-L2':
kernel_regularizer = regularizers.l1_l2(l1=1e-4, l2=1e-3)
assert pooling in {None, 'avg', 'max',
'flatten'}, 'Unknown pooling option %s' % pooling
if pooling == 'avg':
outputs = keras.layers.GlobalAveragePooling2D(
name='avg_pool_our')(img_input)
elif pooling == 'max':
outputs = keras.layers.GlobalMaxPooling2D(
name='max_pool_our')(img_input)
else:
outputs = keras.layers.Flatten(name='flatten_our')(img_input)
if dropout_rate > 0.:
outputs = keras.layers.Dropout(rate=dropout_rate,
name='drop_5')(outputs, training=True)
for i in range(num_dense_layers):
outputs = keras.layers.Dense(
num_dense_units,
activation='relu',
name='fc%d' % (i + 1),
kernel_regularizer=kernel_regularizer)(outputs)
if dropout_rate > 0.:
outputs = keras.layers.Dropout(rate=dropout_rate,
name='drop_6')(outputs,
training=True)
outputs = keras.layers.Dense(
num_classes, name='predictions',
kernel_regularizer=kernel_regularizer)(outputs)
if use_output_activation:
activation = 'sigmoid' if num_classes == 1 else 'softmax'
outputs = keras.layers.Activation(activation, name='outputs')(outputs)
return outputs
train = train.sort_index()
label = label.sort_index()
X_train, X_test, y_train, y_test = train_test_split(train, label.iloc[:,0])
#drop_list = list(np.arange(0.65, 0.7, 0.03))
# drop_list.reverse()
for dense in [128]:
for drop_out in [0.63]:
drop_out = round(drop_out, 2)
patience=50
lr = 0.0005
#搭建融合后的模型
inputs = Input((X_train.shape[1:]))
x = Dropout(drop_out)(inputs)
x = Dense(dense, activation='relu')(x)
x = Dropout(drop_out)(x)
x = Dense(22, activation='softmax')(x)
model = Model(inputs, x)
########################################
# np.random.seed(1337)
#
np.set_printoptions(precision=3,
suppress=True,
threshold=np.inf,
linewidth=200)
# to make this notebook's output stable across runs
np.random.seed(42)
# Python ≥3.5 is required
assert sys.version_info >= (3, 5)
# numpy 1.16.4 is required
assert np.__version__ in ["1.16.5", "1.16.4"]
# ----------------------------------------------------------------------
print("Listing 8.29 GAN 生成器网络")
latent_dim = 32
height, width, channels = 32, 32, 3
generator_input = Input(shape=(latent_dim, ))
# 将输入转换为大小为（16，16）的128个通道的特征图
x = Dense(128 * 16 * 16)(generator_input)
x = LeakyReLU()(x)
x = Reshape((16, 16, 128))(x)
x = Conv2D(256, 5, padding='same')(x)
x = LeakyReLU()(x)
# 上采样为（32，32）
x = Conv2DTranspose(256, 4, strides=2, padding='same')(x)
x = LeakyReLU()(x)
x = Conv2D(256, 5, padding='same')(x)
x = LeakyReLU()(x)
x = Conv2D(256, 5, padding='same')(x)
def resnet50_unet_sigmoid(
input_shape=(IMG_H, IMG_W, IMG_C), weights='imagenet'):
inp = Input(input_shape)
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(inp)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
name='conv1')(x)
x = layers.BatchNormalization(axis=BN_AXIS, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
c1 = x
# print("c1")
# print(c1.shape)
x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
c2 = x
# print("c2")
# print(c2.shape)
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
c3 = x
# print("c3")
# print(c3.shape)
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
c4 = x
# print("c4")
# print(c4.shape)
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
c5 = x
# print("c5")
# print(c5.shape)
u6 = conv_block_custom(UpSampling2D()(c5), 1024)
# print("u6")
# print(u6.shape)
u6 = concatenate([u6, c4], axis=-1)
u6 = conv_block_custom(u6, 1024)
u7 = conv_block_custom(UpSampling2D()(u6), 512)
# print("u7")
# print(u7.shape)
u7 = concatenate([u7, c3], axis=-1)
u7 = conv_block_custom(u7, 512)
u8 = conv_block_custom(UpSampling2D()(u7), 256)
# print("u8")
# print(u8.shape)
u8 = concatenate([u8, c2], axis=-1)
u8 = conv_block_custom(u8, 256)
u9 = conv_block_custom(UpSampling2D()(u8), 64)
# print("u9")
# print(u9.shape)
u9 = concatenate([u9, c1], axis=-1)
u9 = conv_block_custom(u9, 64)
u10 = conv_block_custom(UpSampling2D()(u9), 32)
u10 = conv_block_custom(u10, 32)
res = Conv2D(2, (1, 1), activation='sigmoid')(u10)
model = Model(inp, res)
if weights == "imagenet":
resnet50 = ResNet50(weights=weights,
include_top=False,
input_shape=(input_shape[0], input_shape[1], 3))
# resnet50.summary()
print("Loading imagenet weitghts ...")
for i in tqdm(range(3, len(resnet50.layers) - 2)):
try:
model.layers[i].set_weights(resnet50.layers[i].get_weights())
model.layers[i].trainable = False
except:
print(resnet50.layers[i].name)
exit()
print("imagenet weights have been loaded.")
del resnet50
return model
def __init__(self, n_cols, number_layers=6, node_size=100,
prob_dropout=0.1, sparsity_const=10e-5, activation='relu', different_size=None,
beta=1, nodes_range='auto'):
"""
:param n_cols: Number of columns of the dataset
:param number_layers: Number of total layers in the network (without considering the output node)
:param node_size: Number of nodes per layer
:param prob_dropout: proportion to dropout
:param sparsity_const: Restrict some nodes and not all (as PCA), using regularization strategy
:param activation: Activation function
:param different_size: Different sizes in the nodes between root and auxiliars
"""
self.n_cols = n_cols
self.activation = activation
self.prob_dropout = prob_dropout
self.number_layers = number_layers
self.node_size = node_size
self.sparsity_const = sparsity_const
self.beta = beta
self.nodes_range = nodes_range
input_layer = Input(shape=(n_cols,))
if nodes_range == 'auto':
nodes_range = range(n_cols - node_size * 2, node_size - 1, -node_size)
else:
nodes_range = self.nodes_range
print(nodes_range)
# RESIDUAL LAYER
if sparsity_const is not None:
residual = layers.Dense(node_size, activation=self.activation, name='residual_layer_' + str(node_size),
activity_regularizer=
regularizers.l1_l2(sparsity_const, sparsity_const))(input_layer)
else:
residual = layers.Dense(node_size, activation=self.activation, name='root_layer_' + str(node_size))(
input_layer)
y = residual
print('residual', y)
# ROOT LAYERS
if different_size is None:
for nodes in nodes_range:
print(nodes)
if sparsity_const is not None:
y = layers.Dense(node_size, activation=self.activation, activity_regularizer=
regularizers.l1_l2(sparsity_const, sparsity_const))(y)
else:
y = layers.Dense(node_size, activation=self.activation)(y)
if self.prob_dropout is not None:
y = layers.Dropout(self.prob_dropout)(y)
print(y)
else:
for nodes in nodes_range:
if sparsity_const is not None:
y = residual
y = layers.Dense(nodes, activation=self.activation, name='root_layer_' + str(nodes),
activity_regularizer=
regularizers.l1_l2(sparsity_const, sparsity_const))(y)
else:
y = layers.Dense(nodes + different_size, activation=self.activation,
name='root_layer_' + str(nodes))(y)
if self.prob_dropout is not None:
y = layers.Dropout(self.prob_dropout)(y)
residual = layers.Dense(node_size + different_size)(residual)
y = layers.add([y, residual])
output_tensor = layers.Dense(2, activation='softmax')(y)
self.model = Model(input_layer, output_tensor)
plot_model(self.model, to_file=STRING.img_path + 'rc_architecture.png', show_shapes=True)
print(self.model.summary())
# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Problems with tensorflow2 # from keras import Input, Model # from keras.layers import Dense from keras import Input, Model from keras.layers import Dense # Create the input vector (13 elements). inputs = Input((13, )) # Create the first (input) layer (10 nodes) and connect it to the input vector. input = Dense(10)(inputs) # Create the next (hidden) layer (10 nodes) and connect it to the input layer. hidden = Dense(10)(input) # Create the output layer (1 node) and connect it to the previous (hidden) layer. output = Dense(1)(hidden) # Now let's create the neural network, specifying the input layer and output layer. model = Model(inputs, output)
#数据预处理，归一化
x_train = x_train.astype('float32')/255
x_test = x_test.astype('float32')/255
#数据准备,将28*28矩阵转换成1*784，方便BP神经网络输入层784个神经元读取
x_train = x_train.reshape(len(x_train), np.prod(x_train.shape[1:]))
x_test = x_test.reshape(len(x_test), np.prod(x_test.shape[1:]))
#------------------------------------------构建多层自编码器模型----------------------
input_size = 784
hidden_size = 128
code_size = 64
#定义神经网络层数
x = Input(shape=(input_size,))
hidden_1 = Dense(hidden_size, activation='relu')(x)
h = Dense(code_size, activation='relu')(hidden_1)
hidden_2 = Dense(hidden_size, activation='relu')(h)
r = Dense(input_size, activation='sigmoid')(hidden_2)
autoencoder = Model(inputs=x, outputs=r)
autoencoder.compile(optimizer='adam', loss='mse')
#---------------------------------------------模型训练与可视化------------------------------
epochs = 5
batch_size = 128
history = autoencoder.fit(x_train, x_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, x_test))
def define_model(self, config, dset):
supported_models = self.get_supported_models()
SM = "EfficientNet supported models: " + ",".join(
[str(x) for x in supported_models.keys()])
num_layers = config["train"]["model"]["params"]["conv_blocks"]
error_msg = str(num_layers) + " conv_blocks not in " + SM
assert num_layers in supported_models.keys(), error_msg
# Set session
optimizer = keras.optimizers.SGD(
lr=config["train"]["model"]["params"]["learning_rate"],
momentum=0.9,
nesterov=True)
loss_func = "categorical_crossentropy"
if self.is_training is False and "use_pretrained_input_size" in config[
"profile"].keys():
input_tensor = Input(
(config["profile"]["use_pretrained_input_size"],
config["profile"]["use_pretrained_input_size"], 3),
name="input")
model = self.get_model(config,
input_image=input_tensor,
weights='imagenet',
include_top=True)
elif self.is_training is True or "use_pretrained_input_size" not in config[
"profile"].keys():
input_shape = (
config["dataset"]["locations"]["box_size"], # height
config["dataset"]["locations"]["box_size"], # width
len(config["dataset"]["images"]["channels"]) # channels
)
input_image = keras.layers.Input(input_shape)
model = self.get_model(config, input_image=input_image)
features = keras.layers.GlobalAveragePooling2D(name="pool5")(
model.layers[-1].output)
# 2. Create an output embedding for each target
class_outputs = []
i = 0
for t in dset.targets:
y = keras.layers.Dense(t.shape[1],
activation="softmax",
name=t.field_name)(features)
class_outputs.append(y)
i += 1
# 4. Create and compile model
model = keras.models.Model(inputs=input_image,
outputs=class_outputs)
## Added weight decay following tricks reported in:
## https://github.com/keras-team/keras/issues/2717
regularizer = keras.regularizers.l2(0.00001)
for layer in model.layers:
if hasattr(layer, "kernel_regularizer"):
setattr(layer, "kernel_regularizer", regularizer)
model = keras.models.model_from_json(
model.to_json(), {'AugmentationLayer': AugmentationLayer})
return model, optimizer, loss_func
#building and compiling discriminator model
discriminator = build_discriminator()
dis_optimizer = Adam(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=10e-8)
discriminator.compile(loss=['binary_crossentropy'],
optimizer=dis_optimizer)
#building and compiling generator model
generator = build_generator()
gen_optimizer = Adam(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=10e-8)
generator.compile(loss=['binary_crossentropy'], optimizer=gen_optimizer)
##building and compiling adversarial model(generator+discriminator)
discriminator.trainable = False
#building fake input latent vector and fake input label to make adversarial model
fake_input_latent = Input(shape=(100, ))
fake_input_label = Input(shape=(12, ))
# taking fake output from generator
fake_gen_output = generator([fake_input_latent, fake_input_label])
#taking discriminator output for these fake_gen_output
fake_dis_output = discriminator([fake_gen_output, fake_input_label])
#making adversarial model
adversarial_model = Model(inputs=[fake_input_latent, fake_input_label],
outputs=[fake_dis_output])
adversarial_optimizer = Adam(lr=0.0002,
beta_1=0.5,
beta_2=0.999,
epsilon=10e-8)
#Creating one_hot array
X = np.array(x_heme + x_nucle + x_steroid + x_steroid + x_steroid + x_control)
Y = np.array(y_heme + y_nucle + y_steroid + y_steroid + y_steroid + y_control)
X_Y = list(zip(X,Y))
rd.shuffle(X_Y)
X, Y = zip(*X_Y)
oH_x_train = np.array(X)
oH_y_train = np.array(Y)
#Change channel from last to first
set_image_data_format('channels_first')
### Model
inputs = Input(shape=(14, 32, 32, 32))
conv1 = Conv3D(4, (2,2,2), padding="valid", activation="relu")(inputs)
conv2 = Conv3D(16, (2,2,2), padding="valid", activation="relu")(conv1)
drop1 = Dropout(0.2)(conv2)
pool1 = MaxPooling3D(pool_size=(2,2,2))(drop1)
drop2 = Dropout(0.2)(pool1)
flat1 = Flatten()(drop2)
outputs = Dense(4, activation = "softmax")(flat1)
model = Model(inputs=inputs, outputs=outputs)
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
earlyStop = callbacks.EarlyStopping(monitor="val_loss", patience=10, mode="min")
## set up model
#############
if activationFunc=='selu':
myInitializer="lecun_normal"
elif activationFunc=='tanh':
myInitializer="glorot_uniform"
tensorBoardDir="../deepNN/%s-pid%d/%s/fold%d"%(dateTime, sysuffix, namePrefix, fold) #/tensorBoardLog
if not os.path.exists(tensorBoardDir):
os.makedirs(tensorBoardDir)
checkPtFile='../deepNN/%s-pid%d/p2v-fold%d.hdf5'%(dateTime, sysuffix, fold)
scriptInputArgs='../deepNN/%s-pid%d/scriptInputArgs.txt'%(dateTime, sysuffix)
with open(scriptInputArgs,'w') as textFile:
print(syspec, file=textFile)
protTensor=Input(shape=(protTrainIN.shape[1],), name='FastProt')
if activationFunc=='selu':
x1=layers.AlphaDropout(dropoutRate)(protTensor)
else:
x1=layers.Dropout(dropoutRate)(protTensor)
x1=layers.BatchNormalization()(x1)
x1=layers.Dense(units=32, activation=activationFunc, kernel_initializer=myInitializer, kernel_regularizer=regularizers.l1_l2(l1=0, l2=0.01))(x1)
x1=layers.BatchNormalization()(x1)
rnaTensor=Input(shape=(rnaTrainIN.shape[1],), name='FastRNA')
if activationFunc=='selu':
x2=layers.AlphaDropout(dropoutRate)(rnaTensor)
else:
x2=layers.Dropout(dropoutRate)(rnaTensor)
SCRIPT_VERSION = "0.0.2"
SCRIPT_NAME = os.path.basename(__file__)
TIMESTAMP = str(datetime.now()).replace(':', '.')
EPOCHS = 60
BATCH_SIZE = 100
TRAINING_SIZE = 100000
TRAIN_VALIDATE_SPLIT = 0.2
# Archive the configuration
copyfile(__file__, 'configs/' + TIMESTAMP + ' ' + SCRIPT_NAME)
univariate = np.repeat([[[52]]], TRAINING_SIZE, axis=0)
univariate = np.append(univariate, np.zeros(shape=(TRAINING_SIZE, 1, 1)), axis=2)
(_, max_points, GEO_VECTOR_LEN) = univariate.shape
inputs = Input(name='Input', shape=(max_points, GEO_VECTOR_LEN))
model = LSTM(GEO_VECTOR_LEN, return_sequences=True)(inputs)
model = Dense(GEO_VECTOR_LEN)(model)
model = Model(inputs, model)
model.compile(
loss=univariate_gaussian_loss,
optimizer=Adam(lr=0.001))
model.summary()
callbacks = [
TensorBoard(log_dir='./tensorboard_log/' + TIMESTAMP + ' ' + SCRIPT_NAME, write_graph=False),
DecypherAll(lambda x: str(x)),
EarlyStopping(patience=20, min_delta=0.001)
]
history = model.fit(x=univariate,
data = data.astype("float") / 255.0
trainX, testX, trainY, testY = train_test_split(data,
labels,
test_size=0.25,
random_state=42)
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)
baseModel = VGG16(weights='imagenet',
include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
headModel = FCHeadNet.build(baseModel, len(classNames), 256)
model = Model(inputs=baseModel.input, outputs=headModel)
print("layers.len", len(baseModel.layers))
for layer in baseModel.layers:
layer.trainable = False
opt = RMSprop(lr=0.001)
model.compile(optimizer=opt,
loss="categorical_crossentropy",
metrics=["accuracy"])
maxlen=max_word_length)
q1_test_word_index = sequence.pad_sequences(q1_test_word_index,
maxlen=max_word_length)
q2_train_word_index = sequence.pad_sequences(q2_train_word_index,
maxlen=max_word_length)
q2_dev_word_index = sequence.pad_sequences(q2_dev_word_index,
maxlen=max_word_length)
q2_test_word_index = sequence.pad_sequences(q2_test_word_index,
maxlen=max_word_length)
voc_size = len(tokenizer.word_index)
embedding_dim = 300
drop_out = 0.5
dense_dim = 100
q1_input = Input(name='q1', shape=(max_word_length, ))
q2_input = Input(name='q2', shape=(max_word_length, ))
embedding = Embedding(voc_size + 1, embedding_dim)
spatialdropout = SpatialDropout1D(drop_out)
dense = Dense(dense_dim, activation='tanh')
# sum or rnn or lstm
# encode = Lambda(lambda x: K.sum(x, axis=1, keepdims=False))
# encode = SimpleRNN(dense_dim)
encode = LSTM(dense_dim)
q1_embed = dense(spatialdropout(embedding(q1_input)))
q2_embed = dense(spatialdropout(embedding(q2_input)))
q1_embed = encode(q1_embed)
q2_embed = encode(q2_embed)
from keras import Input, layers, Model input_tensor = Input(shape=(64,)) x = layers.Dense(32, activation='relu')(input_tensor) x = layers.Dense(32, activation='relu')(x) output_tensor = layers.Dense(10,activation='softmax')(x) model = Model(input_tensor,output_tensor)
discriminator = Model(disc_input, x)
optimizer = RMSprop(lr=.0001, clipvalue=1.0, decay=1e-8)
discriminator.compile(optimizer=optimizer, loss='binary_crossentropy')
return discriminator
# Create both networks to use in GAN
generator = create_generator()
discriminator = create_discriminator()
discriminator.trainable = False
# Input is the latent space of the dataset (images)
gan_input = Input(shape=(LATENT_DIM, ))
# Output is the result of Discriminator => Generator
# (created images from Generator obtained from modifying weights based on the Discriminator output)
gan_output = discriminator(generator(gan_input))
# Model GAN
gan = Model(gan_input, gan_output)
# Optimizar for adapting learning
optimizer = RMSprop(lr=.0001, clipvalue=1.0, decay=1e-8)
gan.compile(optimizer=optimizer, loss='binary_crossentropy')
if not os.path.isdir(RES_DIR):
os.mkdir(RES_DIR)
control_vectors = np.random.normal(size=(CONTROL_SIZE_SQRT**2, LATENT_DIM)) / 2
# ----------------------- Training process -----------------------
import os
from keras.preprocessing.image import ImageDataGenerator
group_folder_path = '2019_endoscopy_image/'
categories = ['0', '1']
img_size = (28, 28)
train_datagen = ImageDataGenerator(rescale=1. / 255)
train_data = train_datagen.flow_from_directory(group_folder_path + 'train',
target_size=img_size,
batch_size=3,
class_mode='categorical')
test_datagen = ImageDataGenerator(rescale=1. / 255)
test_data = test_datagen.flow_from_directory(group_folder_path + 'test',
target_size=img_size,
batch_size=3,
class_mode='categorical')
input_tensor = Input(shape=(220, 220, 3), dtype='float32', name='input')
x = layers.Conv2D(64, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(0.01))(input_tensor)
x = layers.Conv2D(64, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(0.01))(x)
x = layers.MaxPooling2D((2, 2))(x)
x = layers.Conv2D(128, (3, 3),
activation='relu',
def GhostNet(self):
inputdata = Input(shape=(self.size, self.size, self.channel))
x = Conv2D(16, (3, 3),
strides=(2, 2),
padding='same',
data_format='channels_last',
activation=None,
use_bias=False)(inputdata)
x = BatchNormalization(axis=-1)(x)
x = Activation('relu')(x)
x = GhostBottleneck(x, 3, 1, 16, 16, 2, False)
x = GhostBottleneck(x, 3, 2, 48, 24, 2, False)
x = GhostBottleneck(x, 3, 1, 72, 24, 2, False)
x = GhostBottleneck(x, 5, 2, 72, 40, 2, True)
x = GhostBottleneck(x, 5, 1, 120, 40, 2, True)
x = GhostBottleneck(x, 3, 2, 240, 80, 2, False)
x = GhostBottleneck(x, 3, 1, 200, 80, 2, False)
x = GhostBottleneck(x, 3, 1, 184, 80, 2, False)
x = GhostBottleneck(x, 3, 1, 184, 80, 2, False)
x = GhostBottleneck(x, 3, 1, 480, 112, 2, True)
x = GhostBottleneck(x, 3, 1, 672, 112, 2, True)
x = GhostBottleneck(x, 5, 2, 672, 160, 2, True)
x = GhostBottleneck(x, 5, 1, 960, 160, 2, False)
x = GhostBottleneck(x, 5, 1, 960, 160, 2, True)
x = GhostBottleneck(x, 5, 1, 960, 160, 2, False)
x = GhostBottleneck(x, 5, 1, 960, 160, 2, True)
x = Conv2D(960, (1, 1),
strides=(1, 1),
padding='same',
data_format='channels_last',
activation=None,
use_bias=False)(x)
x = BatchNormalization(axis=-1)(x)
x = Activation('relu')(x)
x = GlobalAveragePooling2D(data_format='channels_last')(x)
#x = Reshape((1,1,int(x.shape[1])))(x)
x = Lambda(reshapes)(x)
x = Conv2D(1280, (1, 1),
strides=(1, 1),
padding='same',
data_format='channels_last',
activation=None,
use_bias=False)(x)
x = BatchNormalization(axis=-1)(x)
x = Activation('relu')(x)
x = Dropout(0.05)(x)
x = Conv2D(self.numclass, (1, 1),
strides=(1, 1),
padding='same',
data_format='channels_last',
activation=None,
use_bias=False)(x)
#x = K.squeeze(x,1)
#x = K.squeeze(x,1)
#out = softmax(x)
x = Lambda(squeezes)(x)
x = Lambda(squeezes)(x)
out = Lambda(softmaxs)(x)
model = Model(inputdata, out)
plot_model(model,
to_file=os.path.join('weight', "GhostNet_model.png"),
show_shapes=True)
model.compile(loss='categorical_crossentropy',
optimizer=Adam(),
metrics=['accuracy'])
return model
img_array = np.array(img)
img_array = np.expand_dims(img_array, axis=0)
# img_array = np.expand_dims(img_array, axis=3)
i1 = vea_model.predict(img_array)
i1 = i1[0]
i1 = np.array(i1).reshape(img_size, img_size, 3)
img1 = image.array_to_img(i1)
img1.show()
if __name__ == '__main__':
#--------------------- 创建VEA 开始 ----------------------#
input_img = Input(shape=img_shape)
# 编码层
z_mean, z_log_var, shape_before_flattening = enCoder(input_img)
z = layers.Lambda(sampling)(
[z_mean,
z_log_var]) # 相当于直接调用z = sampling(z_mean, z_log_var), z就是潜在空间中的一个点
# 解码层
m_deCoder = getDeCoder(z, shape_before_flattening)
# m_deCoder.summary()
z_decoded = m_deCoder(z) # 得到解码后的z
# 损失组合层
input_img1 = MyLayer()([input_img, z_decoded])
# 构建模型
def fit_cnn():
X_train = train_embed
y_train = np.array(train_labels)
X_test = test_embed
y_test = test_labels
X_train = X_train.reshape(
(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1))
X_test = X_test.reshape(
(X_test.shape[0], X_test.shape[1], X_test.shape[2], 1))
y_train, y_test = convert_one_hot(y_train, y_test)
sequence_length = train_embed.shape[1] # 60
embedding_dim = train_embed.shape[2]
filter_sizes = [2, 3, 4, 5]
num_filters = 64
drop = 0.6
input_shape = train_embed[0].shape
epochs = 1000
batch_size = 64
inputs = Input(shape=(sequence_length, embedding_dim, 1), dtype='float32')
batch_norm = BatchNormalization(input_shape=input_shape)(inputs)
conv_0 = Conv2D(num_filters,
kernel_size=(filter_sizes[0], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
conv_1 = Conv2D(num_filters,
kernel_size=(filter_sizes[1], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
conv_2 = Conv2D(num_filters,
kernel_size=(filter_sizes[2], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
conv_3 = Conv2D(num_filters,
kernel_size=(filter_sizes[3], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
maxpool_0 = MaxPool2D(pool_size=(sequence_length - filter_sizes[0] + 1, 1),
strides=(1, 1),
padding='valid')(conv_0)
maxpool_1 = MaxPool2D(pool_size=(sequence_length - filter_sizes[1] + 1, 1),
strides=(1, 1),
padding='valid')(conv_1)
maxpool_2 = MaxPool2D(pool_size=(sequence_length - filter_sizes[2] + 1, 1),
strides=(1, 1),
padding='valid')(conv_2)
maxpool_3 = MaxPool2D(pool_size=(sequence_length - filter_sizes[3] + 1, 1),
strides=(1, 1),
padding='valid')(conv_3)
concatenated_tensor = Concatenate(axis=1)(
[maxpool_0, maxpool_1, maxpool_2, maxpool_3])
flatten = Flatten()(concatenated_tensor)
dropout = Dropout(drop)(flatten)
output = Dense(units=3,
activation='softmax',
kernel_regularizer=regularizers.l2(0.1))(dropout)
# this creates a model that includes
model = Model(inputs=inputs, outputs=output)
adam = Adam(lr=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(optimizer=adam,
loss='categorical_crossentropy',
metrics=['accuracy'])
print("Traning Model...")
model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_test, y_test))
model.save("model/cnn.h5")
return model
# Read training labels
training_labels = LabelDataset(training_labels_file)
# Read testset
testset = ImageDataset(testset_file)
# Read test labels
test_labels = LabelDataset(test_labels_file)
experiments = list()
repeat = True
# Input type construction
x_dimension, y_dimension = training_set.getImageDimensions()
inChannel = 1
input_img = Input(shape=(x_dimension, y_dimension, inChannel))
# Split dataset into train and validation datasets
X_train, X_validation, y_train, y_validation = train_test_split(
training_set.getImagesNormalized(),
to_categorical(training_labels.get_labels(),
num_classes=training_labels.num_classes()),
test_size=0.2,
random_state=13)
while repeat:
# User Arguments
convolutional_layers = int(input("Number of convolutional layers: "))
convolutional_filter_size = int(input("Convolutional filter size: "))
convolutional_filters_per_layer = []
def build_model(self):
self.layer['input'] = Input(shape=(self.input_shape, ))
self.layer['pre_scaling'] = Scaling(scale_min1=self.scale_min1,
scale_max1=self.scale_max1,
scale_min2=self.scale_min2,
scale_max2=self.scale_max2,
name='pre_scaling')(
self.layer['input'])
self.layer['pre_reshaping'] = Reshape(
target_shape=[1, 1, self.input_shape],
name='pre_reshaping')(self.layer['pre_scaling'])
self.layer['pre_tiling'] = Tiling(units=self.input_shape,
name='pre_tiling')(
self.layer['pre_reshaping'])
self.layer['cnn_conv_1'] = Conv2D(
filters=[AvgFilter(), MaxFilter(),
StdDevFilter()],
window=self.conv_1_window,
padding='same',
use_bias=False,
kernel_size=(self.input_shape, self.input_shape),
data_format='channels_first',
name='cnn_conv_1')(self.layer['pre_tiling'])
self.layer['cnn_activation_1'] = Activation(
activation=sigmoid,
name='cnn_activation_1')(self.layer['cnn_conv_1'])
self.layer['cnn_conv_2'] = Conv2D(
filters=[AvgFilter(), MaxFilter(),
StdDevFilter()],
window=self.conv_2_window,
padding='same',
use_bias=False,
kernel_size=(self.input_shape, self.input_shape),
data_format='channels_first',
name='cnn_conv_2')(self.layer['cnn_activation_1'])
self.layer['cnn_activation_2'] = Activation(
activation=sigmoid,
name='cnn_activation_2')(self.layer['cnn_conv_2'])
self.layer['cnn_pooling_1'] = MaxPooling2D(
pool_size=(self.pool_1_size, self.pool_1_size),
padding='same',
data_format='channels_first',
name='cnn_pooling_1')(self.layer['cnn_activation_2'])
self.layer['cnn_conv_3'] = Conv2D(
filters=[AvgFilter(), MaxFilter(),
StdDevFilter()],
window=self.conv_3_window,
padding='same',
use_bias=False,
kernel_size=(self.input_shape, self.input_shape),
data_format='channels_first',
name='cnn_conv_3')(self.layer['cnn_pooling_1'])
self.layer['cnn_activation_3'] = Activation(
activation=sigmoid,
name='cnn_activation_3')(self.layer['cnn_conv_3'])
self.layer['cnn_pooling_2'] = MaxPooling2D(
pool_size=(self.pool_2_size, self.pool_2_size),
padding='same',
data_format='channels_first',
name='cnn_pooling_2')(self.layer['cnn_activation_3'])
self.layer['bridge_flatten'] = Flatten(name='bridge_flatten')(
self.layer['cnn_pooling_2'])
self.layer['elm_1_dense_1'] = Dense(
units=self.elm_1_dense_1_units,
activation=None,
use_bias=True,
kernel_initializer=Unifinv(minval=self.elm_1_dense_1_kernel_min,
maxval=self.elm_1_dense_1_kernel_max),
bias_initializer=RandomUniform(minval=self.elm_1_dense_1_bias_min,
maxval=self.elm_1_dense_1_bias_max),
trainable=False,
name='elm_1_dense_1')(self.layer['bridge_flatten'])
self.layer['elm_1_activation_1'] = Activation(
activation=sigmoid,
name='elm_1_activation_1')(self.layer['elm_1_dense_1'])
self.layer['elm_1_dense_2'] = Dense(
units=self.category_num,
activation=None,
use_bias=False,
kernel_initializer=Zeros(),
trainable=False,
name='elm_1_dense_2')(self.layer['elm_1_activation_1'])
self.layer['elm_2_dense_1'] = Dense(
units=self.elm_2_dense_1_units,
activation=None,
use_bias=True,
kernel_initializer=Unifinv(minval=self.elm_2_dense_1_kernel_min,
maxval=self.elm_2_dense_1_kernel_max),
bias_initializer=RandomUniform(minval=self.elm_2_dense_1_bias_min,
maxval=self.elm_2_dense_1_bias_max),
trainable=False,
name='elm_2_dense_1')(self.layer['bridge_flatten'])
self.layer['elm_2_activation_1'] = Activation(
activation=sigmoid,
name='elm_2_activation_1')(self.layer['elm_2_dense_1'])
self.layer['elm_2_dense_2'] = Dense(
units=self.category_num,
activation=None,
use_bias=False,
kernel_initializer=Zeros(),
trainable=False,
name='elm_2_dense_2')(self.layer['elm_2_activation_1'])
self.layer['elm_3_dense_1'] = Dense(
units=self.elm_3_dense_1_units,
activation=None,
use_bias=True,
kernel_initializer=Unifinv(minval=self.elm_3_dense_1_kernel_min,
maxval=self.elm_3_dense_1_kernel_max),
bias_initializer=RandomUniform(minval=self.elm_3_dense_1_bias_min,
maxval=self.elm_3_dense_1_bias_max),
trainable=False,
name='elm_3_dense_1')(self.layer['bridge_flatten'])
self.layer['elm_3_activation_1'] = Activation(
activation=sigmoid,
name='elm_3_activation_1')(self.layer['elm_3_dense_1'])
self.layer['elm_3_dense_2'] = Dense(
units=self.category_num,
activation=None,
use_bias=False,
kernel_initializer=Zeros(),
trainable=False,
name='elm_3_dense_2')(self.layer['elm_3_activation_1'])
self.layer['fully_connected_concat'] = Concatenate(
name='fully_connected_concat')([
self.layer['elm_1_dense_2'], self.layer['elm_2_dense_2'],
self.layer['elm_3_dense_2']
])
self.layer['fully_connected_reshape'] = Reshape(
target_shape=(self.fully_connected_num, self.category_num),
name='fully_connected_reshape')(
self.layer['fully_connected_concat'])
self.layer['fully_connected_merge'] = MergeCategorical(
categorical_length=self.category_num,
name='fully_connected_merge')(
self.layer['fully_connected_reshape'])
def get_model(n_classes, input_height=224, input_width=224, weights=None):
n_filters = 16
kernel_size = 3
dropout = 0.25
img_input = Input(shape=(input_height, input_width, 3)) # Assume 224,224,3
# Start with 224x224x3. Apply 3x3x16 Convolution, padding same and 2x2 Pooling. New dimensions:
# 112x112x16
c1 = conv2d_block(n_filters=n_filters * 1,
kernel_size=kernel_size,
input_tensor=img_input)
p1 = MaxPooling2D((2, 2))(c1)
d1 = Dropout(dropout)(p1)
# 112x112x16. Apply 3x3x32 Convolution, padding same and 2x2 Pooling. New dimensions:
# 56x56x32
c2 = conv2d_block(n_filters=n_filters * 2,
kernel_size=kernel_size,
input_tensor=d1)
p2 = MaxPooling2D((2, 2))(c2)
d2 = Dropout(dropout)(p2)
# 56x56x32. Apply 3x3x64 Convolution, padding same and 2x2 Pooling. New dimensions:
# 28x28x64
c3 = conv2d_block(n_filters=n_filters * 4,
kernel_size=kernel_size,
input_tensor=d2)
p3 = MaxPooling2D((2, 2))(c3)
d3 = Dropout(dropout)(p3)
# 28x28x64. Apply 3x3x128 Convolution, padding same and 2x2 Pooling. New dimensions:
# 14x14x128
c4 = conv2d_block(n_filters=n_filters * 8,
kernel_size=kernel_size,
input_tensor=d3)
p4 = MaxPooling2D((2, 2))(c4)
d4 = Dropout(dropout)(p4)
# 14x14x128. Apply 3x3x256 Convolution, padding same. New dimensions: 14x14x256
c5 = conv2d_block(n_filters=n_filters * 16,
kernel_size=kernel_size,
input_tensor=d4)
# Upsampling part starts here
# Start with dimensions 14x14x256
u6 = Conv2DTranspose(n_filters * 8,
kernel_size=(kernel_size, kernel_size),
strides=(2, 2),
padding='same')(c5)
u6 = Concatenate()([u6, c4])
d6 = Dropout(dropout)(u6)
c6 = conv2d_block(n_filters * 8, kernel_size=3, input_tensor=d6)
u7 = Conv2DTranspose(n_filters * 4,
kernel_size=(kernel_size, kernel_size),
strides=(2, 2),
padding='same')(c6)
u7 = Concatenate()([u7, c3])
d7 = Dropout(dropout)(u7)
c7 = conv2d_block(n_filters * 4, kernel_size=3, input_tensor=d7)
u8 = Conv2DTranspose(n_filters * 2,
kernel_size=(kernel_size, kernel_size),
strides=(2, 2),
padding='same')(c7)
u8 = Concatenate()([u8, c2])
d8 = Dropout(dropout)(u8)
c8 = conv2d_block(n_filters * 2, kernel_size=3, input_tensor=d8)
u9 = Conv2DTranspose(n_filters * 1,
kernel_size=(kernel_size, kernel_size),
strides=(2, 2),
padding='same')(c8)
u9 = Concatenate()([u9, c1])
d9 = Dropout(dropout)(u9)
c9 = conv2d_block(n_filters * 1, kernel_size=3, input_tensor=d9)
# Apply 1x1 convolution
outputs = Conv2DTranspose(n_classes, (1, 1), activation='softmax')(c9)
model = Model(inputs=[img_input], outputs=[outputs])
model.summary()
if weights is not None:
model.load_weights(weights)
opt = Adam(lr=1E-5, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
return model
print(labels.shape)
#################### train and test split
x_train_lstm_daily = samples_lstm_daily[:4000]
x_test_lstm_daily = samples_lstm_daily[4000:]
y_train = labels[:4000]
y_test = labels[4000:]
print(x_train_lstm_daily.shape,y_train.shape)
print(x_test_lstm_daily.shape,y_test.shape)
plt.figure(figsize=(20,10))
plt.plot(y_test,'r')
################################################ Model: daily Block - Multi-STGCnet
input130 = Input(shape=(pre,1), dtype='float')
input131 = layers.LSTM(35,return_sequences=True)(input130)
input132 = layers.LSTM(12)(input131)
output13 = layers.Dense(1,activation='relu')(input132)
model = models.Model(inputs=[input130],outputs=[output13])
model.summary()
model.compile(optimizer='rmsprop',loss='mae',metrics=['mae','mse','mape'])
callbacks_list = [
keras.callbacks.ModelCheckpoint(filepath='lstm_daily.h5',
monitor='val_loss',
save_best_only=True,)
################################################ Model training
epochs = 1000
H = model.fit([x_train_lstm_daily], y_train,callbacks=callbacks_list,batch_size=interval_batch,epochs=epochs,validation_data=([x_test_lstm_daily],y_test))
x = up_conv(x, [512, 256])
source = vgg16.get_layer('block4_conv3').output
x = Interpolate(target_layer=source, name='resize_2')(x)
x = concatenate([x, source])
x = up_conv(x, [256, 128])
source = vgg16.get_layer('block3_conv3').output
x = Interpolate(target_layer=source, name='resize_3')(x)
x = concatenate([x, source])
x = up_conv(x, [128, 64])
source = vgg16.get_layer('block2_conv2').output
x = Interpolate(target_layer=source, name='resize_4')(x)
x = concatenate([x, source])
feature = up_conv(x, [64, 32])
x = conv_cls(feature, 2)
region_score = Lambda(lambda layer: layer[:, :, :, 0])(x)
affinity_score = Lambda(lambda layer: layer[:, :, :, 1])(x)
return region_score, affinity_score
if __name__ == '__main__':
input_image = Input(shape=(512, 512, 3))
region, affinity = VGG16_UNet(input_tensor=input_image, weights=None)
model = Model(input_image, [region, affinity], name='vgg16_unet')
model.summary()
import imageio
from keras.optimizers import Adam
import time
from skimage.io import imread
import cv2
"""## **The Generator Network**"""
# Hyperparameters required for generator network
residual_blocks = 16
momentum = 0.8
input_shape = (64, 64, 3)
# Input layer to feed input to the network of a shape of (64,64,3)
input_layer = Input(shape=input_shape)
input_layer
# Adding the pre-residual block (2D convolution layer)
#filters: 64, kerel size: 9, strides: 1, Padding: same, Activation: relu
gen1 = Conv2D(filters=64,
kernel_size=9,
strides=1,
padding='same',
activation='relu')(input_layer)
# Method with the entire code for the residual block
def residual_block(x):
def __init__(self, classes=6, dim=(224, 224, 3)):
self.classes = classes
self.dim = dim
self.input_tensor = Input(shape=self.dim,
dtype='float32',
name='input')
