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)
