def train():
train_data, validation_data = load_pytorch_data(batch_size=32)
model = SimpleCNN(input_size=INPUT_SIZE, D=D, hidden_size=hidden_size)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
loss_weights = torch.tensor([0.1, 0.9])
criterion = torch.nn.CrossEntropyLoss(weight=loss_weights)
print('starting training!')
for epoch in range(20):
print('starting epoch {}...'.format(epoch))
for iter, (X_batch, y_batch) in enumerate(train_data):
X_batch = X_batch.float()
y_batch = y_batch.long()
output = model(X_batch)
output = torch.squeeze(output, 0)
loss = criterion(output, y_batch)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if iter % 40 == 0:
print('Iter {} loss: {}'.format(iter, loss.item()))
check_validation_accuracy(model, validation_data)
losses.append(loss.item())
x = [i for i in range(len(losses))]
plt.plot(x, losses)
plt.show()
print('finished training!')
def main():
w2v_dict = TransVecotr(MODEL_PATH)
dataset, height, width = w2v_dict(WAKATI_PATH)
feat_data = dataset["vec"]
label_data = xp.array([LAB_DIC[i] for i in dataset["lab"]], dtype=xp.int32)
x_train, x_test, y_train, y_test = train_test_split(feat_data, label_data, test_size=0.15)
input_channel = 1
x_train = xp.array(x_train, dtype=xp.float32).reshape(len(x_train), input_channel, height, width)
x_test = xp.array(x_test, dtype=xp.float32).reshape(len(x_test), input_channel, height, width)
train = tuple_dataset.TupleDataset(x_train, y_train)
test = tuple_dataset.TupleDataset(x_test, y_test)
train_iter = iterators.SerialIterator(train, N_BATCH)
test_iter = iterators.SerialIterator(test, N_BATCH, repeat=False, shuffle=False)
model = L.Classifier(SimpleCNN(input_channel, N_OUTPUT, FILTER_H, width, MID_UNITS, N_UNITS, N_LABEL))
if GPU >= 0:
model.to_gpu()
optimizer = optimizers.AdaGrad()
optimizer.setup(model)
updater = training.StandardUpdater(train_iter, optimizer, device=GPU)
trainer = training.Trainer(updater, (N_EPOCH, 'epoch'), out="result")
trainer.extend(extensions.Evaluator(test_iter, model, device=GPU))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot())
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy']))
trainer.extend(extensions.ProgressBar())
trainer.run()
def build_SAN(dataset, args):
# init word embedding module, question embedding module, and Attention network
w_emb = WordEmbedding(dataset.dictionary.ntoken, 300, 0.0, args.op)
q_emb = QuestionEmbedding(300 if 'c' not in args.op else 600, args.num_hid,
1, False, 0.0, args.rnn)
v_att = StackedAttention(args.num_stacks, dataset.v_dim, args.num_hid,
args.num_hid, dataset.num_ans_candidates,
args.dropout)
# build and load pre-trained MAML model
if args.maml:
weight_path = args.RAD_dir + '/' + args.maml_model_path
print('load initial weights MAML from: %s' % (weight_path))
maml_v_emb = SimpleCNN(weight_path, args.eps_cnn, args.momentum_cnn)
# build and load pre-trained Auto-encoder model
if args.autoencoder:
ae_v_emb = Auto_Encoder_Model()
weight_path = args.RAD_dir + '/' + args.ae_model_path
print('load initial weights DAE from: %s' % (weight_path))
ae_v_emb.load_state_dict(torch.load(weight_path))
# Loading tfidf weighted embedding
if hasattr(args, 'tfidf'):
w_emb = tfidf_loading(args.tfidf, w_emb, args)
# init classifier
classifier = SimpleClassifier(args.num_hid, 2 * args.num_hid,
dataset.num_ans_candidates, args)
# contruct VQA model and return
if args.maml and args.autoencoder:
return SAN_Model(w_emb, q_emb, v_att, classifier, args, maml_v_emb,
ae_v_emb)
elif args.maml:
return SAN_Model(w_emb, q_emb, v_att, classifier, args, maml_v_emb,
None)
elif args.autoencoder:
return SAN_Model(w_emb, q_emb, v_att, classifier, args, None, ae_v_emb)
return SAN_Model(w_emb, q_emb, v_att, classifier, args, None, None)
def main():
w2v_dict = TransVecotr(MODEL_PATH)
dataset, height, width = w2v_dict(WAKATI_PATH)
feat_data = dataset["vec"]
label_data = xp.array([LAB_DIC[i] for i in dataset["lab"]], dtype=xp.int32)
input_channel = 1
x_train = xp.array(feat_data, dtype=xp.float32).reshape(len(feat_data), input_channel, height, width)
train = tuple_dataset.TupleDataset(x_train, label_data)
train_iter = iterators.SerialIterator(train, N_BATCH)
model = L.Classifier(SimpleCNN(input_channel, N_OUTPUT, FILTER_H, width, MID_UNITS, N_UNITS, N_LABEL))
if GPU >= 0:
model.to_gpu()
optimizer = optimizers.AdaGrad()
optimizer.setup(model)
updater = training.StandardUpdater(train_iter, optimizer, device=GPU)
trainer = training.Trainer(updater, (1, 'epoch'), out="result")
serializers.load_npz(TRAINER_PATH, trainer)
while True:
input_text = raw_input('input text :')
if input_text == "exit":
break
pred_vec = w2v_dict.gen_pred_vec(input_text, height)
pred_vec = xp.array([pred_vec], dtype=xp.float32)
pred_data = xp.array([pred_vec], dtype=xp.float32)
hyp_data = model.predictor(pred_data)
res_dict = {v:k for k, v in LAB_DIC.items()}
if res_dict[hyp_data.data.argmax()] == "yakiu":
print "彡(ﾟ)(ﾟ) やきう民"
else:
print "(´・ω・`) 原住民"
print
def build_BAN(dataset, args, priotize_using_counter=False):
# init word embedding module, question embedding module, and Attention network
w_emb = WordEmbedding(dataset.dictionary.ntoken, 300, .0, args.op)
q_emb = QuestionEmbedding(300 if 'c' not in args.op else 600, args.num_hid,
1, False, .0, args.rnn)
v_att = BiAttention(dataset.v_dim, args.num_hid, args.num_hid, args.gamma)
# build and load pre-trained MAML model
if args.maml:
weight_path = args.RAD_dir + '/' + args.maml_model_path
print('load initial weights MAML from: %s' % (weight_path))
maml_v_emb = SimpleCNN(weight_path, args.eps_cnn, args.momentum_cnn)
# build and load pre-trained Auto-encoder model
if args.autoencoder:
ae_v_emb = Auto_Encoder_Model()
weight_path = args.RAD_dir + '/' + args.ae_model_path
print('load initial weights DAE from: %s' % (weight_path))
ae_v_emb.load_state_dict(torch.load(weight_path))
# Loading tfidf weighted embedding
if hasattr(args, 'tfidf'):
w_emb = tfidf_loading(args.tfidf, w_emb, args)
# Optional module: counter for BAN
use_counter = args.use_counter if priotize_using_counter is None else priotize_using_counter
if use_counter or priotize_using_counter:
objects = 10 # minimum number of boxes
if use_counter or priotize_using_counter:
counter = Counter(objects)
else:
counter = None
# init BAN residual network
b_net = []
q_prj = []
c_prj = []
for i in range(args.gamma):
b_net.append(
BCNet(dataset.v_dim, args.num_hid, args.num_hid, None, k=1))
q_prj.append(FCNet([args.num_hid, args.num_hid], '', .2))
if use_counter or priotize_using_counter:
c_prj.append(FCNet([objects + 1, args.num_hid], 'ReLU', .0))
# init classifier
classifier = SimpleClassifier(args.num_hid, args.num_hid * 2,
dataset.num_ans_candidates, args)
# contruct VQA model and return
if args.maml and args.autoencoder:
return BAN_Model(dataset, w_emb, q_emb, v_att, b_net, q_prj, c_prj,
classifier, counter, args, maml_v_emb, ae_v_emb)
elif args.maml:
return BAN_Model(dataset, w_emb, q_emb, v_att, b_net, q_prj, c_prj,
classifier, counter, args, maml_v_emb, None)
elif args.autoencoder:
return BAN_Model(dataset, w_emb, q_emb, v_att, b_net, q_prj, c_prj,
classifier, counter, args, None, ae_v_emb)
return BAN_Model(dataset, w_emb, q_emb, v_att, b_net, q_prj, c_prj,
classifier, counter, args, None, None)
def process_img():
simplecnn = SimpleCNN()
img = skimage.data.camera()
img = skimage.color.rgb2gray(img)
l1_filter = numpy.zeros((2, 3, 3))
l1_filter[0, :, :] = numpy.array([[[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]])
l1_filter[1, :, :] = numpy.array([[[1, 1, 1], [0, 0, 0], [-1, -1, -1]]])
print "Conv layer 1..."
l1_feature_map = simplecnn.conv(img, l1_filter)
print "Relu..."
l1_feature_map_relu = simplecnn.relu(l1_feature_map)
print "Max pooling..."
l1_filter_map_relu_pooling = simplecnn.pooling(l1_feature_map_relu,
options=2)
print "End with layer 1..."
print "Conv layer 2..."
l2_filter = numpy.random.rand(3, 5, 5,
l1_filter_map_relu_pooling.shape[-1])
l2_feature_map = simplecnn.conv(l1_filter_map_relu_pooling, l2_filter, 2)
print "Relu..."
l2_feature_map_relu = simplecnn.relu(l2_feature_map)
print "Max pooling..."
l2_feature_map_relu_pooling = simplecnn.pooling(l2_feature_map_relu,
options=2)
print "End wirh layer 2..."
# Reveal the image
show_originale_img(img)
layers_out = [
l1_feature_map, l1_feature_map_relu, l1_filter_map_relu_pooling
]
nrows = 3
ncols = l1_feature_map.shape[-1]
titles = ["L1 map", "L1 map relu", "L1 map relu pool"]
img_name = "L1.png"
show_layeroutput(layers_out, nrows, ncols, titles, img_name)
layers_out = []
layers_out = [
l2_feature_map, l2_feature_map_relu, l2_feature_map_relu_pooling
]
nrows = 3
ncols = l2_feature_map.shape[-1]
titles = ["L2 map", "L2 map relu", "L2 map relu pool"]
img_name = "L2.png"
show_layeroutput(layers_out, nrows, ncols, titles, img_name)
plt.savefig("trainingGraph.png")
plt.show()
# Load and prepare data
DATA_PATH = 'Data'
train_data_path = os.path.join(DATA_PATH, 'train.txt')
images28, labels = js.load(train_data_path)
images28 = images28 / 256
images28 = images28.reshape(len(images28), 28, 28, 1)
images_train, images_val, labels_train, labels_val = train_test_split(
images28, labels, test_size=0.2, random_state=0)
# Prepare the callbacks for the model
MODEL_PATH = 'Model'
checkpoint_path = os.path.join(MODEL_PATH, 'cnn-cp-{epoch:04d}.ckpt')
cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
monitor='val_loss',
save_best_only=True,
save_weights_only=True,
verbose=1)
# Create, train and save the model
model = nn.buildModel()
history = model.fit(images_train,
labels_train,
epochs=20,
validation_data=(images_val, labels_val),
callbacks=[cp_callback])
trainingGraph(history)
n_training_samples = 20000
train_sampler = SubsetRandomSampler(np.arange(n_training_samples, dtype=np.int64))
#Validation
n_val_samples = 5000
val_sampler = SubsetRandomSampler(np.arange(n_training_samples, n_training_samples + n_val_samples, dtype=np.int64))
#Test
n_test_samples = 5000
test_sampler = SubsetRandomSampler(np.arange(n_test_samples, dtype=np.int64))
#Test and validation loaders have constant batch sizes, so we can define them directly
test_loader = torch.utils.data.DataLoader(test_set, batch_size=4, sampler=test_sampler, num_workers=2)
val_loader = torch.utils.data.DataLoader(train_set, batch_size=128, sampler=val_sampler, num_workers=2)
CNN = SimpleCNN()
# CNN.trainNet(CNN, batch_size=32, n_epochs=5, learning_rate=0.001)
input_path = config['path'] + '/test/test_images'
pics = {}
for file in os.listdir(input_path):
filename = os.fsdecode(file)
img = Image.open(os.path.join(input_path, filename))
vec = CNN.forward(V(transform(img).unsqueeze(0)))
vec = vec.detach().numpy()[0, :]
pics[filename] = vec
pic_name = 'cat.jpg'
sims = {}
for key in list(pics.keys()):
download=False,
transform=transform)
testset = torchvision.datasets.CIFAR10(root=ROOT_DIR,
train=False,
download=False,
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=128,
shuffle=True,
num_workers=4)
testloader = torch.utils.data.DataLoader(testset,
batch_size=16,
shuffle=False,
num_workers=4)
net = SimpleCNN()
net.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = Lookahead(optim.Adam(net.parameters(), lr=0.001), k=5, alpha=0.5)
for epoch in range(EPOCHS):
bar = tqdm(trainloader)
for data in bar:
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
bar.set_description('Epoch %d: loss %.4f' % (epoch + 1, loss.item()))