validation_data=valid_batches, validation_steps=4, epochs=9, verbose =2) # observe metrics from training- compare with 3X64 node CNN created previously- use the better one # also check for overfitting """# Predictions""" # test_imgs, test_labels = next(test_batches) plots(test_imgs, titles=test_labels) # 0th index so that empty/occupied gets values 0/1 or vice versa test_labels = test_labels[:,0] # set steps according to : test set image count (eg. 10) and batch size: (eg. 10), so it takes 1 step to run through the batch of imgs predictions = model.predict_generator(test_batches, steps=1, verbose=0) # create confusion matrix variable cm = confusion_matrix(test_labels, np.round(predictions[:,0])) cm_plot_labels = ['empty', 'occupied'] plot_confusion_matrix(cm, cm_plot_labels, title='Confusion Matrix') # plots predicted labels vs true labels on x-y axis -observe values # accuracy might depend on amount of data used for training, epochs (can use library/tool "..." to get optimal value), and other tweaks # compare confusion matrix with previously built 3X64 CNN model - use the best one """# Confusion Matrix -Plot Predicted labels vs True labels """ # insert code (included above) #.
print("acc : ", acc) print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') print('(ง˙∇˙)ว {오늘 안에 조지고만다!!!]') x_pred = np.load('../data/vision2/predict_data.npy') x_pred = x_pred.reshape(-1, 128, 128, 1) print(x_pred.shape) x_pred = x_pred / 255.0 pred_generator = idg2.flow(x_pred, shuffle=False) y_predict = model.predict_generator(pred_generator, verbose=True) print("결과!!!!!!!!!!!!") print(y_predict) sub = pd.read_csv('../data/vision2/sample_submission.csv') sub['a'] = np.where(y_predict > 0.5, 1, 0) sub.to_csv('../data/vision2/file/submission2.csv', index=False)
validation_data=valid_generator, callbacks=[es, mc2, lr]) learning_history_3 = model3.fit_generator(train_generator3, epochs=1000, validation_data=valid_generator, callbacks=[es, mc3, lr]) # predict model1.load_weights( f'c:/data/test/mnist/checkpoint/mnist_checkpoint9_1.hdf5') model2.load_weights( f'c:/data/test/mnist/checkpoint/mnist_checkpoint9_2.hdf5') model3.load_weights( f'c:/data/test/mnist/checkpoint/mnist_checkpoint9_3.hdf5') result1 += model1.predict_generator(test_generator, verbose=True) / 40 result2 += model2.predict_generator(test_generator, verbose=True) / 40 result3 += model3.predict_generator(test_generator, verbose=True) / 40 # save val_loss hist1 = pd.DataFrame(learning_history_1.history) hist2 = pd.DataFrame(learning_history_2.history) hist3 = pd.DataFrame(learning_history_3.history) val_loss_min1.append(hist1['val_loss'].min()) val_loss_min2.append(hist2['val_loss'].min()) val_loss_min3.append(hist3['val_loss'].min()) nth += 1 print(nth, '번째 학습을 완료했습니다.')
callbacks = [ TensorBoard(log_dir="logs/{}".format(NAME)), EarlyStopping(monitor='val_loss', min_delta=0, patience=2, verbose=0, mode='auto', baseline=None, restore_best_weights=False) ] model.fit_generator(train_generator, callbacks=callbacks, steps_per_epoch=TRAIN_STEP, epochs=EPOCHS, validation_data=validation_generator, validation_steps=VALIDATION_STEP) score = model.evaluate_generator(validation_generator, VALIDATION_STEP / BATCH_SIZE, workers=12) scores = model.predict_generator(validation_generator, VALIDATION_STEP / BATCH_SIZE, workers=12) model.save(FILE_NAME) with open("logs/mylog.txt", "a") as f: f.write("\n\n--------" + NAME + "----------\n") f.write(str(score) + "\n")
model.add(Dense(10, activation='softmax')) model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(lr=0.002, epsilon=None), metrics=['acc']) #sparse_categorical_crossentropy : 다중분류 손실 함수. categorical_crossentropy와 동일하지만 원핫인코딩안해도 된다. # epsilon : 0으로 나누어지는 것을 방지 learning_history = model.fit_generator(train_generator, epochs=1000, validation_data=valid_generator, callbacks=[es, mc, reLR]) # predict model.load_weights('../dacon7/check/best_cvision.h5') result += model.predict_generator(test_generator, verbose=True) / 80 # save val_loss hist = pd.DataFrame(learning_history.history) val_loss_min.append(hist['val_loss'].min()) nth += 1 print(nth, '번째 학습을 완료했습니다.') print(val_loss_min, np.mean(val_loss_min)) model.summary() # Submission sub['digit'] = result.argmax(1)
model.add(Dense(128,activation='relu')) model.add(BatchNormalization()) model.add(Dense(64,activation='relu')) model.add(BatchNormalization()) model.add(Dense(10,activation='softmax')) model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(lr=0.002,epsilon=None),metrics=['acc']) learning_history = model.fit_generator(train_generator,epochs=2000, validation_data=valid_generator, callbacks=[es,mc,reLR]) #4. Evaluate, Predict loss, acc = model.evaluate(test_generator) print("loss : ", loss) print("acc : ", acc) # predict result += model.predict_generator(pred_generator, verbose=True)/n_splits_num # save val_loss hist = pd.DataFrame(learning_history.history) val_loss_min.append(hist['val_loss'].min()) nth += 1 print(nth, '번째 학습을 완료했습니다.') sub['digit'] = result.argmax(1) sub.to_csv('C:/data/dacon/mnist1/submit/210204_2.csv', index = False)
metrics=['accuracy']) nb_epochs = 2 history = model.fit_generator( train_generator, steps_per_epoch=train_generator.samples // batch_size, validation_data=validation_generator, validation_steps=validation_generator.samples // batch_size, epochs=nb_epochs) # Plot training & validation accuracy values plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('Model accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') name = 'jmatt_arch_sketches_orig_tune' model.save(f'../output/{name}.h5') plt.savefig(f'../output/{name}.png') acc = model.evaluate_generator(validation_generator, steps=np.floor(validation_generator.n / batch_size), verbose=1) print(acc) probs = model.predict_generator(validation_generator)
batch_size=batch_size, shuffle=False) test_generator = TimeseriesGenerator(X_test, y_test, length=window_size, batch_size=1, shuffle=False) model = Sequential() model.add(CuDNNGRU(128, input_shape=( window_size, X_train.shape[1], ))) model.add(Dense(64, activation='relu')) model.add(Dense(64, activation='relu')) model.add(Dense(64, activation='relu')) model.add(Dense(y_train.shape[1], activation='softmax')) # Run training model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model.fit_generator(train_generator, epochs=epochs) print(model.evaluate_generator(test_generator)) y_true = np.argmax(y_test[window_size:], axis=1) y_pred = np.argmax(model.predict_generator(test_generator), axis=1) print('Confusion matrix') print(confusion_matrix(y_true, y_pred))
# fit model history = model.fit_generator(generator=training_generator, epochs=100, verbose=2, validation_data=validation_generator, callbacks=[checkpoint, early_stopping_callback], use_multiprocessing=False) # plot history pyplot.plot(history.history['loss'], label='train') pyplot.plot(history.history['val_loss'], label='test') pyplot.legend() pyplot.show() # make a prediction test_pred = model.predict_generator(validation_generator) print(test_pred.shape) test_pred = test_pred.reshape(test_pred.shape[0] // 10, 10, test_pred.shape[1]) test_y_list = [] test_pred_list = [] x_labels = [] for k in range(10): x_labels.append('Day' + str(k)) for i in range(test_pred.shape[0]): for j in range(test_pred.shape[1]): temp = np.load('data/data_rows_target/' + 'shop_' + str(i) + '_target' + '.npy') sum_per_day_y = 0
def build_model(): model = Sequential() model.add( Conv2D(filters=32, kernel_size=(3, 3), activation="relu", padding="same", input_shape=(256, 256, 1))) model.add( Conv2D(filters=32, kernel_size=(3, 3), activation="relu", padding="same")) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(rate=0.25)) model.add( Conv2D(filters=64, kernel_size=(3, 3), activation="relu", padding="same")) model.add( Conv2D(filters=64, kernel_size=(3, 3), activation="relu", padding="same")) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(rate=0.25)) model.add(Flatten()) model.add(Dense(1024, activation="relu")) model.add(BatchNormalization()) model.add(Dropout(rate=0.4)) model.add(Dense(6, activation="softmax")) gen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) train_batches = gen.flow_from_directory("runes/mutated", model.input_shape[1:3], color_mode="grayscale", shuffle=True, seed=1, batch_size=16) valid_batches = gen.flow_from_directory("runes/validation", model.input_shape[1:3], color_mode="grayscale", shuffle=True, seed=1, batch_size=16) test_batches = gen.flow_from_directory("runes/testing", model.input_shape[1:3], shuffle=False, color_mode="grayscale", batch_size=8) model.compile(Adam(lr=0.001), loss="categorical_crossentropy", metrics=["accuracy"]) history1 = model.fit_generator(train_batches, steps_per_epoch=163, epochs=5, validation_data=valid_batches, validation_steps=624) p = model.predict_generator(test_batches, verbose=True) # recall_score(pre["label"], pre["pre"]) #roc_auc_score(pre["label"], pre[1]) #true_positive_rate, false_positive_rate, threshold = roc_curve(pre["label"], pre[1]) # roc = DataFrame([true_positive_rate, false_positive_rate]).T # roc.plot(x=0,y=1) plt.plot(history1.history['accuracy']) plt.plot(history1.history['val_accuracy']) plt.axhline(0, color="black") plt.axvline(0, color="black") plt.title('Model Accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Training set', 'Validation set'], loc='upper left') plt.show() plt.plot(history1.history['val_loss']) plt.plot(history1.history['loss']) plt.axhline(0, color="black") plt.axvline(0, color="black") plt.title('Model Loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Training set', 'Test set'], loc='upper left') plt.show() model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) model.save_weights_only = False model.save_weights("keras_model.h5")
class Model: def __init__(self, dataset, model_path): self.dataset = dataset self.model = Sequential() self.model_path = model_path def create(self, tile_size: (int, int)): input_shape = (*tile_size, 3) model = Sequential() model.add(Conv2D(filters=32, kernel_size=3, activation='relu', padding='same', input_shape=input_shape)) # model.add(Conv2D(filters=32, kernel_size=3, # padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPool2D()) model.add(Conv2D(filters=64, kernel_size=3, padding='same', activation='relu')) # model.add(Conv2D(filters=64, kernel_size=3, # padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPool2D()) model.add(Flatten()) model.add(Dense(64, activation='relu')) model.add(Dropout(0.3)) model.add(Dense(16, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile( loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() self.model = model def train(self, epochs, verbose=2): train_datagen = self._get_scaling_generator(self.dataset.X_train, self.dataset.Y_train) val_datagen = self._get_scaling_generator(self.dataset.X_test, self.dataset.Y_test) train_history = self.model.fit_generator(train_datagen, epochs=epochs, validation_data=val_datagen, verbose=verbose) fig, axes = plt.subplots(1, 2, sharex='all') axes[0].plot(train_history.history['loss']) axes[0].plot(train_history.history['val_loss']) axes[0].set_ylabel('loss') axes[1].plot(train_history.history['acc']) axes[1].plot(train_history.history['val_acc']) axes[1].set_ylabel('accuracy') axes[0].legend(['train loss', 'validation loss'], loc='best') axes[1].legend(['train accuracy', 'validation accuracy'], loc='best') fig.text(0.5, 0.02, "Number of epochs", horizontalalignment='center') plt.show() def evaluate(self): test_datagen = self._get_scaling_generator(self.dataset.X_test, self.dataset.Y_test) outputs = self.model.evaluate_generator(test_datagen) logger.info("Results: Loss: %.3f, Accuracy: %.3f", *outputs) def predict(self, verbose=1): test_datagen = self._get_scaling_generator(self.dataset.X_test, shuffle=False) results = self.model.predict_generator(test_datagen, verbose=verbose) return results def save(self): model_path = self.model_path self.model.save(model_path) def load(self): model_path = self.model_path self.model = load_model(model_path) @staticmethod def _get_scaling_generator(x, y=None, shuffle=True): datagen = ImageDataGenerator(rescale=1. / 255) return datagen.flow(x, y, shuffle=shuffle)
model.add(Dense(n_classes, activation='sigmoid')) # # compile the model using binary cross-entropy rather than # categorical cross-entropy -- this may seem counterintuitive for # multi-label classification, but keep in mind that the goal here # is to treat each output label as an independent Bernoulli # distribution model.compile(loss='binary_crossentropy', optimizer='adam', metrics=METRICS) ## Fit model for multiple labels and print accuracy history = model.fit_generator(generator=MyBatchGenerator(X_train, Y_train, batch_size=1), epochs=5) pred = model.predict_generator(generator=MyBatchGenerator(X_test, Y_test, batch_size=1), verbose=2) print(pred) # pred_proba = model.predict_proba(X_test) # preds = model.predict(X_test) # preds[preds>=0.5] = 1 # preds[preds<0.5] = 0 # # acc = history.history['accuracy'] # print(Y_test) # print(preds) # # # n_classes = len(ExtraSensoryFeaturesLabels.labels) # # Compute ROC curve and ROC area for each class # fpr = dict() # tpr = dict()
# ===== Load the model classifier = load_model("Smiling_recognition_classifier.h5") # %% # ===== Print the confusion matrix test_set_no_shuffle = test_data_gen.flow_from_directory( testing_folder, target_size=(IMG_HEIGHT, IMG_WIDTH), batch_size=BATCH_SIZE, class_mode='binary', shuffle=False) Y_pred = classifier.predict_generator(test_set_no_shuffle) y_pred = np.array(list(map(round, Y_pred.reshape(Y_pred.size)))) print('Confusion Matrix') print(confusion_matrix(test_set_no_shuffle.classes, y_pred)) # %% # ===== Function to test on a single image def test_single_image(path): X_test_input = [] img = image.load_img(path, target_size=(IMG_HEIGHT, IMG_WIDTH)) img = image.img_to_array(img).astype('float32') / 255 img = np.expand_dims(img, axis=0) X_test_input.append(img)
validation_steps=64, callbacks=[tb_callback, cp_callback]) print('TRAINING COMPLETE') model.save(MODEL_STRUCT_PATH) for dp in glob(os.path.join(TEST_DATA_PATH, '*')): for fp in glob(os.path.join(TEST_DATA_PATH, dp, '*')): (fn, _) = os.path.splitext(fp) arr = numpy.array( load_img(fp, target_size=(SIGN_IMG_HEIGHT, SIGN_IMG_WIDTH), grayscale=False, color_mode='rgb', interpolation='nearest')) a = get_activations(model, [[arr]], auto_compile=True) rp = os.path.join(KERACT_PATH, relative_path(fn, TEST_DATA_PATH)) display_activations(a, directory=rp, save=True) print(f'VISUALIZATION SAVED: {rp}') break print('DONE') yp = model.predict_generator(test_generator) yp = numpy.argmax(yp, axis=1) print('CONFUSION MATRIX:') print(confusion_matrix(test_generator.classes, yp)) print('Classification Report') print(classification_report(test_generator.classes, yp, target_names=TYPES))
print("evaluation time") evaluation = model.evaluate_generator(test_generator, steps=test_generator.n // test_generator.batch_size, verbose=1) print(evaluation) with open(output_dir + '/evaluation.txt', 'w') as f: f.write(str(evaluation[0]) + "\n") f.write(str(evaluation[1])) print("prediction time") test_generator.reset() pred = model.predict_generator(test_generator, steps=test_generator.n // test_generator.batch_size, verbose=1) predicted_class_indices = np.argmax(pred, axis=1) labels = (train_generator.class_indices) labels = dict((v, k) for k, v in labels.items()) predictions = [labels[k] for k in predicted_class_indices] filenames = test_generator.filenames results = pd.DataFrame({"Filename": filenames, "Predictions": predictions}) results.to_csv(output_dir + "/predictions.csv", index=False) np.save(output_dir + '/class_indices', train_generator.class_indices) model.save(output_dir + '/model.h5')
model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(lr=0.002, epsilon=None), metrics=['acc']) # epsilon : 0으로 나눠지는 것을 피하기 위함 learning_hist = model.fit_generator(train_generator, epochs=1000, validation_data=valid_generator, callbacks=[es, mc, reLR]) # model.load_weights('../data/DACON_vision1/cp/0203_4_cp.hdf5') #4. Evaluate, Predict loss, acc = model.evaluate(test_generator) print("loss : ", loss) print("acc : ", acc) result += model.predict_generator(pred_generator, verbose=True) / 40 # save val_loss hist = pd.DataFrame(learning_hist.history) val_loss_min.append(hist['val_loss'].min()) val_acc_max.append(hist['val_acc'].max()) nth += 1 print(nth, "번째 학습을 완료했습니다.") print("val_loss_min :", np.mean(val_loss_min)) # val_loss_mean : 0.1835539501160383 print("val_acc_max :", np.mean(val_acc_max)) # val_acc_max : 0.9512500002980232 # model.summary()
X_train, X_test, y_train, y_test = train_test_split(X, y, shuffle=False) train_data_gen = TimeseriesGenerator(X_train, y_train, length=window_size, batch_size=batch_size, shuffle=False) test_data_gen = TimeseriesGenerator(X_test, y_test, length=window_size, batch_size=batch_size, shuffle=False) model = Sequential() model.add(CuDNNGRU(4, input_shape=(window_size, 1,))) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') history = model.fit_generator(train_data_gen, epochs=epochs).history index = [df['Open'][0]] for i, d in enumerate(scaler.inverse_transform(data)): index.append(index[i] + d) index_train = [df['Open'][0]] for i, d in enumerate(scaler.inverse_transform(model.predict_generator(train_data_gen))): index_train.append(index_train[i] + d) index_test = [index_train[-1]] for i, d in enumerate(scaler.inverse_transform(model.predict_generator(test_data_gen))): index_test.append(index_test[i] + d) begin = window_size join = begin + len(index_train) end = join + len(index_test) plt.plot(index) plt.plot(list(range(begin, join)), index_train) plt.plot(list(range(join, end)), index_test) plt.show()