def create_model(model_size):
my_new_model = Sequential()
if model_size == 'L':
resnet_weights_path = 'input/resnet50/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5'
resnet = ResNet50(include_top=False,
pooling='avg',
weights=resnet_weights_path)
#resnet.summary()
my_new_model.add(resnet)
my_new_model.layers[0].trainable = False
else:
vgg_weights_path = 'input/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5'
vgg = VGG16(include_top=False, weights=vgg_weights_path)
vgg.summary()
my_new_model.add(vgg)
my_new_model.add(GlobalAveragePooling2D())
my_new_model.layers[0].trainable = False
my_new_model.layers[1].trainable = False
my_new_model.add(Dense(NUM_CLASSES, activation='softmax'))
# Say no to train first layer (ResNet) model. It is already trained
opt = optimizers.adam()
my_new_model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
return my_new_model
def create_model(self):
model = Sequential()
model.add(Dense(512, activation=relu, input_dim=self.state_size))
model.add(Dense(512, activation=relu))
model.add(Dense(self.action_size, activation=softmax))
model.compile(optimizer=adam(), loss=categorical_crossentropy)
return model
def train_test():
data_frame = pd.read_csv(os.path.join(os.path.dirname(__file__),
'Crops.csv'),
sep=",")
data_frame = data_frame.reindex(np.random.permutation(data_frame.index))
selected_features = data_frame[["Temperature", "Humidity"]]
scaler = MinMaxScaler()
scaler.fit(selected_features)
selected_features = scaler.transform(selected_features)
target_class = data_frame['Crop']
label_encoder = LabelEncoder()
label_encoder.fit(target_class)
labels = label_encoder.transform(target_class)
encoded_labels = np_utils.to_categorical(labels)
X_train, X_test, y_train, y_test = train_test_split(
np.asarray(selected_features), encoded_labels, test_size=0.33)
checkpoint = ModelCheckpoint('output/{val_acc:.4f}.hdf5',
monitor='val_acc',
verbose=1,
save_best_only=True,
save_weights_only=True,
mode='auto')
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', name="dense_in"))
model.add(Dense(100, activation='relu', name="dense_in_2"))
model.add(Dense(3, activation='softmax', name="dense_in_3"))
optimizer = adam(lr=0.0001)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['acc'])
tbCallBack = TensorBoard(log_dir="Graph",
histogram_freq=0,
write_graph=True,
write_images=True)
model.fit(X_train,
y_train,
epochs=100,
batch_size=5,
validation_data=(X_test, y_test),
verbose=2,
callbacks=[tbCallBack, checkpoint])
keras.models.save_model(model, "saved_model.h5", overwrite=True)
model.save("best.h5", overwrite=True, save_weights_only=True)
predict = model.predict(np.asarray([0.6, 0.8]).reshape(1, -1))
def structureModel(self):
Inputs = layers.Input(shape=self._inputShape, batch_size=self._iBatchSize)
Con1 = layers.Conv2D(64, (3, 3), name='Con1', activation='relu', padding='SAME', input_shape=self._inputShape, strides=1)(Inputs)
Con2 = layers.Conv2D(64, (3, 3), name='Con2', activation='relu', padding='SAME', strides=1)(Con1)
Side1 = sideBranch(Con2, 1)
MaxPooling1 = layers.MaxPooling2D((2, 2), name='MaxPooling1', strides=2, padding='SAME')(Con2)
# outputs1
Con3 = layers.Conv2D(128, (3, 3), name='Con3', activation='relu', padding='SAME', strides=1)(MaxPooling1)
Con4 = layers.Conv2D(128, (3, 3), name='Con4', activation='relu', padding='SAME', strides=1)(Con3)
Side2 = sideBranch(Con4, 2)
MaxPooling2 = layers.MaxPooling2D((2, 2), name='MaxPooling2', strides=2, padding='SAME')(Con4)
# outputs2
Con5 = layers.Conv2D(256, (3, 3), name='Con5', activation='relu', padding='SAME', strides=1)(MaxPooling2)
Con6 = layers.Conv2D(256, (3, 3), name='Con6', activation='relu', padding='SAME', strides=1)(Con5)
Con7 = layers.Conv2D(256, (3, 3), name='Con7', activation='relu', padding='SAME', strides=1)(Con6)
Side3 = sideBranch(Con7, 4)
MaxPooling3 = layers.MaxPooling2D((2, 2), name='MaxPooling3', strides=2, padding='SAME')(Con7)
# outputs3
Con8 = layers.Conv2D(512, (3, 3), name='Con8', activation='relu', padding='SAME', strides=1)(MaxPooling3)
Con9 = layers.Conv2D(512, (3, 3), name='Con9', activation='relu', padding='SAME', strides=1)(Con8)
Con10 = layers.Conv2D(512, (3, 3), name='Con10', activation='relu', padding='SAME', strides=1)(Con9)
Side4 = sideBranch(Con10, 8)
MaxPooling4 = layers.MaxPooling2D((2, 2), name='MaxPooling4', strides=2, padding='SAME')(Con10)
# outputs4
Con11 = layers.Conv2D(512, (3, 3), name='Con11', activation='relu', padding='SAME', strides=1)(MaxPooling4)
Con12 = layers.Conv2D(512, (3, 3), name='Con12', activation='relu', padding='SAME', strides=1)(Con11)
Con13 = layers.Conv2D(512, (3, 3), name='Con13', activation='relu', padding='SAME', strides=1)(Con12)
Side5 = sideBranch(Con13, 16)
Fuse = layers.Concatenate(axis=-1)([Side1, Side2, Side3, Side4, Side5])
# learn fusion weight
Fuse = layers.Conv2D(1, (1, 1), name='Fuse', padding='SAME', use_bias=False, activation=None)(Fuse)
output1 = layers.Activation('sigmoid', name='output1')(Side1)
output2 = layers.Activation('sigmoid', name='output2')(Side2)
output3 = layers.Activation('sigmoid', name='output3')(Side3)
output4 = layers.Activation('sigmoid', name='output4')(Side4)
output5 = layers.Activation('sigmoid', name='output5')(Side5)
output6 = layers.Activation('sigmoid', name='output6')(Fuse)
outputs = [output1, output2, output3, output4, output5, output6]
self._pModel = Model(inputs=Inputs, outputs=outputs)
pAdam = optimizers.adam(lr=0.0001)
self._pModel.compile(loss={'output1': classBalancedSigmoidCrossEntropy,
'output2': classBalancedSigmoidCrossEntropy,
'output3': classBalancedSigmoidCrossEntropy,
'output4': classBalancedSigmoidCrossEntropy,
'output5': classBalancedSigmoidCrossEntropy,
'output6': classBalancedSigmoidCrossEntropy
}, optimizer=pAdam)
def init_model(self):
# initialize model
self.model = cnn_model(input_shape=self.x_train[0].shape[1:][0],
num_classes=self.num_classes,
num_features=self.num_features,
embedding_matrix=self.embedding_matrix,
filters=64,
kernel_sizes=[3, 4, 5],
dropout_rate=0.4,
embedding_trainable=True,
l2_lambda=1.0)
loss = 'sparse_categorical_crossentropy'
optimizer = adam(lr=1e-3)
self.model.compile(optimizer=optimizer, loss=loss, metrics=['acc'])
def adam_optimizer():
return adam(lr=0.0002, beta_1=0.5)
def structureModel(self):
weightDecay = 0.00001
Inputs = layers.Input(shape=self._inputShape,
batch_size=self._iBatchSize)
Con1 = layers.Conv2D(64, (3, 3),
name='Con1',
activation='relu',
padding='SAME',
input_shape=self._inputShape,
strides=1,
kernel_regularizer=l2(weightDecay))(Inputs)
Con2 = layers.Conv2D(64, (3, 3),
name='Con2',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con1)
Side1 = sideBranch(Con2, 1)
MaxPooling1 = layers.MaxPooling2D((2, 2),
name='MaxPooling1',
strides=2,
padding='SAME')(Con2)
# outputs1
Con3 = layers.Conv2D(128, (3, 3),
name='Con3',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(MaxPooling1)
Con4 = layers.Conv2D(128, (3, 3),
name='Con4',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con3)
Side2 = sideBranch(Con4, 2)
MaxPooling2 = layers.MaxPooling2D((2, 2),
name='MaxPooling2',
strides=2,
padding='SAME')(Con4)
# outputs2
Con5 = layers.Conv2D(256, (3, 3),
name='Con5',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(MaxPooling2)
Con6 = layers.Conv2D(256, (3, 3),
name='Con6',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con5)
Con7 = layers.Conv2D(256, (3, 3),
name='Con7',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con6)
Side3 = sideBranch(Con7, 4)
MaxPooling3 = layers.MaxPooling2D((2, 2),
name='MaxPooling3',
strides=2,
padding='SAME')(Con7)
# outputs3
Con8 = layers.Conv2D(512, (3, 3),
name='Con8',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(MaxPooling3)
Con9 = layers.Conv2D(512, (3, 3),
name='Con9',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con8)
Con10 = layers.Conv2D(512, (3, 3),
name='Con10',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con9)
Side4 = sideBranch(Con10, 8)
MaxPooling4 = layers.MaxPooling2D((2, 2),
name='MaxPooling4',
strides=2,
padding='SAME')(Con10)
# outputs4
Con11 = layers.Conv2D(512, (3, 3),
name='Con11',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(MaxPooling4)
Con12 = layers.Conv2D(512, (3, 3),
name='Con12',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con11)
Con13 = layers.Conv2D(512, (3, 3),
name='Con13',
activation='relu',
padding='SAME',
strides=1,
kernel_regularizer=l2(weightDecay))(Con12)
Side5 = sideBranch(Con13, 16)
Fuse = layers.Concatenate(axis=-1)([Side1, Side2, Side3, Side4, Side5])
# learn fusion weight
fuseInitWeight = initializers.constant(0.2)
Fuse = layers.Conv2D(1, (1, 1),
name='Fuse',
padding='SAME',
use_bias=False,
activation=None,
kernel_initializer=fuseInitWeight,
kernel_regularizer=l1(weightDecay))(Fuse)
# output1 = layers.Activation('sigmoid', name='output1')(Side1)
# output2 = layers.Activation('sigmoid', name='output2')(Side2)
# output3 = layers.Activation('sigmoid', name='output3')(Side3)
# output4 = layers.Activation('sigmoid', name='output4')(Side4)
# output5 = layers.Activation('sigmoid', name='output5')(Side5)
output6 = layers.Activation('sigmoid', name='output6')(Fuse)
outputs = [output6
] # [output1, output2, output3, output4, output5, output6]
self._pModel = Model(inputs=Inputs, outputs=outputs)
pOptimizer = optimizers.adam(lr=0.0001)
pOptimizer = optimizers.SGD(lr=0.000001, decay=0., momentum=0.9)
pOptimizer = tf.optimizers.SGD(lr=0.5, decay=0., momentum=0.9)
# pOptimizer = monitorSGD(lr=0.000001, decay=0., momentum=0.9)
# grads = tf.gradients(classBalancedSigmoidCrossEntropy, self._pModel.trainable_weights)
# pSGD = optimizers.SGD()
self._pModel.compile(
loss={
# 'output1': classBalancedSigmoidCrossEntropy,
# 'output2': classBalancedSigmoidCrossEntropy,
# 'output3': classBalancedSigmoidCrossEntropy,
# 'output4': classBalancedSigmoidCrossEntropy,
# 'output5': classBalancedSigmoidCrossEntropy,
'output6': classBalancedSigmoidCrossEntropy
},
optimizer=pOptimizer)
# Initialize the Q-network with random weights θ
q_net = Sequential([
Dense(10, input_shape=(
None,
4,
)),
Activation('relu'),
Dense(10),
Activation('relu'),
Dense(2),
Activation('linear')
])
# we use the adam optimizer because it generally does well without needing much tuning
# the loss is mse because it has been defined as such in the Minh et al. paper
q_net.compile(optimizer=adam(lr=stepsize), loss=mse, metrics=['accuracy'])
# Initialize the weights of the target network with θ⋆ = θ
target_net = Sequential([
Dense(10, input_shape=(
None,
4,
)),
Activation('relu'),
Dense(10),
Activation('relu'),
Dense(2),
Activation('linear')
])
target_net.compile(optimizer=adam(lr=stepsize), loss=mse, metrics=['accuracy'])
target_net.set_weights(q_net.get_weights())
def build_bcnn(
all_trainable=False,
size_height=448,
size_width=448,
no_class=200,
no_last_layer_backbone=17,
# no_last_layer_backbone=-1,
name_optimizer='sgd',
learning_rate=1.0,
decay_learning_rate=0.0,
decay_weight_rate=0.0,
name_initializer='glorot_normal',
name_activation='softmax',
name_loss='categorical_crossentropy'
):
'''Build Bilinear CNN.
Detector and extractor are both VGG16.
Args:
all_trainable: fix or unfix VGG16 layers.
size_height: default 448.
size_width: default 448.
no_class: number of prediction classes.
no_last_layer_backbone: number of VGG16 backbone layer.
name_optimizer: optimizer method.
learning_rate: learning rate.
decay_learning_rate: learning rate decay.
decay_weight_rate: l2 normalization decay rate.
name_initializer: initializer method.
name_activation: activation method.
name_loss: loss function.
Returns:
Bilinear CNN model.
'''
##########################
# Load pre-trained model #
##########################
# Load model
input_tensor = Input(shape=[size_height, size_width, 3])
pre_train_model = VGG16(
input_tensor=input_tensor,
include_top=False,
weights='imagenet')
# pre_train_model = ResNet50(
# input_tensor=input_tensor,
# include_top=False,
# weights='imagenet')
# Pre-trained weights
for layer in pre_train_model.layers:
layer.trainable = all_trainable
######################
# Combine two models #
######################
# Extract features form detecotr
model_detector = pre_train_model
output_detector = model_detector.layers[no_last_layer_backbone].output
shape_detector = model_detector.layers[no_last_layer_backbone].output_shape
# Extract features from extractor
model_extractor = pre_train_model
output_extractor = model_extractor.layers[no_last_layer_backbone].output
shape_extractor = model_extractor.layers[no_last_layer_backbone].output_shape
# Reshape tensor to (minibatch_size, total_pixels, filter_size)
output_detector = Reshape(
[shape_detector[1]*shape_detector[2], shape_detector[-1]])(output_detector)
output_extractor = Reshape(
[shape_extractor[1]*shape_extractor[2], shape_extractor[-1]])(output_extractor)
# Outer-products
x = Lambda(_outer_product)([output_detector, output_extractor])
# Reshape tensor to (minibatch_size, filter_size_detector*filter_size_extractor)
x = Reshape([shape_detector[-1]*shape_extractor[-1]])(x)
# Signed square-root
x = Lambda(_signed_sqrt)(x)
# L2 normalization
x = Lambda(_l2_normalize)(x)
###############################
# Attach full-connected layer #
###############################
if name_initializer is not None:
name_initializer = eval(name_initializer+'()')
# FC layer
x = Dense(
units=no_class,
kernel_initializer=name_initializer,
kernel_regularizer=l2(decay_weight_rate))(x)
output_tensor = Activation(name_activation)(x)
#################
# Compile model #
#################
model_bcnn = Model(inputs=[input_tensor], outputs=[output_tensor])
# Optimizer
if name_optimizer == 'adam':
optimizer = adam(lr=learning_rate, decay=decay_learning_rate)
elif name_optimizer == 'rmsprop':
optimizer = RMSprop(lr=learning_rate, decay=decay_learning_rate)
elif name_optimizer == 'sgd':
optimizer = SGD(lr=learning_rate, decay=decay_learning_rate, momentum=0.9, nesterov=None)
else:
raise RuntimeError('Optimizer should be one of Adam, RMSprop and SGD.')
# Compile
model_bcnn.compile(loss=name_loss, optimizer=optimizer, metrics=['accuracy'])
# print('-------- Mode summary --------')
# print(model_bcnn.summary())
# print('------------------------------')
return model_bcnn
patience = round(NUM_EPOCHS / NUM_BATCH)
min_delta = 0.001
# welches Model wird trainiert
# set false fall das Model nicht trainiert sein wird
simple_model = True
simple_vgg = True
# Das training wird durch gelaufen werden mit Data_generator
# set false wenn es auf Data-generator vertichtet sein werden
data_gen = True
ohne_gen = True
# Das training Parametern
loss = 'categorical_crossentropy'
metrics = ["accuracy"]
optimizer = optimizers.adam(lr=lernrate)
# config gpu
# tensorflow allocation memory
tf_aloc = 0.5
max_batch_size = 2
max_workspace_size_bytes = 2 * (10**9)
# FP32 FP16 int8
precision_mode = "FP16"
# tensorflow model
output_model = {}
input_model = {}
def build_model():
"""
Function that build the CNN + LSTM network
"""
with tf.name_scope('CNN_LSTM'):
model = Sequential()
with tf.name_scope('Conv1'):
model.add(
TimeDistributed(Convolution2D(16, (5, 5),
padding='same',
strides=(2, 2)),
input_shape=(15, 16, 3200, 1),
name='Conv1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
with tf.name_scope('Conv2'):
model.add(
TimeDistributed(
Convolution2D(32, (5, 5),
padding='same',
strides=(1, 1),
name='Conv2')))
model.add(Activation('relu'))
with tf.name_scope('Pooling'):
model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2))))
with tf.name_scope('Conv3'):
model.add(
TimeDistributed(
Convolution2D(32, (5, 5),
padding='same',
strides=(1, 1),
name='Conv3')))
model.add(Activation('relu'))
with tf.name_scope('Conv4'):
model.add(
TimeDistributed(
Convolution2D(32, (5, 5),
padding='same',
strides=(1, 1),
name='Conv4')))
model.add(Activation('relu'))
with tf.name_scope('Pooling'):
model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2))))
with tf.name_scope('FC1'):
model.add(TimeDistributed(Flatten(), name='FC1'))
model.add(Activation('relu'))
model.add(TimeDistributed(Dropout(0.25)))
with tf.name_scope('FC2'):
model.add(TimeDistributed(Dense(256), name='FC2'))
model.add(Activation('relu'))
model.add(TimeDistributed(Dropout(0.25)))
with tf.name_scope('LSTM'):
model.add(tf.keras.layers.CuDNNLSTM(64, return_sequences=False))
model.add(Dropout(0.5))
with tf.name_scope('OutputLayer'):
model.add(Dense(2, activation='softmax'))
with tf.name_scope('Optimizer'):
optimizer = optimizers.adam(lr=1e-4, decay=1e-5)
with tf.name_scope('Loss'):
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
return model
x = []
y = []
for i in range(len(test_path)):
x.append(cv2.imread(test_path[i]))
y.append(cv2.imread(test_label[i]))
return np.array(x), np.array(y)
############ READING TRAINING DATA ######################
train_data_dir = '../AOD/train_haze/'
train_label_dir = '../AOD/train_gt/'
batch_size = 1
input_shape = (480, 640, 3)
model = auto_enc.auto_encoder(input_shape)
opt = adam(lr=0.0001)
model.compile(loss='mean_squared_error', optimizer=opt)
model.summary()
############ MODEL SPECIFICATION ##################
epochs = 25
train_path = glob.glob(train_data_dir + '/' + '*.jpg')
label_path = glob.glob(train_label_dir + '/' + '*.jpg')
train_X, test_X, train_Y, test_Y = train_test_split(train_path,
label_path,
test_size=0.05,
shuffle=True)
steps_per_epoch = int(len(train_X) / batch_size)
train_set_size = len(train_X)
print("Train set size is:", train_set_size, ",", "Steps per epochs is:",
model.add(Dense(10, activation='softmax')) # Summary serve para mostras a rede neural detalhadamente. Opcional model.summary() # Definição do otimizador. Nesse caso, foi escolhido o Adam (Gradiente estocástico) usado pelo Multilayer Perceptron # Optimizer do keras: [SGD, RMSprop, Adam, Adadelta, Adagrad, Adamax, Nadam, Ftrl] # lr = Taxa de aprendizado. É um valor que multiplica o valor de ajuste do peso. # Valores altos de lr podem dificultar o treinamento, valores muito baixos tornam a aprendizagem demorada. # Momentum é uma forma de acelerar o treinamento. # Momentum https://machinelearningmastery.com/gradient-descent-with-momentum-from-scratch/ opt = adam(lr=0.01) # Adam é um otimizador baseado em gradiente estocástico com momentum. # https://www.youtube.com/c/Deeplearningai/playlists <- Esse canal tem cursos bem interessantes. # O modelo precisa ser compilado, para isso chamamos compile() # https://medium.com/ensina-ai/uma-explica%C3%A7%C3%A3o-visual-para-fun%C3%A7%C3%A3o-de-custo-binary-cross-entropy-ou-log-loss-eaee662c396c # Metrics é utilizado para avaliar seu modelo. #Accuracy metrics: accuracy, binary_accuracy, categorical_accuracy, top_K_categorical_accuracy, etc.. #Probabilistic metrics: binary_crossentropy, categorical_crossentropy, sparse_categorical_crossentropy, poisson #Regression metrics: mean_squared_error, root_mean_squared_error, mean_absolute_error, mean_absolute_percentage_error
Dense(256,
activation='relu',
input_dim=train_scaled.shape[1],
activity_regularizer=regularizers.l1(0.01)))
model.add(BatchNormalization())
model.add(Dense(128, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(64, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(32, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(8, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(1))
adam = optimizers.adam(lr=LEARNING_RATE)
model.compile(loss='mse', optimizer=adam, metrics=['mae']) # mae == rmse
history = model.fit(x=train_scaled,
y=train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
verbose=2,
validation_split=0.10,
shuffle=True)
prediction = model.predict(test_scaled, batch_size=64,
verbose=1) # batch size here doesn't matter
# save our predictions to submission.csv
save_submission(test_df, prediction, 'key', 'fare_amount', 'submission.csv')