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,
