def ejer_3_1(): #fig1, ax1 = plt.subplots() fig2, ax2 = plt.subplots() # ax1.set_title('Exactitud') # ax1.set_xlabel('Épocas') # ax1.set_ylabel('Exactitud') ax2.set_title(' Entrenamiento (-), Validación ($\\cdot\\cdot$)') ax2.set_xlabel('Épocas') ax2.set_ylabel('Pérdida Normalizada') plot_num = 6 epochs_total = 200 ej_vec = np.array([10, 24, 50], dtype=np.int) training_data, target_data = logistic_training(120) ejemplos_color = ['red', 'black', 'blue', 'orange'] for y in range(len(ej_vec)): inp1 = layers.Input(shape=(1, )) x = layers.Dense(5, activation='tanh', use_bias=True, bias_initializer='random_uniform')(inp1) x = layers.Concatenate()([inp1, x]) output = layers.Dense(1, activation='linear', use_bias=True, bias_initializer='random_uniform')(x) model = models.Model(inputs=inp1, outputs=output) #model.summary() sgd = optimizers.SGD(lr=0.008) #print(y)ss model.compile(optimizer=sgd, loss='MSE', metrics=['mse']) size_vec = ej_vec[y] test_size = int(size_vec * 0.5) x_train = training_data[:size_vec] y_train = target_data[:size_vec] x_test = training_data[size_vec:size_vec + test_size] y_test = target_data[size_vec:size_vec + test_size] history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=epochs_total) loss = np.array(history.history['loss']) val_loss = np.array(history.history['val_loss']) epocas = np.arange(len(loss)) #ax1.plot(epocas, acc, label=str(size_vec), color=ejemplos_color[y]) ax2.plot(epocas, val_loss / np.max(val_loss), ':', label=str(test_size), alpha=0.6, color=ejemplos_color[y]) ax2.plot(epocas, loss / np.max(loss), '-', label=str(size_vec), alpha=0.6, color=ejemplos_color[y]) tf.keras.backend.clear_session() ax2.legend(loc=0, title="Ejemplos", ncol=3) #ax1.legend(loc='lower right', title="Ejemplos", ncol=3) #fig1.savefig('../docs/Figs/ejer_5_acc.pdf') fig2.savefig('../docs/Figs/ejer_5_los_gen.pdf') plt.show()
def train(): BATCH_SIZE = 128 EPOCHS = 50 data_train = get_dataset(tfds.Split.TRAIN, BATCH_SIZE) data_test = get_dataset(tfds.Split.TEST, BATCH_SIZE) train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='train_accuracy') test_loss = tf.keras.metrics.Mean(name='test_loss') test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( name='test_accuracy') train_writer = tf.summary.create_file_writer(str(tb_path / 'train')) test_writer = tf.summary.create_file_writer(str(tb_path / 'test')) tf.summary.trace_on(graph=True) model = get_model() loss_function = tf.keras.losses.SparseCategoricalCrossentropy() optimizer = optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True) @tf.function def train_one_step(x, y): with tf.GradientTape() as tape: y_pred = model(x) loss = loss_function(y_true=y, y_pred=y_pred) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss(loss) train_accuracy(y, y_pred) @tf.function def test_one_step(x, y): y_pred = model(x) loss = loss_function(y_true=y, y_pred=y_pred) test_loss(loss) test_accuracy(y, y_pred) for num_epoch in range(EPOCHS): train_loss.reset_states() train_accuracy.reset_states() for batch_num, (images, labels) in enumerate(data_train): train_one_step(images, labels) print(f'Batch {batch_num}', end='\r') with train_writer.as_default(): tf.summary.scalar("loss", train_loss.result(), step=num_epoch) tf.summary.scalar("accuracy", train_accuracy.result(), step=num_epoch) print('Epoch {}, Loss: {}, Accuracy: {}'.format( num_epoch + 1, train_loss.result(), train_accuracy.result() * 100)) if (num_epoch + 1) % 2 == 0: test_loss.reset_states() test_accuracy.reset_states() for batch_num, (images, labels) in enumerate(data_test): test_one_step(images, labels) print(f'Test Batch {batch_num}', end='\r') with test_writer.as_default(): tf.summary.scalar("loss", test_loss.result(), step=num_epoch) tf.summary.scalar("accuracy", test_accuracy.result(), step=num_epoch) print('Test Loss: {}, Test Accuracy: {}'.format( test_loss.result(), test_accuracy.result() * 100)) with train_writer.as_default(): tf.summary.trace_export(name='model_graph', step=0) return model
def get_optimizer(opts): if opts.optimizer == "sgd": return optimizers.SGD(lr=opts.lr) raise Exception("unknown optimizer")
#定义模型,初始化参数 from tensorflow import keras from tensorflow.keras import layers from tensorflow import initializers model = keras.Sequential() model.add( layers.Dense(1, kernel_initializer=initializers.RandomNormal(stddev=0.01))) #定义损失函数 from tensorflow import losses loss = losses.MeanSquaredError() #定义优化算法 from tensorflow.keras import optimizers trainer = optimizers.SGD(learning_rate=0.01) #训练模型 num_epochs = 3 for epoch in range(1, num_epochs + 1): for (batch, (X, y)) in enumerate(dataset): with tf.GradientTape(persistent=True) as t: l = loss(model(X, training=True), y) grads = t.gradient(l, model.trainable_variables) trainer.apply_gradients(zip(grads, model.trainable_variables)) l = loss(model(features), labels) print('epoch %d, loss: %f' % (epoch, l.numpy().mean())) print(model.get_weights())
model = tf.keras.Sequential([ layers.Reshape(target_shape=[28, 28, 1], input_shape=( 28, 28, )), layers.Conv2D(2, 5, padding='same', activation=tf.nn.relu), layers.MaxPooling2D((2, 2), (2, 2), padding='same'), layers.Conv2D(4, 5, padding='same', activation=tf.nn.relu), layers.MaxPooling2D((2, 2), (2, 2), padding='same'), layers.Flatten(), layers.Dense(32, activation=tf.nn.relu), layers.Dropout(rate=0.4), layers.Dense(10) ]) optimizer = optimizers.SGD(learning_rate=0.01, momentum=0.5) def mnist_datasets(): (x_train, y_train), (x_test, y_test) = datasets.mnist.load_data() # Numpy defaults to dtype=float64; TF defaults to float32. Stick with float32. x_train, x_test = x_train / np.float32(255), x_test / np.float32(255) y_train, y_test = y_train.astype(np.int64), y_test.astype(np.int64) train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)) return train_dataset, test_dataset train_ds, test_ds = mnist_datasets() train_ds = train_ds.shuffle(60000).batch(100) test_ds = test_ds.batch(100)
print(e) # classes = ['111', '112', '113', '114', '115', # '221', '222', '223', '224', '225'] classes = ['desert', 'sunset', 'trees', 'mountains', 'sea'] print(classes) model = Sequential() model.add( InceptionResNetV2(include_top=False, pooling='avg', weights='imagenet')) # model.add(Dense(10, activation='sigmoid')) model.add(Dense(len(classes), activation='sigmoid')) model.layers[0].trainable = True model.summary() optimizer = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # optimizer = optimizers.Adam() model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy']) # model.load_weights('/data/backup/pervinco_2020/model/multi_label/2020.05.07_17:27_keras/08-1.00.hdf5') model.load_weights( '/data/backup/pervinco_2020/model/multi_label_cls/2020.05.11_10:33_keras/10-1.00.hdf5' ) # model = tf.keras.models.load_model('/data/backup/pervinco_2020/model/multi_label/test.h5') test_imgs = sorted( glob.glob( '/data/backup/pervinco_2020/datasets/multi_label_cls/test_imgs/*.jpg'))
def run_k_fold(multi_data, X, Y, CLASSES, epoch, MODEL, BATCH_SIZE, num_folds): VALIDATION_ACCURACY = [] VALIDATION_LOSS = [] HISTORY = [] MODEL_NAME = MODEL FOLDS = num_folds EPOCHS = epoch save_dir = os.path.join(os.getcwd(), 'models/') VERBOSE = 1 skf = StratifiedKFold(n_splits=FOLDS, random_state=7, shuffle=True) fold_var = 1 for train_index, val_index in skf.split(X, Y): print("=======EPOCHS ", EPOCHS, " Start--k: ", fold_var) training_data = multi_data.iloc[train_index] validation_data = multi_data.iloc[val_index] print(training_data.shape) print(validation_data.shape) # directory_mover(training_data,"training_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var)) # directory_mover(validation_data,"validation_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var)) # flow_from_dataframe train_data_generator = dataTrainAugmentation().flow_from_dataframe( dataframe=training_data, directory=os.path.join( os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'), target_size=(250, 250), x_col="image_path", y_col="name", batch_size=BATCH_SIZE, class_mode="categorical", shuffle=False) valid_data_generator = dataTrainAugmentation().flow_from_dataframe( dataframe=validation_data, directory=os.path.join( os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'), target_size=(250, 250), x_col="image_path", y_col="name", batch_size=BATCH_SIZE, class_mode="categorical", shuffle=False) model = get_model(MODEL, CLASSES) # rmsprop = RMSprop(lr=1e-3, decay=1e-6) sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['acc']) # CREATE CALLBACKS checkpoint = tf.keras.callbacks.ModelCheckpoint( save_dir + get_model_name(MODEL_NAME, fold_var, BATCH_SIZE), monitor='val_acc', verbose=VERBOSE, save_best_only=True, mode='max') earlystopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=VERBOSE, patience=200) callbacks_list = [checkpoint, earlystopping] ''' STEP_SIZE_TRAIN=train_data_generator.n//train_data_generator.batch_size STEP_SIZE_VALID=valid_data_generator.n//valid_data_generator.batch_size print("STEP_SIZE_TRAIN ",STEP_SIZE_TRAIN) print("STEP_SIZE_VALID ",STEP_SIZE_VALID) history = model.fit_generator(generator=train_data_generator, steps_per_epoch=STEP_SIZE_TRAIN, #steps_per_epoch=training_data.shape[0], validation_data=valid_data_generator, validation_steps=STEP_SIZE_VALID, #validation_steps=validation_data.shape[0], epochs=EPOCHS, #callbacks=callbacks_list, verbose=VERBOSE) ''' history = model.fit(train_data_generator, epochs=EPOCHS, steps_per_epoch=train_data_generator.n // train_data_generator.batch_size, callbacks=callbacks_list, validation_data=valid_data_generator, validation_steps=valid_data_generator.n // valid_data_generator.batch_size, verbose=VERBOSE) HISTORY.append(history) # LOAD BEST MODEL to evaluate the performance of the model model_"+MODEL_NAME+"_"+str(fold_var)+".h5" model.load_weights(os.getcwd() + "/models/model_main2" + MODEL_NAME + "_" + str(fold_var) + '_' + str(BATCH_SIZE) + ".h5") results = model.evaluate(valid_data_generator) # results = model.evaluate_generator(valid_data_generator) results = dict(zip(model.metrics_names, results)) VALIDATION_ACCURACY.append(results['acc']) VALIDATION_LOSS.append(results['loss']) write_results( get_current_time_str() + 'main2_k_fold_' + str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' + str(BATCH_SIZE) + '.txt', VALIDATION_ACCURACY, VALIDATION_LOSS, HISTORY) del history del model tf.keras.backend.clear_session() gc.collect() fold_var += 1
def defineModel(self): verbose = False latentDim = self.latentDim #define encoder model encoder_inputLayer_s = ActorCritic_general.generateActionInputLayer( self.actionSpace) if len(encoder_inputLayer_s) > 1: encoder_inputLayer = concatenate(encoder_inputLayer_s, name='concattenated_input') else: encoder_inputLayer = encoder_inputLayer_s[0] #encoder_intLayer = Dense(latentDim*4,activation='relu')(encoder_inputLayers) encoder_intLayer_last = Dense(latentDim * 2, activation='relu', name='encoding')(encoder_inputLayer) encoder_meanLayer = Dense(latentDim, activation='relu', name='latent_means')(encoder_intLayer_last) encoder_logVarianceLayer = Dense( latentDim, activation='relu', bias_initializer=Constant(value=0), name='latent_log_variance')(encoder_intLayer_last) #encoder_outputLayer = Dense(latentDim)(concatenate([encoder_meanLayer,encoder_logVarianceLayer])) encoder_outputLayer = Lambda(VAE_sampling, output_shape=(latentDim, ), name='sampling_latent_action')([ encoder_meanLayer, encoder_logVarianceLayer ]) #encoder_outputLayers = [encoder_meanLayer,encoder_logVarianceLayer,encoder_outputLayer] encoder_Model = Model(encoder_inputLayer_s, encoder_outputLayer, name='encoder') if verbose: encoder_Model.summary() #plot_model(encoder_Model, to_file='vae_encoder.png', show_shapes=True) #define decoder model decoder_inputLayerLatentAction = Input(shape=(latentDim, ), name='latentLayer') #decoder_intLayer = Dense(latentDim*2,activation='relu')(decoder_inputLayerLatentAction) decoder_intLayer_last = Dense( latentDim * 2, activation='relu', name='decoding')(decoder_inputLayerLatentAction) decoder_outputLayer, losses_reconstruction = ActorCritic_general.generateActionOutputLayer( self.actionSpace, decoder_intLayer_last) decoder_Model = Model(decoder_inputLayerLatentAction, decoder_outputLayer, name='decoder') if verbose: decoder_Model.summary() sgd = optimizers.SGD(lr=1) decoder_Model.compile(optimizer=sgd, loss='mean_squared_error', metrics=['accuracy']) #plot_model(decoder_Model, to_file='vae_decoder.png', show_shapes=True) #define VAE model outputs = decoder_Model(encoder_Model(encoder_inputLayer_s)) vae_model = Model(encoder_inputLayer_s, outputs, name='vae') if verbose: vae_model.summary() plot_model(vae_model, to_file='vae_model.png', show_shapes=True, expand_nested=True) #add KL-divergence to losses kl_loss = 1 + encoder_logVarianceLayer - K.square( encoder_meanLayer) - K.exp(encoder_logVarianceLayer) kl_loss = K.sum(kl_loss, axis=-1) kl_loss *= -0.5 losses = [] for i, loss_recon_str in enumerate(losses_reconstruction): loss = self.lossWrapper(kl_loss, loss_recon_str) losses.append(loss) #vae_model.add_loss(losses) #define model sgd = optimizers.SGD(lr=1) vae_model.compile(optimizer=sgd, loss=losses_reconstruction, metrics=['accuracy']) #save models self.model = vae_model
def parameter_update(theta_0, ln_q, ln_1_q, ln_s, mu, sigma, n_u, n_y, jitter, sample_size_w=1024, batch_size=None, val_size=None, optimizer_choice='adam', lr=1e-3, max_batch=int(4096), tol=8, factr=1e-3, plot_loss=True, print_info=True): batch_L = [] gap = [] if optimizer_choice == 'adam': optimizer = optimizers.Adam(lr=lr) elif optimizer_choice == 'adadelta': optimizer = optimizers.Adadelta(lr=lr) elif optimizer_choice == 'adagrad': optimizer = optimizers.Adagrad(lr=lr) elif optimizer_choice == 'adamax': optimizer = optimizers.Adamax(lr=lr) elif optimizer_choice == 'ftrl': optimizer = optimizers.Ftrl(lr=lr) elif optimizer_choice == 'nadam': optimizer = optimizers.Nadam(lr=lr) elif optimizer_choice == 'rmsprop': optimizer = optimizers.RMSprop(lr=lr) elif optimizer_choice == 'sgd': optimizer = optimizers.SGD(lr=lr) else: optimizer = None theta = tf.Variable(theta_0) fin_theta = theta_0.copy() if val_size is not None: if val_size > n_y: val_size = n_y val_idx = numpy.arange(0, n_y) else: val_idx = numpy.random.choice(numpy.arange(0, n_y), val_size, replace=False) else: val_idx = None for i in range(0, int(1e8)): if batch_size is None: tmp_idx = numpy.arange(0, n_y) else: tmp_idx = numpy.random.choice(numpy.arange(0, n_y), batch_size, replace=False) raw_sample_w = tf.random.normal((sample_size_w, 3 * len(tmp_idx)), dtype='float64') L_t, g_t = get_obj_g(theta, ln_q[tmp_idx], ln_1_q[tmp_idx], ln_s[tmp_idx], mu[tmp_idx], sigma[tmp_idx], n_u, len(tmp_idx), n_y, raw_sample_w, jitter) optimizer.apply_gradients(zip([g_t], [theta])) theta = theta.numpy() theta[:2] = numpy.abs(theta[:2]) theta[:2][theta[:2] <= 1e-8] = 1e-8 theta[5:8][theta[5:8] <= 1e-8] = 1e-8 if val_size is not None: if numpy.mod(i, numpy.min([numpy.floor(tol / 2), 8])) == 0: raw_sample_w = tf.random.normal((sample_size_w, 3 * val_size), dtype='float64') tmp_L_t = vi_obj(theta, ln_q[val_idx], ln_1_q[val_idx], ln_s[val_idx], mu[val_idx], sigma[val_idx], n_u, val_size, n_y, raw_sample_w, jitter) tmp_L = (tmp_L_t.numpy() / n_y) else: tmp_L = (L_t.numpy() / n_y) batch_L.append(numpy.min(tmp_L)) if len(batch_L) >= 2: if tmp_L < numpy.min(batch_L[:-1]): fin_theta = theta.copy() theta = tf.Variable(theta) if (numpy.mod(len(batch_L), tol) == 0) & print_info: print( '=============================================================================' ) print(theta[:8]) print(theta[-6:]) print('Batch: ' + str(len(batch_L)) + ', optimiser: ' + optimizer_choice + ', Loss: ' + str(tmp_L)) print( '=============================================================================' ) if len(batch_L) > tol: previous_opt = numpy.min(batch_L.copy()[:-tol]) current_opt = numpy.min(batch_L.copy()[-tol:]) gap.append(previous_opt - current_opt) if (numpy.mod(len(batch_L), tol) == 0) & print_info: print('Previous And Recent Top Averaged Loss Is:') print(numpy.hstack([previous_opt, current_opt])) print('Current Improvement, Initial Improvement * factr') print(numpy.hstack([gap[-1], gap[0] * factr])) if (len(gap) >= 2) & (gap[-1] <= (gap[0] * factr)): print('Total batch number: ' + str(len(batch_L))) print('Initial Loss: ' + str(batch_L[0])) print('Final Loss: ' + str(numpy.min(batch_L))) print('Current Improvement, Initial Improvement * factr') print(numpy.hstack([gap[-1], gap[0] * factr])) break if len(batch_L) >= max_batch: break if plot_loss: fig = matplotlib.pyplot.figure(figsize=(16, 9)) matplotlib.pyplot.plot(numpy.arange(0, len(batch_L)), numpy.array(batch_L)) matplotlib.pyplot.xlabel('Batches') matplotlib.pyplot.ylabel('Loss') matplotlib.pyplot.title('Learning Rate: ' + str(lr)) matplotlib.pyplot.grid(True) try: fig.savefig('./' + str(n_y) + '_' + str(n_u) + '_' + optimizer_choice + '_' + str(lr) + '.png', bbox_inches='tight') except PermissionError: pass except OSError: pass matplotlib.pyplot.close(fig) return fin_theta
def mdelvgg_build(img_resolucion, cfg, red_name=DEFAULT_NAME, save_model=True): """ Construccion del modelo """ ke_vec = [4, 8, 16, 32] fc_vec = [256, 256] # input x_in = Input(img_resolucion) # bloque 0 kernelnum = ke_vec[0] kernelsze = (3, 3) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_01', padding='same', activation='relu')(x_in) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_02', padding='same', activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2), name='max_pooling_0', strides=(2, 2))(x) # bloque 1 kernelnum = ke_vec[1] kernelsze = (3, 3) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_11', padding='same', activation='relu')(x_in) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_12', padding='same', activation='relu')(x) x = AveragePooling2D(pool_size=(2, 2), name='Avg_pol_1', strides=(2, 2))(x) # bloque 2 kernelnum = ke_vec[2] kernelsze = (3, 3) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_21', padding='same', activation='relu')(x_in) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_22', padding='same', activation='relu')(x) x = AveragePooling2D(pool_size=(2, 2), name='Avg_pol_2', strides=(2, 2))(x) # # Bloque 3 kernelnum = ke_vec[3] kernelsze = (3, 3) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_31', padding='same', activation='relu')(x_in) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_32', padding='same', activation='relu')(x) x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], name='conv3_33', padding='same', activation='relu')(x) x = AveragePooling2D(pool_size=(2, 2), name='Avg_pol_3', strides=(2, 2))(x) # # bloque 3 # kernelnum = int(256*preescaler) # kernelsze = (3, 3) # x = ZeroPadding2D(cfg['padding'])(x) # x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], # name='conv3_31')(x) # x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'], # name='conv3_32')(x) # # x = BatchNormalization(axis=cfg['norm_ejes'], name='batch_normal_3')(x) # x = Activation(cfg['l1_act'])(x) # x = MaxPooling2D(cfg['maxpool_sze'], name='max_pooling_3')(x) # Flatten x = Flatten()(x) # Fullyconected 0 x = Dense(fc_vec[0], activation=cfg['l1_act'], name='fully_conected_0')(x) x = Dropout(0.5)(x) # Fullyconected 1 x = Dense(fc_vec[1], activation=cfg['l1_act'], name='fully_conected_1')(x) x = Dropout(0.2)(x) # output0 x = Dense(2, activation=cfg['fc_act'], name='Salida')(x) # Compilacion: model_nc = Model(inputs=x_in, outputs=x, name='red_uno') # compilación del modelo model_cp = model_nc opt = opti.SGD(lr=0.08, decay=1e-6, momentum=0.9, nesterov=True) #opt = tfopti.Adam(learning_rate=0.001) model_cp.compile(loss='sparse_categorical_crossentropy', optimizer=opt, metrics=cfg['metrica']) # Graficando el modelo os.makedirs(savepath, exist_ok=True) print('Generando imagen del modelo') plot_model(model_cp, to_file=os.path.join(savepath, red_name + '.png')) if save_model: model_cp.save(os.path.join(savepath, red_name + '.h5')) return model_cp, model_nc
#Forward Pass and Generalisation preds = model.predict_classes(X_test) print("test acc: %0.4f" % np.mean(preds == y_test)) # One can use Tesorboard for visualising the loss in various models %load_ext tensorboard import datetime from tensorflow.keras.callbacks import TensorBoard model = Sequential() model.add(Dense(hidden_dim, input_dim = input_dim, activation='tanh')) model.add(Dense(hidden_dim, activation='tanh')) model.add(Dense(output_dim, activation='softmax')) model.compile(optimizer = optimizers.SGD(learning_rate=0.1), loss = 'categorical_crossentropy', metrics=['accuracy'] ) timestamp = datetime.datetime.now().strftime("Y%m%d-%H%M%S") log_dir = "tensorboard_logs/" + timestamp tensorboard_callback = TensorBoard(log_dir=log_dir, histogram_freq=1, write_graph=True) model.fit(x=X_train, y=Y_train, validation_split=0.2, epochs=15, callbacks=[tensorboard_callback]) # Run the commmand below from command line rather than atom !tensorboard --logdir tensorboard_logs # Analysis of the exercise # Setting the learning rate value to a small value (e.g. lr=0.001 on # this dataset) makes the model train much slower (it has not # converged yet after 15 epochs).
def create_model_cnn(self, params, input_shape): ''' Create CCN model ''' for layer in params['layers']: neurons = layer['neurons'] if 'neurons' in layer else None dropout_rate = layer['rate'] if 'rate' in layer else None activation = layer['activation'] if 'activation' in layer else None return_seq = layer['return_seq'] if 'return_seq' in layer else None input_timesteps = layer[ 'input_timesteps'] if 'input_timesteps' in layer else None input_dim = layer['input_dim'] if 'input_dim' in layer else None kernel_size = layer[ 'kernel_size'] if 'kernel_size' in layer else None strides = layer['strides'] if 'strides' in layer else None padding = layer['padding'] if 'padding' in layer else None use_bias = layer['use_bias'] if 'use_bias' in layer else None pool_size = layer['pool_size'] if 'pool_size' in layer else None if layer['type'] == 'dense': if input_dim: self.model.add( Dense(neurons, activation=activation, input_shape=(input_dim, ))) else: self.model.add(Dense(neurons, activation=activation)) if layer['type'] == 'lstm': self.model.add( LSTM(neurons, input_shape=(input_timesteps, input_dim), return_sequences=return_seq)) if layer['type'] == 'Conv2D': self.model.add( Conv2D(neurons, kernel_size, strides=strides, input_shape=input_shape, padding=padding, activation=activation, use_bias=use_bias, kernel_initializer=RandomNormal(mean=0.0, stddev=1e-2, seed=None), kernel_regularizer=l2(2e-4))) if layer['type'] == 'MaxPool2D': self.model.add(MaxPool2D(pool_size=pool_size)) if layer['type'] == 'BatchNormalization': self.model.add(BatchNormalization()) if layer['type'] == 'flatten': self.model.add(Flatten()) if layer['type'] == 'dropout': self.model.add(Dropout(dropout_rate)) # Optimizer if params["optimizer"] == 'rmsprop': optimizer = optimizers.RMSprop(lr=params["lr"]) elif params["optimizer"] == 'sgd': optimizer = optimizers.SGD(lr=params["lr"], decay=1e-6, momentum=0.9, nesterov=True) elif params["optimizer"] == 'adam': optimizer = optimizers.Adam(learning_rate=params["lr"], beta_1=0.9, beta_2=0.999, amsgrad=False) metrics = [] for metric in params['metrics']: if metric == 'accuracy': metrics.append(metric) if metric == 'f1_score': metrics.append(f1_score) if metric == 'precision': metrics.append(keras_metrics.precision()) if metric == 'recall': metrics.append(keras_metrics.recall()) self.model.compile(loss=params['loss'], optimizer=optimizer, metrics=metrics) self.model.summary()
# ====================================== # Build, train, and use the classifier # ====================================== import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras import optimizers from keras.utils import np_utils input_layer = keras.Input(shape=(2,)) # hidden_layer_1 = layers.Dense(2, activation='relu')(input_layer) output_layer = layers.Dense(1, activation='sigmoid')(input_layer) optim = optimizers.SGD(lr=1.0) model = keras.Model(inputs=input_layer, outputs=output_layer) model.compile(optimizer=optim, loss='binary_crossentropy', metrics=['acc', 'mse']) if (LoadModel==True): # Load the trained model from disk model.load_weights("2d_points_clas_model.h5") else: # Train history = model.fit(x_train, y_train, batch_size=100,
print('INPUT_SHAPE = ', INPUT_SHAPE) print('NUMBER_FEATURES_CONV =', NUMBER_FEATURES_CONV) print('NUMBER_FEATURES_DENSE = ', NUMBER_FEATURES_DENSE) print() # load the model print('loading the model ...') model = build_model(NUMBER_FEATURES_CONV, input_shape=INPUT_SHAPE, n_features_dense=NUMBER_FEATURES_DENSE) print() # set optimizer and loss opt = None if optimizer == 'SGD': opt = optimizers.SGD(lr=lrate, momentum=0.9, nesterov=True) elif optimizer == 'Adam': opt = optimizers.Adam(lr=0.0001, decay=1e-6) else: print('Specify the optimizer from [' 'Adam' ', ' 'SGD' ']') print('compiling the model ...') model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy']) print() # model info print('Model summary: ') print(model.summary()) print()
# -print('images', len(images), images) # -print('labels', len(labels), labels) # -print(table) # images:string path,labels:number db = tf.data.Dataset.from_tensor_slices((images, labels)) db = db.shuffle(1000).map(preprocess).batch(32).repeat(20) # Set the global constant as 150 num_classes = 150 model = AlexNet((227, 227, 3), num_classes) model.summary() # Train the model: compute gradients and update network parameters optimizer = optimizers.SGD(lr=0.01) acc_meter = metrics.Accuracy() x_step = [] y_accuracy = [] # Input the batch for the training for step, (x, y) in enumerate(db): # Buld the gradient records with tf.GradientTape() as tape: # Flatten the input such as [b,28,28]->[b,784] x = tf.reshape(x, (-1, 227, 227, 3)) output = model(x) y_onehot = tf.one_hot(y, depth=150) loss = tf.square(output - y_onehot) loss = tf.reduce_sum(loss) / 32 # Compute the gradients of each parameter grads = tape.gradient(loss, model.trainable_variables)
y = tf.one_hot(y, depth=10) print(x.shape, y.shape) train_dataset = tf.data.Dataset.from_tensor_slices((x, y)) train_dataset = train_dataset.batch(200)#一次返回200张图片一起计算 # for step,(x,y) in enumerate(train_dataset): # print(step,x.shape,y,y.shape) model = keras.Sequential([ layers.Dense(512, activation='relu'),#512指的是输出512 layers.Dense(256, activation='relu'), layers.Dense(10)]) optimizer = optimizers.SGD(learning_rate=0.001)#随机梯度下降 def train_epoch(epoch): # Step4.loop for step, (x, y) in enumerate(train_dataset): with tf.GradientTape() as tape: # [b, 28, 28] => [b, 784] x = tf.reshape(x, (-1, 28*28)) # Step1. compute output # [b, 784] => [b, 10] out = model(x) # Step2. compute loss
x = tf.nn.relu(x) # [b, 128] => [b, 64] x = self.fc3(x) x = tf.nn.relu(x) # [b, 64 => [b, 32] x = self.fc4(x) x = tf.nn.relu(x) # [b, 32] => [b, 10] x = self.fc5(x) return x network = MyNetwork() network.compile( optimizer=optimizers.SGD(learning_rate=0.02, momentum=0.9), # optimizer=optimizers.Adam(lr=1e-3), loss=tf.losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy']) network.fit(train_db, epochs=15, validation_data=test_db, validation_freq=1) network.evaluate(test_db) network.save_weights('keras_train.ckpt') del network print('save to keras_train.ckpt') network = MyNetwork() network.compile(optimizer=optimizers.Adam(lr=1e-3), loss=tf.losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy'])
def cnn2d(input_shape, num_classes, args): model = tf.keras.Sequential(name='CNN_2D') # LFLB1 model.add( Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', input_shape=input_shape, kernel_regularizer=tf.keras.regularizers.l2(0.005))) model.add(BatchNormalization(axis=1)) model.add(Activation('elu')) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # LFLB2 model.add( Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', kernel_regularizer=tf.keras.regularizers.l2(0.005))) model.add(BatchNormalization(axis=1)) model.add(Activation('elu')) model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4))) # LFLB3 model.add( Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', kernel_regularizer=tf.keras.regularizers.l2(0.005))) model.add(BatchNormalization(axis=1)) model.add(Activation('elu')) model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4))) # LFLB4 model.add( Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', kernel_regularizer=tf.keras.regularizers.l2(0.005))) model.add(BatchNormalization(axis=1)) model.add(Activation('elu')) model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4))) # LSTM model.add(Reshape((1, 128))) #model.add(Reshape((1, 384))) #model.add(LSTM(units=256)) model.add( LSTM(units=args.num_fc, kernel_regularizer=tf.keras.regularizers.l2(0.005))) # FC model.add(Dense(units=num_classes, activation='softmax')) # Model compilation #opt = optimizers.SGD(lr=args.learning_rate, decay=args.decay,momentum=args.momentum, nesterov=True) #opt = optimizers.Adam(lr=args.learning_rate) opt = optimizers.SGD(lr=0.01, decay=1e-3, momentum=0.8) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['categorical_accuracy']) return model
rec_len = X_train.shape[1] num_classes = len(set(All_ECG_annotation[0])) model = lstm_raw(rec_len, num_classes) # build a learning decay schedule, use this during optimizer building. lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay( # use exponetial learning rate decay during training initial_learning_rate= 0.01, decay_steps=100, # decay the learning rate every given decay_steps decay_rate=0.96, # every time for decay learning rate, decay with decay_rate of exponential decay base. staircase=False) model.compile( optimizer=optimizers.SGD(learning_rate=lr_schedule, momentum=0.9, nesterov=True), #decay=1e-6, loss='sparse_categorical_crossentropy', metrics=[tf.keras.metrics.sparse_categorical_accuracy]) tensorboard_cbk = tf.keras.callbacks.TensorBoard( log_dir=directory, # directory where to write logs histogram_freq=0, # How often to log histogram visualizations embeddings_freq=0, # How often to log embedding visualizations update_freq='epoch') # How often to write logs (default: once per epoch) num_epoches = 4 model.fit(X_train, y_train, batch_size=32, epochs=num_epoches, shuffle=True, callbacks=[tensorboard_cbk], # use tensorboard call back to visualize the training process validation_data=(X_val, y_val))
plt.imshow(train_images[i], cmap='gray') plt.title(train_labels[i]) plt.axis('off') myInput = layers.Input(shape=(28, 28, 1)) conv1 = layers.Conv2D(16, 3, activation='relu', padding='same', strides=2)(myInput) conv2 = layers.Conv2D(32, 3, activation='relu', padding='same', strides=2)(conv1) flat = layers.Flatten()(conv2) out_layer = layers.Dense(10, activation='softmax')(flat) myModel = models.Model(myInput, out_layer) myModel.summary() myModel.compile(optimizer=optimizers.SGD(lr=0.001), loss=losses.categorical_crossentropy) # Train our model history = myModel.fit(X_train, Y_train, batch_size=128, epochs=20, validation_split=0.2) losses = history.history['loss'] val_losses = history.history['val_loss'] plt.plot(losses) plt.plot(val_losses) plt.xlabel('Epochs')
def run_hold_out(multi_data, X, Y, CLASSES, epoch, MODEL, BATCH_SIZE=32): VALIDATION_ACCURACY = [] VALIDATION_LOSS = [] HISTORY = [] MODEL_NAME = MODEL FOLDS = 2 EPOCHS = epoch save_dir = os.path.join(os.getcwd(), 'models/') VERBOSE = 1 fold_var = 7030 # directory_mover(multi_data,"multi_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var)) # no hold out da algum erro no flow_from_dataframe train_data_generator = dataHoldOutAugmentation().flow_from_dataframe( # training_data, dataframe=multi_data, directory=os.path.join( os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'), target_size=(250, 250), x_col="image_path", y_col="name", batch_size=BATCH_SIZE, subset="training", class_mode="categorical", # modificado apenas para verificar o hold out shuffle=True) valid_data_generator = dataHoldOutAugmentation().flow_from_dataframe( # training_data, dataframe=multi_data, directory=os.path.join( os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'), target_size=(250, 250), x_col="image_path", y_col="name", batch_size=BATCH_SIZE, class_mode="categorical", subset="validation", # modificado apenas para verificar o hold out shuffle=True) model = get_model(MODEL, CLASSES) sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['acc']) # CREATE CALLBACKS checkpoint = tf.keras.callbacks.ModelCheckpoint( save_dir + get_model_name(MODEL_NAME, fold_var, BATCH_SIZE), monitor='val_acc', verbose=VERBOSE, save_best_only=True, mode='max') earlystopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=VERBOSE, patience=500) callbacks_list = [checkpoint, earlystopping] history = model.fit(train_data_generator, epochs=EPOCHS, steps_per_epoch=train_data_generator.n // train_data_generator.batch_size, callbacks=callbacks_list, validation_data=valid_data_generator, validation_steps=valid_data_generator.n // valid_data_generator.batch_size, verbose=VERBOSE) HISTORY.append(history) # LOAD BEST MODEL to evaluate the performance of the model model.load_weights(os.getcwd() + "/models/model_" + MODEL_NAME + "_" + str(fold_var) + '_' + str(BATCH_SIZE) + ".h5") results = model.evaluate(valid_data_generator) # results = model.evaluate_generator(valid_data_generator) results = dict(zip(model.metrics_names, results)) VALIDATION_ACCURACY.append(results['acc']) VALIDATION_LOSS.append(results['loss']) write_results( get_current_time_str() + '_holdout_' + str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' + str(BATCH_SIZE) + '.txt', VALIDATION_ACCURACY, VALIDATION_LOSS, HISTORY)
# print('1st convolutional layer, 1st kernel weights:') # print(np.squeeze(model.get_weights()[0][:,:,0,0])) # print('1st convolutional layer, 1st kernel bias:') # print(np.squeeze(model.get_weights()[1][0])) # print('1st convolutional layer, 2nd kernel weights:') # print(np.squeeze(model.get_weights()[0][:,:,0,1])) # print('1st convolutional layer, 2nd kernel bias:') # print(np.squeeze(model.get_weights()[1][1])) # print('fully connected layer weights:') # print(np.squeeze(model.get_weights()[2])) # print('fully connected layer bias:') # print(np.squeeze(model.get_weights()[3][0])) sgd = optimizers.SGD(lr=1) model.compile(loss='MSE', optimizer=sgd, metrics=['accuracy']) history = model.fit(img, output, batch_size=1, epochs=1) print('model output after:') print(model.predict(img)) print('1st convolutional layer, 1st kernel weights:') print(np.squeeze(model.get_weights()[0][:, :, 0, 0])) print('1st convolutional layer, 1st kernel bias:') print(np.squeeze(model.get_weights()[1][0])) print('1st convolutional layer, 2nd kernel weights:') print(np.squeeze(model.get_weights()[0][:, :, 0, 1])) print('1st convolutional layer, 2nd kernel bias:') print(np.squeeze(model.get_weights()[1][1]))
layers.MaxPooling2D(pool_size=2, strides=2), # 池化层,卷积核2*2,步长2 layers.ReLU(), # 激活函数 layers.Conv2D(16, kernel_size=3, strides=1), # 第二个卷积层,16个3*3*6卷积核 layers.MaxPooling2D(pool_size=2, strides=2), # 池化层 layers.ReLU(), # 激活函数 layers.Flatten(), # 拉直,方便全连接层处理 layers.Dense(120, activation='relu'), # 全连接层,120个节点 layers.Dense(84, activation='relu'), # 全连接层,84个节点 layers.Dense(10) # 输出层,10个节点 ]) network.build(input_shape=(None, 28, 28, 1)) # 定义输入,batch_size=32,输入图片大小是28*28,通道数为1。 network.summary() # 显示出每层的待优化参数量 # 3.模型训练(计算梯度,迭代更新网络参数) optimizer = optimizers.SGD(lr=0.01) # 声明采用批量随机梯度下降方法,学习率=0.01 acc_meter = metrics.Accuracy() # 新建accuracy测量器 for step, (x, y) in enumerate(train_dataset): # 一次输入batch组数据进行训练 with tf.GradientTape() as tape: # 构建梯度记录环境 x = tf.reshape(x, (32, 28, 28, 1)) # 将输入拉直,[b,28,28]->[b,784] # x = tf.extand_dims(x, axis=3) out = network(x) # 输出[b, 10] y_onehot = tf.one_hot(y, depth=10) # one-hot编码 loss = tf.square(out - y_onehot) loss = tf.reduce_sum(loss) / 32 # 定义均方差损失函数,注意此处的32对应为batch的大小 grads = tape.gradient(loss, network.trainable_variables) # 计算网络中各个参数的梯度 optimizer.apply_gradients(zip(grads, network.trainable_variables)) # 更新网络参数 acc_meter.update_state(tf.argmax(out, axis=1), y) # 比较预测值与标签,并计算精确度(写入数据,进行求精度)
model.add( layers.Conv2D(16, (3, 3), activation='relu', input_shape=(150, 225, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(16, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(16, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(0.5)) model.add(layers.Dense(8, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) sgd = optimizers.SGD(lr=1e-2, decay=1e-6, momentum=0.9, nesterov=True) # rmsprop = optimizers.RMSprop(lr=1e-2, decay=1e-6) model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['acc']) from tensorflow.keras.preprocessing.image import ImageDataGenerator # All images will be rescaled by 1./255 train_datagen = ImageDataGenerator(rescale=1. / 255) test_datagen = ImageDataGenerator(rescale=1. / 255) # decreased batch size from 10 to 5 train_generator = train_datagen.flow_from_directory( # This is the target directory train_dir, # All images will be resized to 150x225 target_size=(150, 225),
val_dataset = val_dataset.batch(200) # 利用正态分布初始化 w = tf.Variable(initial_value=tf.random.normal((784, 10))) b = tf.Variable(initial_value=tf.random.normal((10, ))) # 利用均匀分布初始化初始化 # w = tf.Variable(initial_value=tf.random.uniform((784, 10))) # b = tf.Variable(initial_value=tf.random.uniform((10,))) # 利用Glorot(Xavier)正太分布初始化 # w = tf.Variable(initial_value=tf.initializers.GlorotNormal()((784, 10))) # b = tf.Variable(initial_value=tf.initializers.GlorotNormal()((10,))) # 利用Glorot(Xavier)均匀分布初始化 # w = tf.Variable(initial_value=tf.initializers.GlorotUniform()((784, 10))) # b = tf.Variable(initial_value=tf.initializers.GlorotUniform()((10,))) optimizer = optimizers.SGD(learning_rate=0.02) def train_epoch(epoch): # Step4.loop for step, (x, y) in enumerate(train_dataset): with tf.GradientTape() as tape: # [b, 28, 28] => [b, 784] x = tf.reshape(x, (-1, 28 * 28)) # Step1. compute output # [b, 784] => [b, 10] out = model(x, w, b) # Step2. compute loss loss = tf.reduce_sum(tf.square(out - y)) / x.shape[0] # 训练集测试准确度
def main(args): # Print settings for k, v in vars(args).items(): print(f'{k}: {v}') num_classes = 8 size = (224, 224, 3) # size of images # Runtime initialization will not allocate all memory on GPU physical_devices = tf.config.list_physical_devices('GPU') try: tf.config.experimental.set_memory_growth(physical_devices[0], True) except: # Invalid device or cannot modify virtual devices once initialized. pass # Create checkpoints dir os.makedirs('saved_models', exist_ok=True) optimizer = optimizers.SGD(learning_rate=args.learning_rate, momentum=0.9) loss = keras.losses.SparseCategoricalCrossentropy(from_logits=False) metrics = [keras.metrics.SparseCategoricalAccuracy()] # model = models.vgg16(input_shape=size, num_classes=num_classes, classifier_activation='softmax') model = models.resnet50(input_shape=size, num_classes=num_classes, classifier_activation='softmax') model.compile(optimizer=optimizer, loss=loss, metrics=metrics) model.summary() if args.checkpoints: if os.path.exists(args.checkpoints): print(f'Loading checkpoints: {args.checkpoints}') model.load_weights(args.checkpoints) else: print(f'Checkpoints `{args.checkpoints}` not found', file=sys.stderr) os.makedirs("logs/scalars/", exist_ok=True) logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S") # Log loss/metrics for training and validation tensorboard = keras.callbacks.TensorBoard(log_dir=logdir) if args.train: # Same augs as C++ train_aug = iaa.Sequential([ iaa.Resize(size=size[:-1], interpolation='cubic'), iaa.Fliplr(p=0.5), iaa.Flipud(p=0.5), iaa.Rotate(rotate=(-180, 180)), iaa.AdditivePoissonNoise(lam=(0, 10)), iaa.GammaContrast(gamma=(.8, 1.5)), iaa.GaussianBlur(sigma=(.0, .8)), iaa.CoarseDropout(p=(.02, .1), size_px=(0.02, 0.05), size_percent=0.5), ]) val_aug = iaa.Sequential([iaa.Resize(size=size[:-1], interpolation='cubic')]) training_dataset = ISICClassification(args.dataset, 'training', args.batch_size, train_aug) training_tfdata = training_dataset.map_samples(args.epochs) validation_dataset = ISICClassification(args.dataset, 'validation', args.batch_size, val_aug, shuffle=False) validation_tfdata = validation_dataset.map_samples(args.epochs) # Save checkpoints checkpoint = ModelCheckpoint(f'saved_models/{args.name}.h5', monitor='val_sparse_categorical_accuracy', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', save_freq='epoch') # Stop training after 20 epochs of no improvement early = EarlyStopping(monitor='val_sparse_categorical_accuracy', min_delta=0, patience=args.epochs // 4, verbose=1, mode='auto') # Train the model model.fit( x=training_tfdata, epochs=args.epochs, verbose=1, callbacks=[checkpoint, early, tensorboard], validation_data=validation_tfdata, steps_per_epoch=len(training_dataset), validation_steps=len(validation_dataset), ) if args.test: # Test model on test set test_aug = iaa.Sequential([iaa.Resize(size=size[:-1], interpolation='cubic')]) test_dataset = ISICClassification(args.dataset, 'test', args.batch_size, test_aug) test_tfdata = test_dataset.map_samples(1) results = model.evaluate(test_tfdata, verbose=1, callbacks=[tensorboard]) print("Test set loss and accuracy:", results)
max_lr = base_lr * 10 max_m = MAX_MOMENTUM base_m = BASE_MOMENTUM cyclical_momentum = CYCLICAL_MOMENTUM augment = AUGMENT cycles = CYCLES # Расчет количества итерация и шага изменения learning rate iterations = round(train_generator.samples // train_generator.batch_size * EPOCHS_STEP1) iterations = list(range(0, iterations + 1)) step_size = len(iterations) / (cycles) model.compile(loss="categorical_crossentropy", optimizer=optimizers.SGD(lr=base_lr, momentum=BASE_MOMENTUM), metrics=["accuracy"]) clr1 = CyclicLR(base_lr=LR_STEP1, max_lr=LR_STEP1 * 10, step_size=step_size, max_m=MAX_MOMENTUM, base_m=BASE_MOMENTUM, cyclical_momentum=CYCLICAL_MOMENTUM) # Добавим ModelCheckpoint чтоб сохранять прогресс обучения модели и можно было потом подгрузить и дообучить модель. checkpoint = ModelCheckpoint('best_model.hdf5', monitor=['accuracy'], verbose=1, mode='max') earlystop = EarlyStopping(monitor='accuracy',
def main(): """ 主函数 :return: """ # 输入:[b, 32, 32, 3] model = ResNet18() model.build(input_shape=(None, 32, 32, 3)) model.summary() mydense = layers.Dense(100, activation=None, kernel_regularizer=regularizers.l2(5e-4)) fc_net = Sequential([mydense]) fc_net.build(input_shape=(None, 512)) fc_net.summary() optimizer = optimizers.SGD(lr=0.1, momentum=0.9, decay=5e-4) variables = model.trainable_variables + fc_net.trainable_variables for epoch in range(500): for step, (x, y) in enumerate(train_db): with tf.GradientTape() as tape: out = model(x, training=True) avgpool = layers.GlobalAveragePooling2D()(out) logits = fc_net(avgpool) y_onehot = tf.one_hot(y, depth=100) loss = tf.reduce_mean( tf.losses.categorical_crossentropy(y_onehot, logits, from_logits=True)) loss = loss + tf.add_n(model.losses) + tf.add_n(fc_net.losses) # 梯度求解 grads = tape.gradient(loss, variables) # 梯度更新 optimizer.apply_gradients(zip(grads, variables)) # 学习率动态调整 optimizer.lr = lr_schedule_300ep(epoch) # 每100个step打印一次 if step % 100 == 0: print('epoch:', epoch, 'step:', step, 'loss:', float(loss), 'lr:', optimizer.lr.numpy()) # 做测试 total_num, total_correct = 0, 0 for x, y in test_db: out = model(x, training=False) avgpool = layers.GlobalAveragePooling2D()(out) output = fc_net(avgpool) # 预测可能性。 prob = tf.nn.softmax(output, axis=1) pred = tf.argmax(prob, axis=1) # 还记得吗pred类型为int64,需要转换一下。 pred = tf.cast(pred, dtype=tf.int32) # 拿到预测值pred和真实值比较。 correct = tf.cast(tf.equal(pred, y), dtype=tf.int32) correct = tf.reduce_sum(correct) total_num += x.shape[0] total_correct += int(correct) # 转换为numpy数据 acc = total_correct / total_num print('epoch:', epoch, 'test_acc:', acc) print('====================================================')
modified_ResNet50_output = GlobalAveragePooling2D()(modified_ResNet50_output) modified_ResNet50_output = Dense(512, activation='relu')(modified_ResNet50_output) modified_ResNet50_output = Dropout(0.5)(modified_ResNet50_output) modified_ResNet50_output = Dense( num_classes, activation='softmax')(modified_ResNet50_output) # Create the new model by using Input and Output layers new_ResNet50_model = Model(inputs=base_model.input, outputs=modified_ResNet50_output) new_ResNet50_model.summary() # Compile the model with categorical crossentropy loss function and SGD optimizer new_ResNet50_model.compile(loss='categorical_crossentropy', optimizer=optimizers.SGD(lr, momentum), metrics=['accuracy']) # Train the model print("[INFO] Train the model on training data") history = new_ResNet50_model.fit(train_generator, validation_data=validation_generator, epochs=epochs, verbose=1) #new_VGG16_model.save('ResNet50_TransferLearning_NDDA.h5') # Plot training curves x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] pyplot.plot(history.history['accuracy'])
# (train_images, train_labels, test_images, test_labels) = load_CIFAR('/home/user/Documents/dataset/Cifar-10') (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.cifar10.load_data() train_labels = tf.keras.utils.to_categorical(train_labels, 10) test_labels = tf.keras.utils.to_categorical(test_labels, 10) train_images = np.array(train_images, dtype=np.float32) test_images = np.array(test_images, dtype=np.float32) train_images, test_images = color_normalize(train_images, test_images) # get model img_input = Input(shape=(32, 32, 3)) output = ResNet(img_input) model = models.Model(img_input, output) # show model.summary() # train learning_rate_schedules = optimizers.schedules.PiecewiseConstantDecay( boundaries, learning_rate) optimizer = optimizers.SGD(learning_rate=learning_rate_schedules, momentum=0.9, nesterov=True) for epoch in range(epoch_num): print('epoch %d' % epoch) train(model, optimizer, train_images, train_labels) test(model, test_images, test_labels)