x = Flatten()(vgg.output) prediction=Dense(len(folders), activation='softmax')(x) model = Model(inputs=vgg.input, outputs=prediction) model.summary() model.compile( loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'] ) batch_size=32 r= model.fit_generator(training_set,epochs = 10, validation_data = test_set,verbose = 1, steps_per_epoch=X_train.shape[0] // batch_size) # plot the loss plt.figure(figsize=(10,6)) plt.subplot(1,2,1) plt.plot(r.history['loss'], label='train loss') plt.plot(r.history['val_loss'], label='val loss') plt.legend() plt.savefig('LossVal_loss') # plot the accuracy plt.subplot(1,2,2) plt.plot(r.history['accuracy'], label='train acc') plt.plot(r.history['val_accuracy'], label='val acc') plt.legend()
batch_size=batch_size, target_size=img_shape) model = ResNet50(include_top=False, input_shape=(298, 298, 3)) for layer in model.layers: layer.trainable = False flat1 = Flatten()(model.layers[-1].output) class1 = Dense(128, activation='relu', kernel_initializer='he_uniform')(flat1) output = Dense(1, activation='sigmoid')(class1) model = Model(inputs=model.inputs, outputs=output) opt = SGD(lr=lr, momentum=0.9) model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy']) history = model.fit_generator(train_it, steps_per_epoch=len(train_it), epochs=epochs, verbose=1) if 'acc' in history.history.keys(): for i in range(1, epochs + 1): log_metrics('accuracy', float(history.history['acc'][i - 1]), i, i) log_metrics('loss', float(history.history['loss'][i - 1]), i, i) print("accuracy=", float(history.history['acc'][i - 1])) print("loss=", float(history.history['loss'][i - 1])) else: for i in range(1, epochs + 1): log_metrics('accuracy', float(history.history['accuracy'][i - 1]), i, i) log_metrics('loss', float(history.history['loss'][i - 1]), i, i) print("accuracy=", float(history.history['accuracy'][i - 1])) print("loss=", float(history.history['loss'][i - 1]))
labels[v] = k train_generator = gen.flow_from_directory(train_path, target_size=IMAGE_SIZE, shuffle=True, batch_size=batch_size) valid_generator = gen.flow_from_directory(validation_path, target_size=IMAGE_SIZE, shuffle=True, batch_size=batch_size) r = model.fit_generator( train_generator, #validation_data=valid_generator, epochs=15, steps_per_epoch=len(image_files) // batch_size, #validation_steps=len(validation_files)//batch_size ) def get_confusion_matrix(data_path, N): print("Generating Confusion Matrix {}".format(N)) predictions = [] targets = [] i = 0 for x, y in gen.flow_from_directory(data_path, target_size=IMAGE_SIZE, shuffle=False, batch_size=batch_size * 2): i += 1
y_true *= 255 y_pred *= 255 rmean = (y_true[:, :, :, 0] + y_pred[:, :, :, 0]) / 2 r = y_true[:, :, :, 0] - y_pred[:, :, :, 0] g = y_true[:, :, :, 1] - y_pred[:, :, :, 1] b = y_true[:, :, :, 2] - y_pred[:, :, :, 2] return K.mean(K.sqrt((((512+rmean)*r*r)/256) + 4*g*g + (((767-rmean)*b*b)/256))) val_generator = image_generator(config.batch_size, train_dir) in_sample_images, out_sample_images = next(val_generator) class ImageLogger(Callback): def on_epoch_end(self, epoch, logs): preds = self.model.predict(in_sample_images) in_resized = [] for arr in in_sample_images: # Simple upsampling in_resized.append(arr.repeat(8, axis=0).repeat(8, axis=1)) wandb.log({ "examples": [wandb.Image(np.concatenate([in_resized[i] * 255, o * 255, out_sample_images[i] * 255], axis=1)) for i, o in enumerate(preds)] }, commit=False) opt = Adam(lr=0.0001, beta_1=0.9) generator.compile(loss='mse', optimizer=opt, metrics=[perceptual_distance]) generator.fit_generator(image_generator(config.batch_size, train_dir), steps_per_epoch=config.steps_per_epoch, epochs=config.num_epochs, callbacks=[ ImageLogger(), WandbCallback()], validation_steps=config.val_steps_per_epoch, validation_data=val_generator)
class IIC(): def __init__(self, args, backbone): self.args = args self.backbone = backbone self._model = None self.train_gen = DataGenerator(args, siamese=True) self.n_labels = self.train_gen.n_labels self.build_model() self.load_eval_dataset() self.accuracy = 0 # build the n_heads of the IIC model def build_model(self): inputs = Input(shape=self.train_gen.input_shape) x = self.backbone(inputs) x = Flatten()(x) outputs = [] for i in range(self.args.heads): name = "head%d" % i outputs.append( Dense(self.n_labels, activation='softmax', name=name)(x)) self._model = Model(inputs, outputs, name='encoder') optimizer = Adam(lr=1e-3) self._model.compile(optimizer=optimizer, loss=self.loss) self._model.summary() # MI loss def loss(self, y_true, y_pred): size = self.args.batch_size n_labels = y_pred.shape[-1] # lower half is Z Z = y_pred[0:size, :] Z = K.expand_dims(Z, axis=2) # upper half is Zbar Zbar = y_pred[size:y_pred.shape[0], :] Zbar = K.expand_dims(Zbar, axis=1) # compute joint distribution P = K.batch_dot(Z, Zbar) P = K.sum(P, axis=0) # enforce symmetric joint distribution P = (P + K.transpose(P)) / 2.0 P = P / K.sum(P) # marginal distributions Pi = K.expand_dims(K.sum(P, axis=1), axis=1) Pj = K.expand_dims(K.sum(P, axis=0), axis=0) Pi = K.repeat_elements(Pi, rep=n_labels, axis=1) Pj = K.repeat_elements(Pj, rep=n_labels, axis=0) P = K.clip(P, K.epsilon(), np.finfo(float).max) Pi = K.clip(Pi, K.epsilon(), np.finfo(float).max) Pj = K.clip(Pj, K.epsilon(), np.finfo(float).max) # negative MI loss neg_mi = K.sum((P * (K.log(Pi) + K.log(Pj) - K.log(P)))) # each head contribute 1/n_heads to the total loss return neg_mi / self.args.heads # train the model def train(self): accuracy = AccuracyCallback(self) lr_scheduler = LearningRateScheduler(lr_schedule, verbose=1) callbacks = [accuracy, lr_scheduler] self._model.fit_generator(generator=self.train_gen, use_multiprocessing=True, epochs=self.args.epochs, callbacks=callbacks, workers=4, shuffle=True) # pre-load test data for evaluation def load_eval_dataset(self): (_, _), (x_test, self.y_test) = self.args.dataset.load_data() image_size = x_test.shape[1] x_test = np.reshape(x_test, [-1, image_size, image_size, 1]) x_test = x_test.astype('float32') / 255 x_eval = np.zeros([x_test.shape[0], *self.train_gen.input_shape]) for i in range(x_eval.shape[0]): x_eval[i] = center_crop(x_test[i]) self.x_test = x_eval # reload model weights for evaluation def load_weights(self): if self.args.restore_weights is None: raise ValueError("Must load model weights for evaluation") if self.args.restore_weights: folder = "weights" os.makedirs(folder, exist_ok=True) path = os.path.join(folder, self.args.restore_weights) print("Loading weights... ", path) self._model.load_weights(path) # evaluate the accuracy of the current model weights def eval(self): y_pred = self._model.predict(self.x_test) print("") # accuracy per head for head in range(self.args.heads): if self.args.heads == 1: y_head = y_pred else: y_head = y_pred[head] y_head = np.argmax(y_head, axis=1) accuracy = unsupervised_labels(list(self.y_test), list(y_head), self.n_labels, self.n_labels) info = "Head %d accuracy: %0.2f%%" if self.accuracy > 0: info += ", Old best accuracy: %0.2f%%" data = (head, accuracy, self.accuracy) else: data = (head, accuracy) print(info % data) # if accuracy improves during training, # save the model weights on a file if accuracy > self.accuracy \ and self.args.save_weights is not None: self.accuracy = accuracy folder = self.args.save_dir os.makedirs(folder, exist_ok=True) path = os.path.join(folder, self.args.save_weights) print("Saving weights... ", path) self._model.save_weights(path) @property def model(self): return self._model
caption_model = Model(inputs=[inputs1, inputs2], outputs=outputs) caption_model.layers[2].set_weights([embedding_matrix]) caption_model.layers[2].trainable = False caption_model.compile(loss='categorical_crossentropy', optimizer='adam') number_pics_per_bath = 3 steps = len(train_descriptions)//number_pics_per_bath model_path = os.path.join(root_captioning,"data",f'caption-model-coco.hdf5') if not os.path.exists(model_path): for i in tqdm(range(EPOCHS*2)): generator = data_generator(train_descriptions, encoding_train, wordtoidx, max_length, number_pics_per_bath) caption_model.fit_generator(generator, epochs=1, steps_per_epoch=steps, verbose=1) caption_model.optimizer.lr = 1e-4 number_pics_per_bath = 6 steps = len(train_descriptions)//number_pics_per_bath for i in range(EPOCHS): generator = data_generator(train_descriptions, encoding_train, wordtoidx, max_length, number_pics_per_bath) caption_model.fit_generator(generator, epochs=1, steps_per_epoch=steps, verbose=1) caption_model.save_weights(model_path) print(f"\Training took: {hms_string(time()-start)}") else: caption_model.load_weights(model_path) def generateCaption(photo):
def main(): directory = 'img' # 画像が保存されているフォルダ df_train = pd.read_csv('train.csv') # 学習データの情報がかかれたDataFrame df_validation = pd.read_csv('val.csv') # 検証データの情報がかかれたDataFrame df_test = pd.read_csv('test.csv') # テストデータの情報がかかれたDataFrame label_list = ['AMD', 'DR_DM', 'Gla', 'MH', 'Normal', 'RD', 'RP', 'RVO'] # ラベル名 image_size = (224, 224) # 入力画像サイズ classes = len(label_list) # 分類クラス数 batch_size = 32 # バッチサイズ epochs = 300 # エポック数 loss = 'categorical_crossentropy' # 損失関数 optimizer = Adam(lr=0.00001, amsgrad=True) # 最適化関数 metrics = 'accuracy' # 評価方法 # ImageDataGenerator画像増幅のパラメータ aug_params = {'rotation_range': 5, 'width_shift_range': 0.05, 'height_shift_range': 0.05, 'shear_range': 0.1, 'zoom_range': 0.05, 'horizontal_flip': True, 'vertical_flip': True} # val_lossが最小になったときのみmodelを保存 mc_cb = ModelCheckpoint('model_weights.h5', monitor='val_loss', verbose=1, save_best_only=True, mode='min') # 学習が停滞したとき、学習率を0.2倍に rl_cb = ReduceLROnPlateau(monitor='loss', factor=0.2, patience=3, verbose=1, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) # 学習が進まなくなったら、強制的に学習終了 es_cb = EarlyStopping(monitor='loss', min_delta=0, patience=5, verbose=1, mode='auto') # データの数に合わせて損失の重みを調整 weight_balanced = {} for i, label in enumerate(label_list): weight_balanced[i] = (df_train['label'] == label).sum() max_count = max(weight_balanced.values()) for label in weight_balanced: weight_balanced[label] = max_count / weight_balanced[label] print(weight_balanced) # ジェネレータの生成 ## 学習データのジェネレータ datagen = ImageDataGenerator(rescale=1./255, **aug_params) train_generator = datagen.flow_from_dataframe( dataframe=df_train, directory=directory, x_col='filename', y_col='label', target_size=image_size, class_mode='categorical', classes=label_list, batch_size=batch_size) step_size_train = train_generator.n // train_generator.batch_size ## 検証データのジェネレータ datagen = ImageDataGenerator(rescale=1./255) validation_generator = datagen.flow_from_dataframe( dataframe=df_validation, directory=directory, x_col='filename', y_col='label', target_size=image_size, class_mode='categorical', classes=label_list, batch_size=batch_size) step_size_validation = validation_generator.n // validation_generator.batch_size # ネットワーク構築 base_model = EfficientNetB0(include_top=False, weights='imagenet', pooling='avg', input_shape=(image_size[0], image_size[1], 3), backend=tf.keras.backend, layers=tf.keras.layers, models=tf.keras.models, utils=tf.keras.utils) x = Dense(256, kernel_initializer='he_normal')(base_model.output) x = Dense(classes, kernel_initializer='he_normal')(x) outputs = Activation('softmax')(x) model = Model(inputs=base_model.inputs, outputs=outputs) model.summary() model.compile(loss=loss, optimizer=optimizer, metrics=[metrics]) # 学習 history = model.fit_generator( train_generator, steps_per_epoch=step_size_train, epochs=epochs, verbose=1, callbacks=[mc_cb, rl_cb, es_cb], validation_data=validation_generator, validation_steps=step_size_validation, class_weight=weight_balanced, workers=3) # 学習曲線の保存 plot_history(history) # テストデータの評価 ## 学習済み重みの読み込み model.load_weights('model_weights.h5') ## 推論 X = df_test['filename'].values y_true = list(map(lambda x: label_list.index(x), df_test['label'].values)) y_pred = [] for file in tqdm(X, desc='pred'): # 学習時と同じ条件になるように画像をリサイズ&変換 img = Image.open(f'{directory}/{file}') img = img.resize(image_size) img = np.array(img, dtype=np.float32) img *= 1./255 img = np.expand_dims(img, axis=0) y_pred.append(np.argmax(model.predict(img)[0])) ## 評価 print(classification_report(y_true, y_pred, target_names=label_list))
include_top=False, weights='imagenet') w = base_model.output w = Flatten()(w) w = Dense(256, activation="relu")(w) w = Dense(128, activation="relu")(w) output = Dense(17, activation="sigmoid")(w) # Compile the model for execution. Losses and optimizers # can be anything here, since we don’t train the model. model = Model(inputs=[base_model.inputs[0]], outputs=[output]) model.layers[-6].trainable = True model.layers[-7].trainable = True model.layers[-8].trainable = True #train NN model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) model.fit_generator(generator=train_generator, steps_per_epoch=STEP_SIZE_TRAIN, validation_data=val_generator, validation_steps=STEP_SIZE_VALID, epochs=EpochSize, class_weight=weights) model.save('EfficientNetB5_Comp.h5')
print(layer.name, layer.trainable) # compile the model print("----------Compiling model----------") optim = Adam(lr=init_LR, decay=init_LR / Epochs) model.compile(loss="binary_crossentropy", optimizer=optim, metrics=["accuracy"]) # train the head of the network print("----------Training head----------") trainHead = model.fit_generator(traindataAugm.flow(train_X, train_Y, batch_size=BS), steps_per_epoch=len(train_X) // BS, validation_data=(val_X, val_Y), validation_steps=len(val_X) // BS, epochs=Epochs) # make predictions on the testing set print("----------Evaluating test set----------") testpred = model.predict(test_X, batch_size=BS) # set label with corresponding largest predicted probability testpred_a = (testpred[:, 1] > 0.5) * 1 #Classification report ######################### print( classification_report(test_Y.argmax(axis=1),
# 設定凍結與要進行訓練的網路層 net_final = Model(inputs=net.input, outputs=output_layer) for layer in net_final.layers[:FREEZE_LAYERS]: layer.trainable = False for layer in net_final.layers[FREEZE_LAYERS:]: layer.trainable = True # 使用 Adam optimizer,以較低的 learning rate 進行 fine-tuning net_final.compile(optimizer=Adam(lr=1e-5), loss='categorical_crossentropy', metrics=['accuracy']) logdir = os.path.join( "logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir, histogram_freq=1) # 輸出整個網路結構 print(net_final.summary()) # 訓練模型 net_final.fit_generator(train_batches, steps_per_epoch=train_batches.samples // BATCH_SIZE, validation_data=valid_batches, validation_steps=valid_batches.samples // BATCH_SIZE, epochs=NUM_EPOCHS, callbacks=[tensorboard_callback]) # 儲存訓練好的模型 net_final.save(WEIGHTS_FINAL) # 如果需要show出tensorboard的圖 使用下面這行 # %tensorboard --logdir logs
else: file_name = "dense" checkpointer = ModelCheckpoint( "../data/models/" + file_name + "_ms_transfer_alternative_init." + "{epoch:02d}-{val_categorical_accuracy:.3f}." + "hdf5", monitor='val_categorical_accuracy', verbose=1, save_best_only=True, mode='max') earlystopper = EarlyStopping(monitor='val_categorical_accuracy', patience=10, mode='max', restore_best_weights=True) history = model.fit_generator(train_generator, steps_per_epoch=1000, epochs=10000, callbacks=[checkpointer, earlystopper], validation_data=validation_generator, validation_steps=500) initial_epoch = len(history.history['loss']) + 1 # at this point, the top layers are well trained and we can start fine-tuning # convolutional layers. We will freeze the bottom N layers # and train the remaining top layers. # let's visualize layer names and layer indices to see how many layers # we should freeze: names = [] for i, layer in enumerate(model.layers): names.append([i, layer.name, layer.trainable]) print(names)
Batch_size = 128 train_generator = gen.flow_from_directory(train_path, shuffle=True, target_size=img_size, batch_size=Batch_size) valid_generator = gen.flow_from_directory(validation_path, target_size=img_size, batch_size=Batch_size) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # adding early stopping from tensorflow.keras.callbacks import EarlyStopping early_stop = EarlyStopping(monitor='val_loss', patience=2) #fit model results = model.fit_generator(train_generator, validation_data=valid_generator, epochs=25, callbacks=[early_stop]) #accuracy= approx 90% # model.save('rock_paper_scissor.h5')
optimizer = Adam(0.001) combine.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['categorical_accuracy']) train_loader = DataGenerator(way=train_way, query=train_query, shot=shot, num_batch=1000) val_loader = DataGenerator(data_type='val',way=val_way, shot=shot) test_loader = DataGenerator(data_type='test',way=val_way, shot=shot, num_batch=1000) save_conv = SaveConv() reduce_lr = cb.ReduceLROnPlateau(monitor='val_loss', factor=0.4,patience=2, min_lr=1e-8) lr_sched = cb.LearningRateScheduler(scheduler) tensorboard = cb.TensorBoard() combine.fit_generator(train_loader,epochs=50,validation_data=val_loader, use_multiprocessing=True, workers=4, shuffle=False, callbacks=[save_conv, lr_sched, tensorboard]) combine.evaluate(test_loader) save_model(conv, "model/miniimage_conv_{epoch}_{shot}_{val_way}") combine.evaluate(test_loader) # images, labels = zip(*list(loader('python/images_background'))) # images = np.expand_dims(images, axis=-1) # images = np.repeat(images, repeats=3, axis=-1) # print(images.shape) # main_labels, sub_labels= [x[0] for x in labels], [x[1] for x in labels] # encoder = LabelBinarizer() # enc_main_labels = encoder.fit_transform(main_labels) # output_num = len(np.unique(main_labels))
figPath = os.path.join(model_dir, 'checkpoints', 'progress', 'train.png') jsonPath = os.path.join(model_dir, 'checkpoints', 'progress', 'train.json') train_monitor = TrainingMonitor(figPath, jsonPath=jsonPath, startAt=init_epoch_train) # TypeError: Object of type float32 is not JSON serializable # train_monitor = TrainingMonitor(figPath) callbacks_list = [early_stop, reduce_lr, checkpoint, train_monitor] history = model.fit_generator(train_generator, steps_per_epoch=train_steps, epochs=train_epochs, validation_data=validation_generator, validation_steps=validation_steps, class_weight=class_weights, initial_epoch=init_epoch_train, max_queue_size=15, workers=8, callbacks=callbacks_list) plot_history(history, save_fig=True, save_path=os.path.join('data', 'models', 'bottleneck.png')) print("\n") bn_end_time = datetime.now() print("[Info] Model Bottlenecking completed at: {}".format(bn_end_time)) bn_duration = bn_end_time - bn_start_time
class MINE: def __init__(self, args, backbone): """Contains the encoder, SimpleMINE, and linear classifier models, the loss function, loading of datasets, train and evaluation routines to implement MINE unsupervised clustering via mutual information maximization Arguments: args : Command line arguments to indicate choice of batch size, folder to save weights file, weights file name, etc backbone (Model): MINE Encoder backbone (eg VGG) """ self.args = args self.latent_dim = args.latent_dim self.backbone = backbone self._model = None self._encoder = None self.train_gen = DataGenerator(args, siamese=True, mine=True) self.n_labels = self.train_gen.n_labels self.build_model() self.accuracy = 0 def build_model(self): """Build the MINE model unsupervised classifier """ inputs = Input(shape=self.train_gen.input_shape, name="x") x = self.backbone(inputs) x = Flatten()(x) y = Dense(self.latent_dim, activation='linear', name="encoded_x")(x) # encoder is based on backbone (eg VGG) # feature extractor self._encoder = Model(inputs, y, name="encoder") # the SimpleMINE in bivariate Gaussian is used # as T(x,y) function in MINE (Algorithm 13.7.1) self._mine = SimpleMINE(self.args, input_dim=self.latent_dim, hidden_units=1024, output_dim=1) inputs1 = Input(shape=self.train_gen.input_shape, name="x") inputs2 = Input(shape=self.train_gen.input_shape, name="y") x1 = self._encoder(inputs1) x2 = self._encoder(inputs2) outputs = self._mine.model([x1, x2]) # the model computes the MI between # inputs1 and 2 (x and y) self._model = Model([inputs1, inputs2], outputs, name='encoder') optimizer = Adam(lr=1e-3) self._model.compile(optimizer=optimizer, loss=self.mi_loss) self._model.summary() self.load_eval_dataset() self._classifier = LinearClassifier(\ latent_dim=self.latent_dim) def mi_loss(self, y_true, y_pred): """ MINE loss function Arguments: y_true (tensor): Not used since this is unsupervised learning y_pred (tensor): stack of predictions for joint T(x,y) and marginal T(x,y) """ size = self.args.batch_size # lower half is pred for joint dist pred_xy = y_pred[0:size, :] # upper half is pred for marginal dist pred_x_y = y_pred[size:y_pred.shape[0], :] loss = K.mean(K.exp(pred_x_y)) loss = K.clip(loss, K.epsilon(), np.finfo(float).max) loss = K.mean(pred_xy) - K.log(loss) return -loss def train(self): """Train MINE to estimate MI between X and Y (eg MNIST image and its transformed version) """ accuracy = AccuracyCallback(self) lr_scheduler = LearningRateScheduler(lr_schedule, verbose=1) callbacks = [accuracy, lr_scheduler] self._model.fit_generator(generator=self.train_gen, use_multiprocessing=True, epochs=self.args.epochs, callbacks=callbacks, workers=4, shuffle=True) def load_eval_dataset(self): """Pre-load test data for evaluation """ (_, _), (x_test, self.y_test) = \ self.args.dataset.load_data() image_size = x_test.shape[1] x_test = np.reshape(x_test, [-1, image_size, image_size, 1]) x_test = x_test.astype('float32') / 255 x_eval = np.zeros([x_test.shape[0], *self.train_gen.input_shape]) for i in range(x_eval.shape[0]): x_eval[i] = center_crop(x_test[i]) self.y_test = to_categorical(self.y_test) self.x_test = x_eval def load_weights(self): """Reload model weights for evaluation """ if self.args.restore_weights is None: error_msg = "Must load model weights for evaluation" raise ValueError(error_msg) if self.args.restore_weights: folder = "weights" os.makedirs(folder, exist_ok=True) path = os.path.join(folder, self.args.restore_weights) print("Loading weights... ", path) self._model.load_weights(path) def eval(self): """Evaluate the accuracy of the current model weights """ # generate clustering predictions fr test data y_pred = self._encoder.predict(self.x_test) # train a linear classifier # input: clustered data # output: ground truth labels self._classifier.train(y_pred, self.y_test) accuracy = self._classifier.eval(y_pred, self.y_test) info = "Accuracy: %0.2f%%" if self.accuracy > 0: info += ", Old best accuracy: %0.2f%%" data = (accuracy, self.accuracy) else: data = (accuracy) print(info % data) # if accuracy improves during training, # save the model weights on a file if accuracy > self.accuracy \ and self.args.save_weights is not None: folder = self.args.save_dir os.makedirs(folder, exist_ok=True) args = (self.latent_dim, self.args.save_weights) filename = "%d-dim-%s" % args path = os.path.join(folder, filename) print("Saving weights... ", path) self._model.save_weights(path) if accuracy > self.accuracy: self.accuracy = accuracy @property def model(self): return self._model @property def encoder(self): return self._encoder @property def classifier(self): return self._classifier
subset='validation') import tensorflow.keras.layers as layers from tensorflow.keras.layers import Input, Dense, Flatten, Conv2D, MaxPooling2D, BatchNormalization, Dropout, Reshape, Concatenate, LeakyReLU from tensorflow.keras.models import Model, Sequential from tensorflow.keras.applications import MobileNetV2 x = Input(shape=(256, 256, 3)) #ImageNet weights model_mn = MobileNetV2(input_shape=(256, 256, 3), alpha=1.3, include_top=False) #Use the generated model output_mn = model_mn(x) #Add the fully-connected layers y = Flatten()(output_mn) y = Dense(1000, activation='relu')(y) y = Dense(1000, activation='relu')(y) y = Dropout(0.5)(y) y = Dense(1, activation='sigmoid')(y) model = Model(inputs=x, outputs=y) model.summary() model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit_generator(training_images, validation_data=validation_images, epochs=10)
mode='auto') es = EarlyStopping(mode='min', monitor='val_loss', min_delta=0.001, verbose=1) adam = Adam(lr=1e-5, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy']) model.summary() print("Traning Model...") history = model.fit_generator(train_data_gen, epochs=epochs, verbose=1, validation_data=valid_data_gen, callbacks=[checkpoint, es], steps_per_epoch=len(train_data_gen), validation_steps=len(valid_data_gen)) # test y_pred = model.predict(test_data_gen) y_pred_labels = np.argmax(y_pred, axis=1) print('VGG16,acc on test:\t', accuracy_score(test_data_gen.classes, y_pred_labels)) confusion_matrix = metrics.confusion_matrix(y_true=test_data_gen.classes, y_pred=y_pred_labels) print(confusion_matrix)
save_best_only=True, mode='max') reduce_lr = ReduceLROnPlateau(monitor='val_top_3_accuracy', factor=0.5, patience=2, verbose=1, mode='max', min_lr=0.00001) callbacks_list = [checkpoint, reduce_lr] history = model.fit_generator(train_batches, steps_per_epoch=train_steps, class_weight=class_weights, validation_data=valid_batches, validation_steps=val_steps, epochs=30, verbose=0, callbacks=callbacks_list) # Now we need to conver the model.h5 model to a tflite model so that it is # compatible with the tensorflow android app. new_model = tf.keras.models.load_model(filepath="model.h5", custom_objects={ 'top_2_accuracy': top_2_accuracy, 'top_3_accuracy': top_3_accuracy }) tflite_converter = tf.lite.TFLiteConverter.from_keras_model(new_model) tflite_model = tflite_converter.convert()
#Plot the accuracy............... plt.plot(r.history['accuracy'], label='accuracy') plt.plot(r.history['val_accuracy'], label='val_accuracy') plt.legend() plt.show() #Fit the model with data augmentation #Remember:: If you run this after first fit, it will continue training where it left off. batch_size = 32 data_generator = tf.keras.preprocessing.image.ImageDataGenerator( width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True) train_generator = data_generator.flow(x_train, y_train, batch_size) steps_per_epochs = x_train.shape[0] // batch_size r = model.fit_generator(train_generator, validation_data=(x_test, y_test), steps_per_epoch=steps_per_epochs, epochs=7) #Plot the loss........... plt.plot(r.history['loss'], label='loss') plt.plot(r.history['val_loss'], label='val_loss') plt.legend() plt.show() #Plot the accuracy............ plt.plot(r.history['accuracy'], label='accuracy') plt.plot(r.history['val_accuracy'], label='val_accuracy') plt.legend() plt.show()
es = EarlyStopping(monitor='val_loss', patience=15, mode='min') file_path = 'c:/data/modelcheckpoint/lotte_last5.hdf5' mc = ModelCheckpoint(file_path, monitor='val_loss', save_best_only=True, mode='min', verbose=1) rl = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, verbose=1, mode='min') model.fit_generator(xy_train, steps_per_epoch=(xy_train.samples / xy_train.batch_size), epochs=1000, validation_data=xy_val, validation_steps=(xy_val.samples / xy_val.batch_size), callbacks=[es, mc, rl]) from tensorflow.keras.models import load_model model = load_model('c:/data/modelcheckpoint/lotte_last5.hdf5') for i in range(72000): image = Image.open(f'../data/lotte/test/test/{i}.jpg') image.save('../data/lotte/test_new/test_new/{0:05}.jpg'.format(i)) test_data = test_datagen.flow_from_directory('../data/lotte/test_new', target_size=(img_size, img_size), batch_size=batch, class_mode=None, shuffle=False)
# Use GPU strategy = tf.distribute.MirroredStrategy() with strategy.scope(): base_model = ResNet50(weights='imagenet', include_top=False) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(512, activation='relu')(x) predictions = Dense(n_classes, activation = 'softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) for layer in base_model.layers: layer.trainable = False # define optimizers model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.summary() # training model.fit_generator(generator=train_generator, validation_data=test_generator, use_multiprocessing=True, workers=Config['num_workers'], )
beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) model_final.compile(loss='binary_crossentropy', optimizer=optim, metrics=['accuracy', keras_metrics.fbeta_score]) #%% history = model_final.fit_generator( image_generator(image_list, labels, batch_size=16, selection_indices=train_indices), steps_per_epoch=len(train_indices) / 16, epochs=10, validation_data=image_generator(image_list, labels, batch_size=16, selection_indices=val_indices), validation_steps=len(val_indices) / 16) #%% # model_final.summary() print(len(model_final.layers[-3:])) # for layer in model_final.layers[:-3]: # layer.trainable = False #%% #%%
'ctc_loss': lambda y_true, y_pred: y_pred }, optimizer="adam") complete_model.summary() def decode_examples(images, labels): """Transform our output for example logging""" return complete_model.predict(format_batch_ctc(images, labels)[0])[1] # Initialize generators and train train = Generator(dataset.x_train, dataset.y_train, batch_size=32, format_fn=format_batch_ctc) test = Generator(dataset.x_test, dataset.y_test, batch_size=32, format_fn=format_batch_ctc) complete_model.fit_generator( train, epochs=75, callbacks=[ ExampleLogger(dataset, decode_examples), ModelCheckpoint("best-ctc.h5", save_best_only=True) ], validation_data=test, )
horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label\naccuracy={:0.4f}; misclass={:0.4f}'.format( accuracy, misclass)) plt.show() save_models = tf.keras.models.load_model('saved_model.h5', compile=False) save_models.compile(Adam(lr=0.0001), loss='categorical_crossentropy', metrics=['accuracy']) trained_model = model.fit_generator(train_batch, validation_data=test_batch, epochs=30) loss, accuracy = save_models.evaluate(test_batch) print(f'loss: {loss} and accuracy: {accuracy*100}') # new_model = model.save("saved_model.h5") test_labels = test_batch.classes # this line shows classes and store into test_labels print(test_labels) # shows classes print(test_batch.class_indices ) # show class indices like 0 for car 1 for cat 2 for man predictions = save_models.predict_generator(test_batch) cm = confusion_matrix(test_labels, predictions.argmax(axis=1)) print(f'model input : {model.input}, model input_names : {model.input_names} ') print( f'model output : {model.output}, model output_names : {model.output_names} ' )
# use generator training_generator = DataProcessor(train_list) validation_generator = DataProcessor(valid_list) # dataIt = iter(training_generator) # for i in range(2): # x, y = next(dataIt) # print(x[0]) ''' training ''' early = EarlyStopping(monitor='val_loss', mode='min', patience=3, min_delta=0.01) model.fit_generator(training_generator, validation_data=validation_generator, epochs=20, callbacks=[early], use_multiprocessing=True, workers=2) # save weights if not os.path.exists('./weights'): os.makedirs('./weights') model.save_weights('./weights/mnist.h5') ''' test (eval) ''' test_files = [] for root, _, files in os.walk('./data/testing'): for fname in files: filepath = os.path.join(root, fname) test_files.append(filepath)
input_shape=(64, 64, 3)) resnet.trainable = False x = resnet.output x = GlobalAveragePooling2D()(x) x = Dense(128, activation='relu')(x) x = Dropout(0.2)(x) predictions = Dense(n_classes, kernel_regularizer=regularizers.l2(0.005), activation='softmax')(x) model = Model(inputs=resnet.input, outputs=predictions) model.compile(optimizer='SGD', loss='binary_crossentropy', metrics=['accuracy']) history = model.fit_generator( train_generator, steps_per_epoch=150, epochs=350, verbose=1, ) model.save('papaya.hdf5') plt.title('epochs vs loss') plt.plot(history.history['loss']) plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train_loss', 'validation_loss'], loc='best') plt.show()
center_loss = get_center_loss(0.5, num_classes, feature_dim) adam = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) custom_model.compile(loss={ 'prediction': 'sparse_categorical_crossentropy', 'features': center_loss }, optimizer=adam, metrics={'prediction': 'accuracy'}) pdb.set_trace() ############################################################################## history = custom_model.fit_generator( train_generator, steps_per_epoch=(num_train_samples) // batch_size, validation_data=validation_generator, validation_steps=(num_validation_samples) // batch_size, epochs=25) print(history.history.keys()) # summarize history for accuracy plt.plot(history.history['prediction_accuracy']) plt.plot(history.history['val_prediction_accuracy']) plt.title('Model accuracy of prediction') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.show() plt.plot(history.history['features_loss']) plt.plot(history.history['val_features_loss']) plt.title('model loss of features')
min_delta=0.00008, mode='max', cooldown=3, verbose=1), ModelCheckpoint("./models/lstm_xception_full1.h5", monitor='val_top_3_accuracy', mode='max', save_best_only=True, verbose=1) ] hists = [] hist = model.fit_generator(train_datagen, steps_per_epoch=STEPS, epochs=EPOCHS, verbose=1, validation_data=val_datagen, validation_steps=500, callbacks=callbacks) hists.append(hist) # Validation print("Running validation") df = pd.read_csv(os.path.join(DP_DIR, 'train_k{}.csv.gz'.format(NCSVS - 1)), nrows=34000) for i in range(10): valid_df = df.loc[i * 3400:(i + 1) * 3400, :].copy() x_valid, x2 = df_to_image_array_xd(valid_df, SIZE) y_valid = keras.utils.to_categorical(valid_df.y, num_classes=NCATS) print(x_valid.shape, y_valid.shape)
headModel = baseModel.output headModel = AveragePooling2D(pool_size=(4, 4))(headModel) headModel = Flatten(name="flatten")(headModel) headModel = Dense(64, activation="relu")(headModel) headModel = Dropout(0.5)(headModel) headModel = Dense(3, activation="softmax")(headModel) # place the head FC model on top of the base model (this will become # the actual model we will train) model = Model(inputs=baseModel.input, outputs=headModel) # loop over all layers in the base model and freeze them so they will # *not* be updated during the first training process for layer in baseModel.layers: layer.trainable = False # In[ ]: # compile our model print("[INFO] compiling model...") opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS) model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"]) # train the head of the network print("[INFO] training head...") H = model.fit_generator(trainAug.flow(trainX, trainY, batch_size=BS), steps_per_epoch=len(trainX) // BS, validation_data=(testX, testY), validation_steps=len(testX) // BS, epochs=EPOCHS) # In[ ]:
loss="categorical_crossentropy", metrics=['accuracy'], ) # train the model # define callback function early_stopping = EarlyStopping(monitor='val_loss', patience=10, ) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, ) model.fit_generator(train_generator, steps_per_epoch=train_image_numbers//batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=validation_steps, callbacks=[early_stopping, reduce_lr], ) # test the model test_metrics = model.evaluate_generator(test_generator, steps=1, ) for i in zip(model.metrics_names, test_metrics): print(i) # save the model model.save(model_filepath)