def main(): np.random.seed(42) if DATA == 'linear': X_train, y_train, X_val, y_val = make_linear(x_min=-5, x_max=5, n_samples=10000, n_features=11, n_labels=N_LABELS, a=3, b=4, sigma=0.5, test_size=0.2) else: X_train, y_train, X_val, y_val = make_sinus(x_min=-5, x_max=5, n_samples=10000, n_features=11, n_labels=N_LABELS, a=3, b=4, amplitude=10, phase=1, sigma=0.5, test_size=0.2) model = Sequential([ Dense(X_train.shape[1], 100), ReLU(), Dense(100, 200), Sigmoid(), Dense(200, N_LABELS) ]) loss = MSE() for epoch in range(N_EPOCHS): if BATCH_SIZE: for x_batch, y_batch in minibatch_iterator(X_train, y_train, batch_size=BATCH_SIZE, shuffle=True): train(model, x_batch, y_batch, learning_rate=LEARNING_RATE) else: train(model, X_train, y_train, learning_rate=LEARNING_RATE) train_loss = np.mean(loss(model(X_train), y_train)) val_loss = np.mean(loss(model(X_val), y_val)) print("Epoch", epoch) print("Train MSE:", train_loss) print("Val MSE:", val_loss)
def optimaze_lstm(trial): model = Model( s_stage='ResNet', res_block_num=4, t_hidden_dim=trial.suggest_int('t_hidden_dim', 50, 500, 50), t_output_dim=trial.suggest_int('t_output_dim', 50, 500, 50), ) score = train(model, train_loader, test_loader, DEVICE) return score
def search_res_block_num(train_loader, test_loader): print('\n=== ResNet ===') scores = [] for i in range(1, 6): model = Model( s_stage='ResNet', res_block_num=i, ) best_auc = train(model, train_loader, test_loader, DEVICE) scores.append(best_auc) for i in range(5): print(i + 1, scores[i])
def optimaze_san(trial): block_num = trial.suggest_int('block_num', 1, 5) layer_size_hop = trial.suggest_int('layer_size_hop', 2, 5) kernel_size = trial.suggest_int('kernel_size', 3, 7, 2) layers = [3] kernels = [3] for i in range(1, block_num): layers.append(2 + i * layer_size_hop) kernels.append(kernel_size) model = Model( s_stage='SAN', san_layers=layers, san_kernels=kernels, ) score = train(model, train_loader, test_loader, DEVICE) return score
def test_smoke(self): train(self.model, self.X_train, self.y_train, learning_rate=0.01)
from nn.train import train from nn.constants import * from nn.models import CycleGAN from vids2data import vid_io model = CycleGAN() if USE_CUDA: model.cuda() A = vid_io.load("A.npy.gz") B = vid_io.load("B.npy.gz") # Train model on A and B for 15000 iterations train(model, A, B, 15000)
def main(): seed = 0 fix_seed(seed) data = cr.Dataset( data_paths=cfg.data_paths, exp_id=cfg.exp_id, img_shape=cfg.img_shape, img_crop_size=cfg.img_crop_size, max_trace=cfg.max_trace_len, ) x_train, x_test, y_train, y_test = data.split_training_test_data( test_split=.20, seed=10, for_deep=True) trainsets = NNDataset(x_train, y_train, DEVICE) testsets = NNDataset(x_test, y_test, DEVICE) train_loader = torch.utils.data.DataLoader(trainsets, batch_size=32) test_loader = torch.utils.data.DataLoader(testsets, batch_size=32) for model_name in MODEL_LIST: print(f'\n======== {model_name} ========\n') if model_name == 'LSTM': model = Model(t_stage='LSTM', device=DEVICE, t_hidden_dim=500, t_output_dim=500, use_cnn_for_trace=False) elif model_name == 'CNN_LSTM': model = Model(t_stage='LSTM', device=DEVICE, t_hidden_dim=500, t_output_dim=500) elif model_name == 'OnlyCNN': model = Model(s_stage='CNN', device=DEVICE, block_num=3) else: model = Model(s_stage=model_name, t_stage='LSTM', device=DEVICE, pretrained=PRETRAINED, block_num=3, t_hidden_dim=500, t_output_dim=500) if MODE == 'train': score, model = train(model, model_name, train_loader, test_loader, DEVICE, log_path=f'{ROOT}/out/{model_name}.txt') model = model.to('cpu') torch.save(model.state_dict(), f'{ROOT}/best_models/{model_name}.pth') elif MODE == 'fps': model.eval() inputs = (torch.rand(1, 1, 500).to(DEVICE), torch.rand(1, 1, 80, 80).to(DEVICE)) t0 = time.time() for i in range(100): model(inputs) with open(f'{ROOT}/out/speed.txt', 'a') as f: f.write(f'{model_name}: {100 / (time.time() - t0):.04f} fps\n') else: raise ValueError
""" The example of xor which cannot be learned by a linear model """ from nn.model import Sequential from nn.layers import Dense, Tanh, Sigmoid, Relu from nn.train import train import numpy as np inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) targets = np.array([[0.0], [1.0], [1.0], [0.0]]) net = Sequential() net.add(Dense(2, 2)) net.add(Tanh()) net.add(Dense(2, 1)) net.add(Sigmoid()) train(net, inputs, targets) print(net(np.expand_dims(inputs[0], 0))) print(inputs[0].shape) for X, y in zip(inputs, targets): predicted = net(np.expand_dims(X, 0)) print(X, predicted, y)