def train():
"""
Performs training and evaluation of ConvNet model.
Implement training and evaluation of ConvNet model. Evaluate your model on the whole test set each eval_freq iterations.
"""
### DO NOT CHANGE SEEDS!
# Set the random seeds for reproducibility
np.random.seed(42)
dataset = cifar10_utils.get_cifar10(DATA_DIR_DEFAULT)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
a, b, c = dataset['train'].images.shape[1:]
n_classes = dataset['train'].labels.shape[1]
cnn = ConvNet(3, n_classes).to(device)
optimizer = optim.Adam(cnn.parameters(), lr=FLAGS.learning_rate)
crossentropy = nn.CrossEntropyLoss()
n_test = dataset['test'].images.shape[0]
for step in range(FLAGS.max_steps):
input, labels = dataset['train'].next_batch(FLAGS.batch_size)
labels = np.argmax(labels, axis=1)
input, labels = torch.from_numpy(input).to(device), torch.from_numpy(
labels).long().to(device)
predictions = cnn.forward(input)
loss = crossentropy(predictions, labels)
# clean up old gradients
cnn.zero_grad()
loss.backward()
optimizer.step()
if (step == FLAGS.max_steps - 1 or step % FLAGS.eval_freq == 0):
test_loss = []
test_accuracy = []
for i in range(0, n_test, FLAGS.batch_size):
test_input, test_labels = dataset['test'].next_batch(
FLAGS.batch_size)
test_input = torch.from_numpy(test_input).to(device)
test_labels = torch.from_numpy(np.argmax(
test_labels, axis=1)).long().to(device)
test_prediction = cnn.forward(test_input)
test_loss.append(
crossentropy(test_prediction, test_labels).item())
test_accuracy.append(accuracy(test_prediction, test_labels))
sys.stdout = open(
str(FLAGS.learning_rate) + '_' + str(FLAGS.max_steps) + '_' +
str(FLAGS.batch_size) + '_' + str(FLAGS.batch_size) +
'conv.txt', 'a')
print("{},{:f},{:f}".format(step, np.mean(test_loss),
np.mean(test_accuracy)))
def train():
"""
Performs training and evaluation of ConvNet model.
TODO:
Implement training and evaluation of ConvNet model. Evaluate your model on the whole test set each eval_freq iterations.
"""
### DO NOT CHANGE SEEDS!
# Set the random seeds for reproducibility
np.random.seed(42)
# Load data
cifar10 = cifar10_utils.get_cifar10(data_dir=FLAGS.data_dir,
one_hot=False,
validation_size=5000)
train_set = cifar10['train']
test_set = cifar10['test']
val_set = cifar10['validation']
# Initialize model
n_channels = len(train_set.images[0].shape)
n_classes = train_set.labels.max() + 1
# set device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ConvNet(n_channels, n_classes)
model = model.to(device)
model = nn.DataParallel(model)
cross_entropy = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=FLAGS.learning_rate)
total_loss = 0
losses = []
val_acc = []
train_acc = []
for i in range(FLAGS.max_steps + 1):
# prepare batch
x, y = train_set.next_batch(FLAGS.batch_size)
x, y = torch.tensor(x), torch.tensor(y, dtype=torch.long)
x, y = x.to(device), y.to(device)
# forward pass
out = model(x)
loss = cross_entropy(out, y)
total_loss += loss.item()
# keep track of training accuracy
train_acc.append(accuracy(out, y))
# backward pass
model.zero_grad()
loss.backward()
optimizer.step()
if i % FLAGS.eval_freq == 0 and i != 0:
with torch.no_grad():
val_inputs = test_set.images
val_inputs = torch.tensor(val_inputs)
val_inputs = val_inputs.to(device)
pred = model(val_inputs)
targ = torch.tensor(test_set.labels)
targ = targ.to(device)
acc = accuracy(pred, targ)
losses.append(total_loss)
val_acc.append(acc)
print()
print("- - - - - - - - - -")
print('- STEPS:\t\t\t', i)
print('- TRAIN ACC: \t\t\t', np.array(train_acc).mean())
print('- VALIDATION ACC:\t\t', acc)
print("- - - - - - - - - -")
train_acc = []
total_loss = 0
print("Loss over time: \t", losses)
print("Val acc over time: \t", val_acc)
with open('cnn_data.dill', 'wb') as f:
dill.dump({'train_loss': losses, 'val_acc': val_acc}, f)
def train():
"""
Performs training and evaluation of ConvNet model.
TODO:
Implement training and evaluation of ConvNet model. Evaluate your model on the whole test set each eval_freq iterations.
"""
### DO NOT CHANGE SEEDS!
# Set the random seeds for reproducibility
np.random.seed(42)
epoch_num = 3
########################
# PUT YOUR CODE HERE #
#######################
model = ConvNet(3, 10)
#Obtain Dataset
train_dataset = cifar10_utils.get_cifar10()['train']
val_dataset = cifar10_utils.get_cifar10()['validation']
test_dataset = cifar10_utils.get_cifar10()['test']
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=BATCH_SIZE_DEFAULT,
drop_last=True)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
for epoch in range(epoch_num):
model.train()
losses = []
accs = []
for i_iter in range(
int(train_dataset.num_examples / BATCH_SIZE_DEFAULT)):
images, labels = train_dataset.next_batch(BATCH_SIZE_DEFAULT)
images, labels = torch.tensor(images), torch.tensor(
labels, dtype=torch.long)
pred = model(images)
labels = torch.argmax(labels, dim=1)
loss = criterion(pred, labels)
pred_result = torch.argmax(pred, dim=1)
acc = accuracy(pred_result, labels)
accs.append(acc)
model.zero_grad()
loss.backward()
optimizer.step()
losses.append(loss)
if i_iter % 100 == 0:
msg = 'Epoch:[{}/{}] Iter: [{}/{}], Loss: {: .6f}, ACC:[{: .6f}]'.format(
epoch, epoch_num, i_iter,
int(train_dataset.num_examples / BATCH_SIZE_DEFAULT),
sum(losses) / len(losses),
sum(accs) / len(accs))
print(msg)
with open('./log.txt', 'a') as f:
f.write(msg)
f.write('\n')
msg_epoch = '--------Epoch: [{}/{}], Loss: {: .6f}, ACC:[{: .6f}]-------'.format(
epoch, epoch_num,
sum(losses) / len(losses),
sum(accs) / len(accs))
print(msg_epoch)
with open('./log.txt', 'a') as f:
f.write(msg)
f.write('\n')
