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')