def evaluate(model, val_data, batch_size, seq_len): model.eval() loss_all = [] for i, xs_seq in enumerate(yield_data_time(val_data, batch_size, seq_len)): xs_seq = torch.FloatTensor(xs_seq).to(device) out, mu, logvar = model(xs_seq, adj) loss = loss_fn(xs_seq, out, mu, logvar, [0, 1]) loss_all.append(loss.cpu().data.numpy()) return np.mean(loss_all)
def train_epoch(data, batch_size, seq_len, val_data=None, show_iter=None, show_forward_info='', device=device): loss_data = [] max_i = (len(data) - 1) // batch_size for i, xs_seq in enumerate(yield_data_time(data, batch_size, seq_len)): trainer.train(True) xs_seq = torch.FloatTensor(xs_seq).to(device) out, mu, std = trainer(xs_seq, adj) loss = loss_fn(xs_seq, out, mu, std, [0, 1]) optimizer.zero_grad() loss.backward() optimizer.step() loss_data.append(loss.cpu().data.numpy()) if show_iter is not None and i % show_iter == 0: print('{} b:{}/{} loss:{}'.format(show_forward_info, i, max_i, loss_data[-1])) if val_data is not None: del xs_seq, out, loss torch.cuda.empty_cache() trainer.eval() eval_loss_all = [] for i, xs_seq in enumerate( yield_data_time(val_data, batch_size, seq_len)): xs_seq = torch.FloatTensor(xs_seq).to(device) out, mu, logvar = trainer(xs_seq, adj) loss = loss_fn(xs_seq, out, mu, logvar, [0, 1]) eval_loss_all.append(loss.cpu().data.numpy()) val_loss = np.mean(eval_loss_all) print('{} val_loss:{}'.format(show_forward_info, val_loss)) return np.array(loss_data), val_loss
import numpy as np import matplotlib.pyplot as plt from data_process import yield_data_time from mpl_toolkits.mplot3d import Axes3D from sklearn.manifold import TSNE #encode10dim = np.load('result/rnn_new/encode10_seqlen/fin_delnegative/fin_delnegative_e77_encode.npy') origin_data = np.load('data/new/data2.npy') label = np.load('data/new/label2.npy') label = label.T seq_label = [] for seq in yield_data_time(label, 1, 10, False): seq_label.append(np.sum(seq)) seq_label = np.array(seq_label) seq_label = (seq_label>50).astype('int') #%% tsne = TSNE(n_components=2) fit2dim = tsne.fit_transform(encode10dim) np.save('result/rnn_new/encode10_seqlen/fin_delnegative/tsne_fit2dim.npy', fit2dim) tsne = TSNE(n_components=3) fit3dim = tsne.fit_transform(encode10dim) np.save('result/rnn_new/encode10_seqlen/fin_delnegative/tsne_fit3dim.npy', fit3dim) #%%
with open(load_name+'.model', 'rb') as f: trainer = torch.load(f).to(device) encoder = trainer.encoder decoder = trainer.decoder adj = torch.FloatTensor(adj).to(device) adj.requires_grad = False result = [] mu_result = [] std_result = [] start = time.time() max_i = (len(data)-seq_len) // batch_size for i, x in enumerate(yield_data_time(data, batch_size, seq_len, False)): x = torch.FloatTensor(x).to(device) encode, mu, std = encoder(x, adj) result.append(encode.cpu().data.numpy()) mu_result.append(mu.cpu().data.numpy()) std_result.append(std.cpu().data.numpy()) print("{}/{}".format(i, max_i)) end = time.time() print('time:{}'.format(end - start)) #result = np.array(result) #result = np.concatenate(result) #np.save(load_name+'_encode.npy', result) #%%
encoder = Denses(encoder_list) encoder_list.reverse() decoder = Denses(encoder_list) encoder_list.reverse() trainer = Trainer(encoder, decoder).to(device) optimizer = optim.Adam(trainer.parameters()) loss_fn = MSE() loss_log = [] all_len = len(train_data) // batch_size + 1 for e in range(epochs): loss_ = [] trainer.train() for i, x in enumerate(yield_data_time(train_data, batch_size, 1, True)): x = x.reshape(x.shape[1], -1) x = torch.FloatTensor(x).to(device) out = trainer(x, None) loss = loss_fn(x, out) optimizer.zero_grad() loss.backward() optimizer.step() loss_.append(loss.cpu().data.numpy()) if i % 10 == 0: print('e:{}/{} {}/{} loss{}'.format(e, epochs, i, all_len, loss_[-1])) trainer.eval() loss_eval_ = [] for i, x in enumerate(yield_data_time(val_data, batch_size, 1, True)):
encoder = trainer.encoder decoder = trainer.decoder adj = torch.FloatTensor(adj).to(device) adj.requires_grad = False result = [] mu_result = [] std_result = [] decoder_mu = [] decoder_std = [] start = time.time() max_i = (len(data)-seq_len) // batch_size for i, x in enumerate(yield_data_time(data, batch_size, seq_len, False)): x = torch.FloatTensor(x).to(device) encode, mu, std = encoder(x, adj) mu_output = decoder(mu, adj.transpose(1, 0)) std_output = decoder(std, adj.transpose(1, 0)) decoder_mu.append(mu_output.cpu().data.numpy()) decoder_std.append(std_output.cpu().data.numpy()) result.append(encode.cpu().data.numpy()) mu_result.append(mu.cpu().data.numpy()) std_result.append(std.cpu().data.numpy()) print("{}/{}".format(i, max_i)) end = time.time()