K.epsilon()) # return a single tensor value return _f1score ############################################################################################################### # 컴파일, 훈련 op = Adadelta(lr=1e-5) # model.compile(optimizer=op, loss="sparse_categorical_crossentropy", metrics=["acc",f1score]) model.compile(optimizer=op, loss="sparse_categorical_crossentropy", metrics=["acc"]) stop = EarlyStopping(monitor='val_loss', patience=20, restore_best_weights=True, verbose=1) lr = ReduceLROnPlateau(monitor='val_loss', vactor=0.5, patience=10, verbose=1) mcpath = 'C:/nmb/nmb_data/h5/speechvgg_mels_del4.h5' mc = ModelCheckpoint(mcpath, monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=True) tb = TensorBoard(log_dir='C:/nmb/nmb_data/graph/' + start.strftime("%Y%m%d-%H%M%S") + "/", histogram_freq=0, write_graph=True, write_images=True) history = model.fit(x_train, y_train,
print(inceptionv3.weights) inceptionv3.trainable = False inceptionv3.summary() print(len(inceptionv3.weights)) # 26 print(len(inceptionv3.trainable_weights)) # 0 model = Sequential() model.add(inceptionv3) model.add(Flatten()) model.add(Dense(10, activation='softmax')) model.summary() from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau es = EarlyStopping(monitor='val_loss', patience=15, mode='auto') lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) model.fit(x_train, y_train, epochs=1000, batch_size=16, validation_split=0.2, verbose=1, callbacks=[es, lr]) loss = model.evaluate(x_test, y_test) print(loss)
## 옵티마이져 #optimizer = Adam(lr=0.0001, beta_1 = 0.9, beta_2 = 0.999) # ADAM 옵티마이져, loss Mse # optimizer = RMSprop(learning_rate=0.001, rho= 0.9, momentum = 0.0, epsilon=0.0000001) # ADAM 옵티마이져, loss Mse #optimizer = SGD(learning_rate=0.0001,momentum=0.9,nesterov=True) #SGD는 별로 도움이 안됨 optimizer = Adamax(lr=0.001, beta_1=0.9, beta_2=0.999) #optimizer = Adagrad(lr=0.001, epsilon=1e-6) X #optimizer = Adadelta(lr=1.0, rho=0.95, epsilon=None, decay=0.0) #@optimizer = MomentumOptimizer(learning_rate=0.001, momentum=0.9) 못씀 model.compile(loss='mean_squared_error', optimizer=optimizer) # In[119]: epochs = 200 batch_size = 24 early_stopping = EarlyStopping(monitor='val_loss', patience=10, verbose=1) model.fit(train_x, train_y, batch_size=batch_size, epochs=epochs, validation_data=(val_x, val_y), callbacks=[early_stopping]) # In[108]: batch_size = 30 mae = [] epochs = 1 for i in range(0, 100): print(i + 1)
model.add(Flatten()) model.add(Dense(64, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) model.summary() model.compile(loss='binary_crossentropy', metrics=['acc'], optimizer='adam') modelPath = './homework/project1/models/checkpoints/PJ-Conv2D-{val_loss:.4f}.hdf5' checkPoint = ModelCheckpoint(filepath=modelPath, monitor='val_loss', save_best_only=True, mode='auto') ealyStopping = EarlyStopping(monitor='val_loss', mode='max', patience=20) for i in range(1, 11, 2): hist = model.fit(x_train, y_train, epochs=300, batch_size=16, validation_split=0.2, callbacks=[ealyStopping, checkPoint]) loss, acc = model.evaluate(x_test, y_test) x_predict = x_test y_predict = model.predict(x_predict) print('loss', loss)
plot_model(model, dpi=200) # In[108]: # 定义优化器 # 因为标签没有转独热编码,所以loss用sparse_categorical_crossentropy model.compile(optimizer=Adam(0.01), loss='sparse_categorical_crossentropy', metrics=['accuracy']) # 监控指标统一使用val_accuracy # 可以使用EarlyStopping来让模型停止,连续40个周期val_accuracy没有下降就结束训练 # ModelCheckpoint保存所有训练周期中val_accuracy最高的模型 # ReduceLROnPlateau学习率调整策略,连续20个周期val_accuracy没有提升,当前学习率乘以0.1 callbacks = [ EarlyStopping(monitor='val_accuracy', patience=40, verbose=1), ModelCheckpoint('audio_model/' + 'cnn_{val_accuracy:.4f}.h5', monitor='val_accuracy', save_best_only=True), ReduceLROnPlateau(monitor='val_accuracy', factor=0.1, patience=20, verbose=1) ] # 模型训练 history = model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, y_test),
layer.trainable = True model.summary() # optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, # epsilon=None, decay=1e-6, amsgrad=False) optimizer = SGD(learning_rate=0.001) model.compile(optimizer=optimizer, loss="categorical_crossentropy", metrics=['accuracy', utils.CalculateF1Score]) # Set a learning rate reductor cb_early_stopper = EarlyStopping(monitor='val_loss', patience=4) # Set a learning rate reductor learningRateReduction = ReduceLROnPlateau( monitor='val_accuracy', patience=3, verbose=1, factor=0.5, min_lr=0.00001) # Fit the model epochs = 30 batchSize = 10 history = model.fit(train_datagen.flow(xTrain, yTrain, batch_size=batchSize), epochs=epochs, validation_data=(xValidate, yValidate), verbose=1, steps_per_epoch=xTrain.shape[0] // batchSize, callbacks=[learningRateReduction]) print('Model metrics name: {0}'.format(model.metrics_names))
loss=losses.binary_crossentropy, metrics=['acc']) model.summary() return model # In[19]: model = get_model() file_path = "cnn_res_deep_ptbdb.h5" checkpoint = ModelCheckpoint(file_path, monitor='val_acc', verbose=1, save_best_only=True, mode='max') early = EarlyStopping(monitor="val_acc", mode="max", patience=5, verbose=1) redonplat = ReduceLROnPlateau(monitor="val_acc", mode="max", patience=3, verbose=2) callbacks_list = [checkpoint, early, redonplat] # early model.fit(X, Y, epochs=1000, verbose=2, callbacks=callbacks_list, validation_split=0.1) model.load_weights(file_path) # ### Evaluation
y_in = Input(shape=(256, 1)) y_err = Input(shape=(256, 1)) vae = VariationalAutoEncoder(256, 1024, 16) optimizer = tf.keras.optimizers.Adam(clipvalue=0.5) vae.compile(optimizer, loss=chi2(y_err)) # vae.fit(x_train, x_train, epochs=3, batch_size=64) training_time_stamp = datetime.datetime.now( tz=pytz.timezone('Europe/London')).strftime("%Y-%m-%d_%H-%M-%S") CB = EarlyStopping(monitor='val_loss', min_delta=5e-5, patience=100, verbose=1, mode='auto') MC = ModelCheckpoint( '../../model_weights/model_{}.h5'.format(training_time_stamp), monitor='val_loss', mode="auto", save_best_only=True, verbose=1) history = vae.fit_generator(training_generator, epochs=8000, verbose=2, callbacks=[MC, CB], validation_data=validation_generator) np.savetxt("training_history/loss_history-{}.txt".format(training_time_stamp),
model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.25)) model.add(Conv2D(64, kernel_size=(3,3), padding = 'SAME')) model.add(Dropout(0.2)) model.add(Conv2D(32, kernel_size=(3,3), padding = 'SAME')) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(32, activation= 'relu')) model.add(Dense(32, activation= 'relu')) model.add(Dense(10, activation= 'softmax')) model.summary() model.save('../data/h5/k52_1_model1.h5')#모델저장 #3. 컴파일, 훈련 from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint early_stopping = EarlyStopping(monitor = 'loss', patience = 5, mode = 'auto') modelpath = '../data/modelCheckpoint/k52_1_MCK.h5_{epoch:02d}-{val_loss:.4f}.hdf5' # k45_mnist_37_0100(0.0100).hdf5 cp = ModelCheckpoint(filepath= modelpath , monitor='val_loss', save_best_only=True, mode = 'auto') #filepath='(경로)' : 가중치를 세이브 해주는 루트 model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['acc']) model.fit(x_train, y_train, epochs = 5, batch_size = 64, validation_split=0.2, verbose = 1 ,callbacks = [early_stopping, cp]) model.save('../data/h5/k52_1_model2.h5') model.save_weights('../data/h5/k52_1_weight.h5') #4. 평가, 예측 loss = model.evaluate(x_test, y_test, batch_size=8) print('loss : ', loss) y_pred = model.predict(x_test[:10])
from __future__ import print_function from tensorflow.keras.datasets import cifar10 from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras import utils from tensorflow.keras.callbacks import ReduceLROnPlateau, CSVLogger, EarlyStopping from tensorflow.keras import backend import numpy as np from ML.models import ResNet_SNN from ML.data import cifar lr_reducer = ReduceLROnPlateau(factor=np.sqrt(0.1), cooldown=0, patience=5, min_lr=0.5e-6) early_stopper = EarlyStopping(min_delta=0.001, patience=10) csv_logger = CSVLogger('resnet18SNN_cifar10.csv') batch_size = 32 nb_classes = 10 nb_epoch = 200 data_augmentation = True # input image dimensions img_rows, img_cols = 32, 32 # the cifar10 images are RGB img_channels = 3 # the data, shuffled and split between train and test sets dataloader = cifar.CifarLoader('../../data/cifar-10-batches-py/') X_train, y_train = dataloader.load_train()
metrics=['categorical_accuracy']) # generate callback to save best model w.r.t val_categorical_accuracy if use_vgg: file_name = "vgg" 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:
for fold, (train_index, valid_index) in enumerate(kfold.split(f_train, la_tr)): print("{}train {}th fold{}".format('==' * 20, fold + 1, '==' * 20)) y_ = to_categorical(la_tr, num_classes=19) model = MCNN_model_v2(feat_lens, y_.shape[1]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['acc']) model.summary() plateau = ReduceLROnPlateau(monitor="val_acc", verbose=1, mode='max', factor=0.5, patience=20) early_stopping = EarlyStopping(monitor='val_acc', verbose=1, mode='max', patience=30) checkpoint = ModelCheckpoint(f'models/fold{fold}_mlp.h5', monitor='val_acc', verbose=0, mode='max', save_best_only=True) csv_logger = CSVLogger('../logs/log.csv', separator=',', append=True) history = model.fit( [f_train[train_index] for f_train in f_trains], y_[train_index], epochs=500, batch_size=128, verbose=1, shuffle=True,
def precision_m(y_true, y_pred): true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1))) precision = true_positives / (predicted_positives + K.epsilon()) return precision def f1_m(y_true, y_pred): precision = precision_m(y_true, y_pred) recall = recall_m(y_true, y_pred) return 2 * ((precision * recall) / (precision + recall + K.epsilon())) #3 Compile, train es = EarlyStopping(monitor='val_loss', patience=20, mode='min') lr = ReduceLROnPlateau(monitor='val_loss', factor=0.3, patience=10, mode='min') path = '../Project01_data/9.cp/find_cocacola_{val_loss:.4f}.hdf5' cp = ModelCheckpoint(path, monitor='val_loss', mode='min', save_best_only=True) model.compile(optimizer='adam', metrics=['acc', f1_m], loss='binary_crossentropy') hist = model.fit_generator( train_generator, steps_per_epoch=len(x_train) // batch, epochs=100, \ validation_data=valid_generator, callbacks=[es, lr, cp]) #4 Evaluate, Predict loss, acc, f1_score = model.evaluate(test_generator) print("loss : ", loss)
output_folder = 'models' if not os.path.exists(output_folder): os.makedirs(output_folder) model.load_weights(os.path.join(output_folder, model_name + '.hdf5')) # training parameters batch_size = 128 nb_epoch = 400 # callbacks checkpointer = ModelCheckpoint(filepath=os.path.join(output_folder, model_name + '.hdf5'), save_best_only=True) early_stopping = EarlyStopping(patience=10) tensorboard = TensorBoard() # training loop model.fit( RotNetDataGenerator(train_filenames, input_shape=input_shape, batch_size=batch_size, one_hot=False, preprocess_func=preprocess_input, crop_center=True, crop_largest_rect=True, shuffle=True), steps_per_epoch=len(train_filenames) / batch_size, epochs=nb_epoch, validation_data=RotNetDataGenerator(test_filenames,
metric_list = [SparseCategoricalAccuracy()] output_shape = 2 train_labels = np.reshape(train_labels, (-1)) val_labels = np.reshape(val_labels, (-1)) # Load model model = mb.model_selector(model_name, input_shape, output_shape, model_arguments) callbacks = None if stpc_type.lower() == 'epoch' or stpc_type.lower() == 'epochs': callbacks = None elif stpc_type.lower() == "earlystopping" or stpc_type.lower( ) == "early_stopping": arguments = cgf['TRAIN']['stopping_criteria']['arguments'] es = EarlyStopping(**arguments) callbacks = [es] for key, value in arguments.items(): print('\t{}: {}'.format(key, value)) else: print('Unknown stopping criteria') callbacks = None print('') #model = tf.keras.models.load_model('model/300/best_model_resnet.h5') model.load_weights('model/302/best_model_resnet.h5', by_name=True, skip_mismatch=True) opt = tf.keras.optimizers.Adam() # Compile model
X_train_cont, X_cal_cont, X_test_cont = get_continuous_arrays( list_df=[train, cal, test], config=config) Y_train, Y_cal, Y_test = get_targets_arrays(list_df=[train, cal, test], config=config) X_train_cont, X_val_cont, Y_train, Y_val = train_test_split( X_train_cont, Y_train, test_size=0.1, random_state=1337) checkpoint = ModelCheckpoint("mlp.h5", monitor="val_loss", verbose=1, save_best_only=True, mode="min") early = EarlyStopping(monitor="val_loss", mode="min", patience=20, verbose=1) redonplat = ReduceLROnPlateau(monitor="val_loss", mode="min", patience=10, verbose=2) callbacks_list = [checkpoint, early, redonplat] # normalized conformal prediction for multi print("Normalized conformal prediction for MULTI NN %s" % i) start_multi = time.time() model, model_repr = two_model_mlp( n_continuous=n_cont, n_outputs=n_out,
def main(): my_ds = xr.open_mfdataset('/lambda_stor/data/rjackson/coverage_product/*.nc') labels = my_ds['time'].values labels = np.array([get_label(dt64_to_dt(x)) for x in labels]) print(my_ds.variables.keys()) time = my_ds['time'].values range_bins = my_ds['range_bins'].values feature_list = ['snrgt3.000000', 'snrgt5.000000', 'snrgt10.000000'] x = np.concatenate([my_ds[x].values for x in feature_list], axis=1) feature_labels = [] for feat in feature_list: for i in range(len(my_ds.range_bins.values)): feature_labels.append('%s%d' % (feat, my_ds.range_bins[i])) valid = np.where(labels > -1)[0] x = x[valid, :] labels = labels[valid] time = time[valid] pct_clear = len(np.argwhere(labels == 0))/len(labels) # Since dataset is biased to clear values, remove half of clear values where_clear = np.argwhere(labels == 0) for inds in where_clear: if np.random.random(1) > pct_clear: labels[inds] = -1 valid = np.where(labels > -1)[0] x = x[valid, :] labels = labels[valid] time = time[valid] x = np.where(np.isfinite(x), x, 0) x = scale(x) np.savez('snrscp.npz', x=x, labels=labels, time=time, range_bins=range_bins) x_train, x_test, y_train, y_test = train_test_split(x, labels, test_size=0.20) epoch_no = 1 #y_train = tf.one_hot(y_train, depth=4).numpy() #y_test = tf.one_hot(y_test, depth=4).numpy() y = labels #train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) #test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)) model = nn_classifier(x_train, num_layers=12, num_channel_start=64) model.summary() model.compile(optimizer=Adam(lr=0.0001), loss='sparse_categorical_crossentropy', metrics=['accuracy']) checkpointer = ModelCheckpoint( filepath=('/homes/rjackson/arming_the_edge/models/nnclassifier-{epoch:03d}.hdf5'), verbose=1) early_stop = EarlyStopping(patience=200) model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=3000, callbacks=[checkpointer, early_stop], initial_epoch=epoch_no) #history = pd.DataFrame(dicts['history']) #fname = 'train' #model = 'model_nonrf' #for feat in feature_list: # fname += feat # model += feat #fname += 'optimized_nonrf.csv' #model += '.json' #with open(fname, 'w') as f: # f.write('Features used: ') # for feat in feature_list: # f.write('%s ' % feat) # f.write('\n') # res.to_csv(f) #num_rounds = len(res['test-merror-mean'].values) #bst = xgb.train(params, dtrain, num_boost_round=num_rounds, # callbacks=[xgb.callback.reset_learning_rate(lr)], # evals=[(dtest, 'test')]) #bst.save_model(model) #y_predict = bst.predict(dtest) #y_all_predict = bst.predict(dall) #y_train_predict = bst.predict(dtrain) y_all_predict = model.predict(x) y_predict = model.predict(x_test) y_train_predict = model.predict(x_train) predicted_labels_df = xr.Dataset({'label_true': labels, 'label_pred': y_all_predict, 'label_train_pred': y_train_predict, 'label_test_pred': y_predict, 'label_train': y_train, 'label_test': y_test}) predicted_labels_df.to_netcdf('classification_nnn.nc') print("Accuracy score for test set: %f" % accuracy_score(y_test, y_predict)) my_ds.close()
train_datagen = DataGen_curt(params, train_data, nsteps, nclone_factor, npartial_mult) val_datagen = CloneGen_curt(params, val_data, fufis=True) model, just_trnsf, just_unet = unet_sep(params, weight_ccpf=weight_ccpf, lr=params['lr']) print('Loading weights!!') #weights_name = dnnfolder + '/weights/decrypt_weights.hdf5' weights_name = dnnfolder + '/weights/changes_adam_rotatingclonegen.hdf5' model.load_weights(weights_name) weights_name_next = dnnfolder + '/weights/changes_adam_rotatingclonegen2.hdf5' callbacks = [ EarlyStopping(monitor='loss', patience=25, verbose=1, min_delta=1e-9), ReduceLROnPlateau(monitor='loss', factor=0.1, patience=10, verbose=1, min_delta=1e-9), ModelCheckpoint(monitor='val_loss', mode='min', filepath=weights_name_next, save_best_only=True, save_weights_only=True, verbose=1), CSVLogger(logs_folder + '/hist_' + weights_name_next.split('/')[-1].split('.')[0] + '.csv') ]
# %%time # module_url = "https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/1" # bert_layer = hub.KerasLayer(module_url, trainable=True) vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy() do_lower_case = bert_layer.resolved_object.do_lower_case.numpy() tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case) train_input = bert_encode(data.text.values, tokenizer, max_len=160) test_input = bert_encode(data1.text.values, tokenizer, max_len=160) train_labels = data.user_suggestion.values model = build_model(bert_layer, max_len=160) model.summary() es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=100) train_history = model.fit( train_input, train_labels, validation_split=0.2, callbacks=[es], # Early stopping epochs=3, batch_size=16 ) model.save('model.h5') test_pred = model.predict(test_input) test_pred
#2. 모델링 model = Sequential() model.add(Conv1D(filters=10, kernel_size=(5), input_shape=(32 * 32, 3))) model.add(MaxPool1D(pool_size=(3))) model.add(Flatten()) model.add(Dense(1)) #3. 컴파일, 훈련 model.compile(loss='mse', optimizer='adam', metrics=['mae']) ''' EarlyStopping ''' from tensorflow.keras.callbacks import EarlyStopping early_stopping = EarlyStopping( monitor='loss', patience=20, mode='auto' ) #loss값이 가장낮을 때를 10번 지나갈 때 까지 기다렸다가 stop. mode는 min, max, auto조정가능 model.fit(x_test, y_test, epochs=10, batch_size=1, validation_data=(x_val, y_val), callbacks=[early_stopping]) #4. 평가, 예측 loss, mae = model.evaluate(x_test, y_test) print("loss : ", loss) print("mae : ", mae) y_predict = model.predict(x_test) #print(y_predict)
input_shape=(30, 1, 1))) model.add(MaxPooling2D(pool_size=1)) model.add(Dense(4, activation='relu')) model.add(Flatten()) model.add(Dense(11)) model.add(Dense(11)) model.add(Dense(3)) model.add(Dense(1, activation='sigmoid')) #마지막에만 sigmoid를 준다 #3. 컴파일, 훈련 from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint modelpath6 = '../data/modelCheckpoint/k46_6_mnist_{epoch:02d}-{val_loss:.4f}.hdf5' #02d 정수로 두번째 자리 까지, 4f 실수로 4번째 자리까지 #따라서 0.01이면 02d: 01, 4f : 0100이된다. k45_mnist_0100.hdf5 es = EarlyStopping(monitor='val_loss', patience=10) cp = ModelCheckpoint(filepath=modelpath6, monitor='val_loss', save_best_only=True, mode='auto') #ModelCheckpoint는 최저점이 생길 때마다 filepath(파일형태)로 기록한다. #파일형태에 weight 값을 기록하기 위해 사용한다. 최적의 weight(val_loss가장낮음) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc']) ####loss가 이진 분류일 때는binary_crossentropy(0,1만 추출) hist = model.fit(x_train, y_train, epochs=20, batch_size=16, verbose=1, validation_split=0.2,
def lstm_prediction(): """ start the burn in with a year's data - 9 month and 3 month split retrain model every 10 days """ # df_ftr = pd.read_csv(r'../data/ftr_tgt.csv') df_ftr = read_cleaned_data() lookback = 60 target = 'target' df_ftr = df_ftr.dropna() # df_ftr['date'] = pd.to_datetime(df_ftr['date']) # df_ftr = df_ftr.set_index('date') # df_ftr = df_ftr.resample('3Min').last() # df_ftr[target] = df_ftr[target]+1 df_burn = df_ftr.loc[df_ftr.index.year == 2018] train_period = 9 test_period = 11 n_period = 12 df_train = df_burn.loc[df_burn.index.month <= train_period] df_val = df_burn.loc[((df_burn.index.month > train_period) & (df_burn.index.month <= test_period))] df_test = df_burn.loc[((df_burn.index.month > test_period) & (df_burn.index.month <= n_period))] ftr_cols = [x for x in df_train.columns if x != 'target'] print(f'train data shape is {df_train.shape}') print(f'validation data shape is {df_val.shape}') mm_scaler = preprocessing.MinMaxScaler() X_train = mm_scaler.fit_transform(df_train[ftr_cols]) df_check = pd.DataFrame(X_train) X_val = mm_scaler.transform(df_val[ftr_cols]) X_test = mm_scaler.transform(df_test[ftr_cols]) df_check = pd.DataFrame(X_val) X_train_lstm = [] y_train_lstm = [] for i in range(lookback, len(X_train), 3): X_train_lstm.append(X_train[i - lookback:i, :]) y_train_lstm.append(df_train[target].iloc[i]) X_train_lstm, y_train_lstm = np.array(X_train_lstm), np.array(y_train_lstm) X_val = np.concatenate((X_train, X_val), axis=0) X_test = np.concatenate((X_val, X_test), axis=0) X_val_lstm = [] y_val_lstm = [] X_test_lstm = [] y_test_lstm = [] for i in range(len(X_train), len(X_val), 3): X_val_lstm.append(X_val[i - lookback:i, :]) y_val_lstm.append(df_val[target].iloc[i - len(X_train)]) for i in range(len(X_val), len(X_test), 3): X_test_lstm.append(X_test[i - lookback:i, :]) y_test_lstm.append(df_test[target].iloc[i - len(X_test)]) X_val_lstm, y_val_lstm = np.array(X_val_lstm), np.array(y_val_lstm) X_test_lstm, y_test_lstm = np.array(X_test_lstm), np.array(y_test_lstm) mdl_nm = 'LSTM' model = create_lstm_model(n_lookback=X_train_lstm.shape[1], n_features=X_train_lstm.shape[2], lr=0.001) earlyStopping = EarlyStopping(monitor='val_accuracy', patience=300, verbose=0, mode='max', min_delta=0.001) mcp_save = ModelCheckpoint( f'../models/{mdl_nm}_train_split{train_period}vs{n_period - train_period}.h5', save_best_only=True, monitor='val_accuracy', mode='max') # reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, epsilon=1e-4, mode='min') csv_logger = CSVLogger( f'../models/{mdl_nm}_train_split{train_period}vs{n_period - train_period}.log' ) callback_ls = [mcp_save, csv_logger, mcp_save] class_weight = {0: 20, 1: 80} print('start run model') history = model.fit( X_train_lstm, # Features y_train_lstm, # Target epochs=2000, # Number of epochs verbose=1, # No output batch_size=2**10, # Number of observations per batch validation_data=(X_val_lstm, y_val_lstm), callbacks=callback_ls, class_weight=class_weight) # Data for evaluation plot_model_loss( history, outfile= f'../models/{mdl_nm}_split{train_period}vs{n_period - train_period}') model = load_model( f'../models/{mdl_nm}_train_split{train_period}vs{n_period - train_period}.h5' ) train_pred_y = model.predict(X_train_lstm) # test_pred_y = model.predict(X_test_lstm) val_pred_y = model.predict(X_val_lstm) test_pred_y = model.predict(X_test_lstm) # # df_train_pred = pd.DataFrame(y_train_lstm) df_train_pred.columns = ['target'] df_train_pred['pred_prob'] = train_pred_y plot_roc_curve(df_train_pred, target, 'train') prob_cut = Find_Optimal_Cutoff(df_train_pred[target], df_train_pred['pred_prob']) df_train_pred['pred_bi'] = (df_train_pred['pred_prob'] > prob_cut[0]) confusion_matrix(df_train_pred[target], df_train_pred['pred_bi']) print( classification_report(df_train_pred[target], df_train_pred['pred_bi'])) df_val_pred = pd.DataFrame(y_val_lstm) df_val_pred.columns = ['target'] df_val_pred['pred_prob'] = val_pred_y plot_roc_curve(df_val_pred, target, 'val') prob_cut = Find_Optimal_Cutoff(df_val_pred[target], df_val_pred['pred_prob']) df_val_pred['pred_bi'] = (df_val_pred['pred_prob'] > prob_cut[0]) confusion_matrix(df_val_pred[target], df_val_pred['pred_bi']) print(classification_report(df_val_pred[target], df_val_pred['pred_bi'])) df_test_pred = pd.DataFrame(y_test_lstm) df_test_pred.columns = ['target'] df_test_pred['pred_prob'] = test_pred_y plot_roc_curve(df_test_pred, target, 'test') prob_cut = Find_Optimal_Cutoff(df_test_pred[target], df_test_pred['pred_prob']) df_test_pred['pred_bi'] = (df_test_pred['pred_prob'] > prob_cut[0]) confusion_matrix(df_test_pred[target], df_test_pred['pred_bi']) print(classification_report(df_test_pred[target], df_test_pred['pred_bi'])) # df_val_pred = df_val_pred.reset_index(drop=True) # plt.figure() # plt.scatter(df_val_pred.index, df_val_pred[target], s=5, marker='.') # plt.savefig(cfg.local_projfolder + 'temp/visualization/plot.png') clear_session() del model gc.collect()
x_train = sequence.pad_sequences(x_train, maxlen=max_length) x_test = sequence.pad_sequences(x_test, maxlen=max_length) # skip-gram with negative sampling data preprocessing # skip-gram with negative sampling model input_x = Input(batch_shape=(None, max_length)) target_x = Input(batch_shape=(None, max_length)) Embed_input = Embedding(max_features, embedding_dim)(input_x) Embed_target = Embedding(max_features, embedding_dim)(target_x) Concat = Concatenate(axis=1)([Embed_input, Embed_target]) Output_x = Dense(1, activation='sigmoid')(Concat) Output_x_reshaped = Reshape((-1, 1))(Output_x) model_skipgram = Model([input_x, target_x], Output_x_reshaped) model_skipgram.compile(loss='binary_crossentropy', optimizer='adam') earlystopping = EarlyStopping(patience=5) model_skipgram.fit([x_train, x_train], y_train, validation_data=([x_test, x_test], y_test), callbacks=[earlystopping], epochs=100, batch_size=100) # save parameters model_skipgram.save( 'c:/Users/soohan/MC_python_study/python_nlp/skipgram_model.h5')
model6.add(Conv1D(32, 5, activation='relu')) model6.add(MaxPooling1D(3)) model6.add(Conv1D(32, 5, activation='relu')) model6.add(GlobalMaxPooling1D()) model6.add(Dense(1)) model6.compile(optimizer=RMSprop(), loss='mae', metrics=['mae']) print(model6.summary()) # Train ####### m2_callbacks = [ # interrupt training when there is no more improvement. # patience=2 means interrupt training when accuracy has stopped improving # for more than 2 epochs. mae MUST be in the compile step in the metrics EarlyStopping(monitor='mae', patience=2), # saves the current weights after every epoch # only overwrite the model file when val_loss has improved ModelCheckpoint('weather__v6.h5', monitor='val_loss', save_best_only=True) ] history6 = model6.fit(train_gen, steps_per_epoch=500, epochs=20, validation_data=val_gen, callbacks=m2_callbacks, validation_steps=val_steps) metrics_df = pd.DataFrame(history6.history) metrics_df.to_csv('history6.csv', index=False) # Save ######
encode_cate([content[1] for content in train_data], cat_to_id)) data_test = encode_sentences([content[0] for content in test_data], word_to_id) label_test = to_categorical( encode_cate([content[1] for content in test_data], cat_to_id)) data_train = sequence.pad_sequences(data_train, maxlen=args.max_len) data_test = sequence.pad_sequences(data_test, maxlen=args.max_len) model = TextCNNLSTM(args.max_len, args.max_features, args.embedding_size).build_model() model.compile('adam', 'categorical_crossentropy', metrics=['accuracy']) logger.info('开始训练...') callbacks = [ ModelCheckpoint('./model.h5', verbose=1), EarlyStopping(monitor='val_accuracy', patience=2, mode='max') ] history = model.fit(data_train, label_train, batch_size=args.batch_size, epochs=args.epochs, callbacks=callbacks, validation_data=(data_test, label_test)) model.summary() label_pre = model.predict(data_test) pred_argmax = label_pre.argmax(-1) label_test = label_test.argmax(-1) print(evaluate(label_test, pred_argmax, categories))
input_shape=(28, 28, 1))) # 28x28x1 -> 24x24x16 model.add(MaxPooling2D(pool_size=(2, 2))) # 24x24x16 -> 12x12x16 model.add( Conv2D(64, kernel_size=(5, 5), activation='relu', kernel_initializer='he_normal')) # 12x12x16 -> 8x8x64 model.add(MaxPooling2D(pool_size=(2, 2))) # 8x8x64 -> 4x4x64 model.add(Flatten()) # 4x4x64-> 1024 model.add(Dense(10, activation='softmax')) # 1024 -> 10 model.compile(loss=keras.losses.categorical_crossentropy, optimizer='adam', metrics=['accuracy']) # 作成したモデルの確認 # SVG(model_to_dot(model, show_shapes=True).create(prog='dot', format='svg')) early_stopping = EarlyStopping(patience=1, verbose=1) model.fit(x=x_train, y=y_train, batch_size=128, epochs=100, verbose=1, validation_data=(x_test, y_test), callbacks=[early_stopping])
model.add(Dropout(0.2)) model.add(MaxPooling1D(2)) model.add(Conv1D(300, 3)) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(200, activation='sigmoid')) model.add(Dropout(0.2)) model.add(Dense(120, activation='sigmoid')) model.add(Dense(60, activation='sigmoid')) model.add(Dense(30, activation='sigmoid')) model.add(Dense(1, activation='sigmoid')) # 3. 컴파일, 훈련 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc']) from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint early_stopping = EarlyStopping(monitor='val_loss', patience=30, mode='auto') modelpath= '../data/modelcheckpoint/k54_conv1d_cancer_checkpoint.hdf5' cp = ModelCheckpoint(modelpath, monitor='val_loss', save_best_only=True, mode='auto') model.fit(x_train, y_train, epochs=400, validation_split=0.2, callbacks=[early_stopping, cp], batch_size=16) # 4. 평가, 예측 loss, acc = model.evaluate(x_test, y_test, batch_size=16) print("loss : ", loss) print("acc : ", acc) # 결과치 나오게 코딩할것 0또는 1로 # loss= 0.046165917068719864 # acc =0.9912280440330505
print(x_pred) # model structure model = Sequential() model.add(LSTM(150, input_shape=(3,7), activation='relu')) model.add(Dense(100, activation='relu')) model.add(Dense(50, activation='relu')) model.add(Dense(30, activation='relu')) model.add(Dense(15, activation='relu')) model.add(Dense(3)) model.summary() # compile model.compile(loss='mse', optimizer='adam') # EarlyStopping from tensorflow.keras.callbacks import EarlyStopping es = EarlyStopping(monitor = 'loss', patience = 30, mode='min') # fit hist = model.fit(x_train, y_train, epochs= 300, batch_size= 3, verbose = 1, validation_split=0.2, callbacks = [es]) # evaluate evaluate = model.evaluate(x_test, y_test, batch_size=3, verbose=2) print(evaluate) # predict y_pred = model.predict(x_pred) print(y_pred)
sess = tf.compat.v1.Session(config=config) tf.compat.v1.keras.backend.set_session(sess) ##--------------------------- SETTING AREA ------------------------------## loading = instant_data() df, mode = loading.hourly_instant(), 'hour' # df,mode = loading.daily_instant(),'day' if mode == 'hour': n_past, n_future = 24 * 6, 72 elif mode == 'day': n_past, n_future = 60, 30 st = 'CPY012' target, start_p, stop_p, host_path = station_sel(st, mode) DLtype = '06_Lv1wave_cAonly' #------------ DL PARAMETER ---------------------# callback_early_stopping = EarlyStopping(monitor='val_loss', patience=5, verbose=2) reduce_lr = tf.keras.callbacks.LearningRateScheduler(lambda x: 1e-5 * 0.90**x) callbacks = [callback_early_stopping, reduce_lr] #my_optimizer = SGD(lr=0.01, decay=0, momentum=0.9, nesterov=True) #--------------------------- 4 Yr Edit -----------------------------------# # host_path = './CPY012/4Yr_flood/' # start_p='2014-10-01' # stop_p='2017-10-01' split_date = '2016-11-01' #n_pca = 4 syn = '' # Yscale = False # scaler Y before put in model allscale = True # scale X before put in model
def main(_argv): physical_devices = tf.config.experimental.list_physical_devices('GPU') for physical_device in physical_devices: tf.config.experimental.set_memory_growth(physical_device, True) if FLAGS.training_source == 'weight': model = YoloV3Tiny(classes=FLAGS.num_classes, training=True) model_pretrained = YoloV3Tiny(FLAGS.size, training=True, classes=FLAGS.num_classes) model_pretrained.load_weights(weigths_path) model.get_layer("yolo_darknet").set_weigths( model_pretrained.get_layer("yolo_darknet").get_weigths()) elif FLAGS.training_source == 'model': model = tf.keras.models.load_model(FLAGS.source_path, compile=False) anchors = yolo_tiny_anchors anchor_masks = yolo_tiny_anchor_masks #model.load_weights(weights_path).expect_partial() model.summary() train_dataset = dataset.load_fake_dataset() classes_names = [c.strip() for c in open(FLAGS.classes).readlines()] train_dataset = dataset.load_tfrecord_dataset(FLAGS.datasets, FLAGS.classes, FLAGS.size) train_dataset = train_dataset.shuffle(buffer_size=512) train_dataset = train_dataset.batch(FLAGS.batch_size) train_dataset = train_dataset.map(lambda x, y: ( dataset.transform_images(x, FLAGS.size), dataset.transform_targets(y, anchors, anchor_masks, FLAGS.size))) train_dataset = train_dataset.prefetch( buffer_size=tf.data.experimental.AUTOTUNE) val_dataset = dataset.load_fake_dataset() val_dataset = val_dataset.batch(FLAGS.batch_size) val_dataset = val_dataset.map(lambda x, y: ( dataset.transform_images(x, FLAGS.size), dataset.transform_targets(y, anchors, anchor_masks, FLAGS.size))) optimizer = tf.keras.optimizers.Adam(lr=FLAGS.learning_rate) loss = [ YoloLoss(anchors[mask], classes=FLAGS.num_classes) for mask in anchor_masks ] model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy']) callbacks = [ ReduceLROnPlateau(verbose=1), EarlyStopping(patience=5, verbose=1), ModelCheckpoint('./checkpoints/yolov3_train_test_' + FLAGS.method + '.h5', verbose=1, save_best_only=True), TensorBoard(log_dir='logs') ] history = model.fit(train_dataset, epochs=FLAGS.epochs, callbacks=callbacks, validation_data=val_dataset) """