# logging.info("Epoch %d (%d/%d)" % (i+1, j+1, num_batches))
train_X_mb = train_X_shuffled[j * batch_size:(j + 1) *
batch_size] #mini-batch
train_y_mb = train_y_shuffled[j * batch_size:(j + 1) * batch_size]
for k in range(num_groups): # number_gropu = batch_size
train_X_mg = fixed(
train_X_mb[k * group_size:(k + 1) * group_size], 16,
FL_A_input
) # convert dataset to fixed-point, 16+FL_A_input
train_y_mg = train_y_mb[k * group_size:(k + 1) * group_size]
predictions, loss = cnn.feed_forward(train_X_mg,
train_y_mg,
train_or_test=1)
# logging.info('Epoch {} Batch {} Loss {:.4f}'.format(i, j, loss))
cnn.feed_backward()
cnn.weight_gradient()
# import pdb; pdb.set_trace()
if k == num_groups - 1:
cnn.apply_weight_gradients(Learning_Rate, args.momentum,
batch_size, True)
else:
cnn.apply_weight_gradients(Learning_Rate, args.momentum,
batch_size, False)
#import pdb; pdb.set_trace()
wrong_predictions += torch.sum(
predictions.cpu() != train_y_mg).numpy()
train_loss += loss
# logging.info("Loss: %.4f" % cnn.loss)
torch.cuda.empty_cache()
elapsed_time = time.time() - start_time
if args.data_augmentation:
IX_flipped = np.random.choice(batch_size, int(batch_size/2))
train_X_mb[IX_flipped] = torch.flip(train_X_mb[IX_flipped], [2])
train_X_mb_padded = torch.zeros(batch_size, 3, 40, 40)
train_X_mb_padded[:,:,4:36,4:36] = train_X_mb
off_x = np.random.randint(9, size=batch_size)
off_y = np.random.randint(9, size=batch_size)
for k in range(batch_size):
train_X_mb[k] = train_X_mb_padded[k,:,off_x[k]:off_x[k]+32,
off_y[k]:off_y[k]+32]
train_X_mb = fixed(train_X_mb, 16, FL_A_input)
train_y_mb = train_y_shuffled[j*batch_size:(j+1)*batch_size]
predictions, loss = cnn.feed_forward(train_X_mb, train_y_mb)
cnn.feed_backward()
cnn.weight_gradient(num_groups)
cnn.apply_weight_gradients(Learning_Rate, args.momentum, batch_size, True)
wrong_predictions += torch.sum(predictions.cpu() != train_y_mb).numpy()
train_loss += loss
#print("Loss: %.4f" % cnn.loss)
elapsed_time = time.time() - start_time
print("Epoch %d takes %.2f seconds" % (i, elapsed_time))
train_error = wrong_predictions / 45000.
train_loss /= (num_batches*num_groups)
batch_size_valid = 40
num_batches_valid = int(5000./batch_size_valid)
valid_error = 0.
valid_loss = 0.
for j in range(num_batches_valid):
