def model_train(model_name, train_data, valid_data, trainTemporal, validTemporal, topo_data): # set callbacks csv_logger = CSVLogger(PATH + '/' + MODELNAME + '.log') checkpointer_path = PATH + '/' + MODELNAME + '.h5' checkpointer = ModelCheckpoint(filepath=checkpointer_path, verbose=1, save_best_only=True) early_stopping = EarlyStopping(monitor='val_loss', patience=10, verbose=1, mode='auto') LearnRate = LearningRateScheduler(lambda epoch: LR) # data generator train_generator = data_generator(train_data, trainTemporal, topo_data, BATCHSIZE, TIMESTEP, model_name) val_generator = data_generator(valid_data, validTemporal, topo_data, BATCHSIZE, TIMESTEP, model_name) sep = (train_data.shape[0] - TIMESTEP) * train_data.shape[1] // BATCHSIZE val_sep = (valid_data.shape[0] - TIMESTEP) * valid_data.shape[1] // BATCHSIZE # train model model = get_model_structure(model_name) # model = multi_gpu_model(model, gpus=2) # gpu parallel model.compile(loss=LOSS, optimizer=OPTIMIZER) model.fit_generator( train_generator, steps_per_epoch=sep, epochs=EPOCH, validation_data=val_generator, validation_steps=val_sep, callbacks=[csv_logger, checkpointer, LearnRate, early_stopping]) # compute mse val_nolabel_generator = test_generator(valid_data, validTemporal, topo_data, BATCHSIZE, TIMESTEP) val_predY = model.predict_generator(val_nolabel_generator, steps=val_sep) valY = get_test_true(valid_data, TIMESTEP, model_name) # mse scaled_valY = np.reshape(valY, ((valid_data.shape[0] - TIMESTEP), HEIGHT, WIDTH)) scaled_predValY = np.reshape( val_predY, ((valid_data.shape[0] - TIMESTEP), HEIGHT, WIDTH)) print('val scale shape: ', scaled_predValY.shape) val_scale_MSE = np.mean((scaled_valY - scaled_predValY)**2) print("Model val scaled MSE", val_scale_MSE) # rescale mse val_rescale_MSE = val_scale_MSE * MAX_VALUE**2 print("Model val rescaled MSE", val_rescale_MSE) # write record with open(PATH + '/' + MODELNAME + '_prediction_scores.txt', 'a') as wf: wf.write('train start time: {}\n'.format(StartTime)) wf.write('train end time: {}\n'.format( datetime.datetime.now().strftime('%Y%m%d_%H%M%S'))) wf.write("Keras MSE on trainData, %f\n" % val_scale_MSE) wf.write("Rescaled MSE on trainData, %f\n" % val_rescale_MSE)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=encoder_states) decoder_dense = Dense(num_output_features, activation='linear') decoder_outputs = decoder_dense(decoder_outputs) model = Model([encoder_inputs, decoder_inputs], decoder_outputs) model.compile(optimizer=optimizer, loss=loss) pacing_text = ['LV', 'RV', 'BiV', 'LBBB'] data_dir = '../parse_data' X, y = data_loader(pacing_text, data_dir, normalize=True) X_train = X[[0, 2, 3], :, :] y_train = y[[0, 2, 3], :, :] X_test = np.expand_dims(X[1, :, :], axis=0) y_test = np.expand_dims(y[1, :, :], axis=0) train_data = data_generator(X_train, y_train) val_data = data_generator(X_test, y_test) model.fit_generator(train_data, epochs=50, steps_per_epoch=8, validation_data=val_data, validation_steps=1) encoder_model = Model(encoder_inputs, encoder_states) decoder_state_input_h = Input(shape=(neurons, )) decoder_state_input_c = Input(shape=(neurons, )) decoder_state_inputs = [decoder_state_input_h, decoder_state_input_c] decoder_outputs, state_h, state_c = decoder_lstm( decoder_inputs, initial_state=decoder_state_inputs) decoder_states = [state_h, state_c] decoder_outputs = decoder_dense(decoder_outputs)
from visdom import Visdom viz = Visdom() viz.line([[0.0, 0.0]], [0.], win='loss', opts=dict(title='loss', legend=['D_loss', 'G_loss'])) torch.set_default_tensor_type(torch.cuda.FloatTensor) trX, trY, mean, std = load_wind() D = Discriminator().cuda() G = Generator().cuda() print(D) data_iter = data_generator(trX, trY) optim_G = optim.RMSprop(G.parameters(), lr=1e-4) optim_D = optim.RMSprop(D.parameters(), lr=1e-4) g_loss = [] d_loss = [] ep = [] p_real = [] p_fake = [] for epoch in range(40000): for _ in range(5): xr, yr = next(data_iter) xr = torch.from_numpy(xr).cuda() # (32, 1, 24, 24)
if type == "de": indexes = [SOS_token] + indexes return torch.tensor(indexes, dtype=torch.long, requires_grad=False).unsqueeze(0) def tensors_from_pair(input_lang, output_lang, pair, max_length_en, max_length_de): input_tensor = tensor_from_sentence("en", input_lang, pair[0], max_length_en) target_tensor = tensor_from_sentence("de", output_lang, pair[1], max_length_de) return input_tensor, target_tensor language, total_data = data_generator(batch_size, 20, device) train_data, test_data, y_train, y_test = train_test_split( total_data, np.zeros(len(total_data, )), test_size=0.1, random_state=42) d_model = 128 heads = 8 N = 6 src_vocab = language.n_words trg_vocab = language.n_words en_weight_matrix = Embedder.initial_weights_matrix( "word_vector/glove.6B.300d.txt", language, 300) src_vocab = language.n_words trg_vocab = language.n_words model = Transformer(src_vocab, trg_vocab, d_model, N, heads, device, en_weight_matrix, en_weight_matrix)
from load_data import vocab2idx, label2idx, data_generator device = "cuda" if torch.cuda.is_available() else 'cpu' model = BiLSTM_CRF_PARALLEL(len(vocab2idx), label2idx, EMBEDDING_DIM, HIDDEN_DIM).to(device) model.train() #optimizer = optim.SGD(model.parameters(), lr=0.001, weight_decay=1e-4) optimizer = optim.Adam(model.parameters(), lr=0.001) start = time.time() loss_vals = [] for epoch in range(EPOCHS): epoch_loss = [] for sentence, tags in data_generator(TRAIN_DATA_PATH, vocab2idx, label2idx): sentences_idx_batch, tags_idx_batch = sentence.to(device), tags.to( device) model.zero_grad() loss = model.neg_log_likelihood_parallel(sentences_idx_batch, tags_idx_batch) loss.backward() epoch_loss.append(loss.item()) optimizer.step() loss_vals.append(np.mean(epoch_loss)) print(f'Epoch[{epoch}] - Loss:{np.mean(epoch_loss)}') torch.save(model.state_dict(), "./saved_model/model.pth") plt.plot(np.linspace(1, EPOCHS, EPOCHS).astype(int), loss_vals)
x = norm_data[:, :-1] y = norm_data[:, -1] print("fare amount distribution over first window:") print(data.iloc[:, -1].describe()) regressor = MLPRegressor() # Initial training regressor.fit(x, y) predictions = regressor.predict(x) print(len(predictions)) smallest = [(i, -abs(a[0] - a[1])) for i, a in enumerate(zip(predictions, y))] # Next: use partial_fit in order to iterate over all the data and update the model as we go for index, item in tqdm(enumerate(data_generator(start_from=100, norm=True))): prediction = regressor.predict(item[:, :-1]) regressor.partial_fit(item[:, :-1], item[:, -1]) score = -abs(prediction - item[:, -1]) if score < smallest[-1][1]: smallest.append((index + 1024, score)) smallest = sorted(smallest, key=lambda _: _[1])[:NUMBER_OF_ANOMALIES] if index == 10000: break log_path = Path("run_log") / f"{datetime.now().strftime('%d.%m.%Y_%H:%M:%S')}" print(log_path) with open(log_path, 'w') as f: for item in smallest: f.write(str(item[0])) f.write('\n')
final_model = Model(inputs=[audio_input, text_input], outputs=final_prediction) adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) final_model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy']) final_model.summary() print('Train...') #result = final_model.fit([train_audio_data, train_text_data], train_label, batch_size=batch_size, epochs=15, validation_data=([test_audio_data, test_text_data], test_label), verbose=1) #print(result.history) """ audio_acc = 0 for i in range(50): print('audio branch, epoch: ', str(i)) train_d, train_l = shuffle(train_audio_data, train_label) audio_model.fit_generator(data_generator(audio_path, train_d, train_l, len(train_d)), steps_per_epoch=len(train_d) / 8, epochs=1, verbose=1) loss_a, acc_a = audio_model.evaluate_generator( data_generator(audio_path, test_audio_data, test_label, len(test_audio_data)), steps=len(test_audio_data) / 8) print('epoch: ', str(i)) print('loss_a', loss_a, ' ', 'acc_a', acc_a) if acc_a >= audio_acc: audio_acc = acc_a train_audio_inter = inter_audio_model.predict_generator( data_generator_output(audio_path, train_audio_data, train_label, len(train_audio_data)), steps=len(train_audio_data))
mode='min') callbacks = [checkpoint] print('steps_train: {}, steps_val: {}'.format(steps_train, steps_val)) print('Batch Size: {}'.format(batch_size)) print('Total Number of Epochs = {}'.format(num_of_epochs)) # Shuffle train data ids_train = list(X2train.keys()) random.shuffle(ids_train) X2train_shuffled = {_id: X2train[_id] for _id in ids_train} X2train = X2train_shuffled # Create the train data generator # returns [[img_features, text_features], out_word] generator_train = data_generator(X1train, X2train, tokenizer, max_length, batch_size, config['random_seed']) # Create the validation data generator # returns [[img_features, text_features], out_word] generator_val = data_generator(X1val, X2val, tokenizer, max_length, batch_size, config['random_seed']) # Fit for one epoch model.fit_generator(generator_train, epochs=num_of_epochs, steps_per_epoch=steps_train, validation_data=generator_val, validation_steps=steps_val, callbacks=callbacks, verbose=1) """ *Evaluate the model on validation data and ouput BLEU score
from tqdm import tqdm load_music = load_data.load_data_from_music from keras.models import Model from keras.layers import Conv2D, Flatten, Dense, Input, Dropout, MaxPooling2D from keras.optimizers import SGD #, Momentum from keras.callbacks import ReduceLROnPlateau seq_shape = (256, 300, 1) batch_train = 16 batch_val = 8 batch_iter = 64 batch_iter_val = 64 w_path = 'model.h5' gen_train = load_data.data_generator(batch_train, r=(0, 6500)) gen_val = load_data.data_generator(batch_val, r=(6500, 8000)) def cnn_model(feature=False): im_in = Input(shape=seq_shape) ''' x = Conv2D(4, 8, padding='same', activation='tanh', name='conv_1')(im_in) x = Conv2D(8, 8, padding='same', activation='tanh', strides=(2, 2), name='conv_2')(x) x = Conv2D(16, 4, padding='same', activation='tanh', strides=(2, 2), name='conv_3')(x) x = Conv2D(16, 4, padding='same', activation='tanh', strides=(2, 2), name='conv_4')(x) x = Conv2D(32, 4, padding='same', activation='tanh', strides=(2, 2), name='conv_5')(x) x = Conv2D(32, 4, padding='same', activation='tanh', strides=(2, 2), name='conv_6')(x) ''' x = Conv2D(96, 11,