from collections import namedtuple
import numpy as np
import random
import cv2
import matplotlib
import matplotlib.pyplot as plt
import torch
from itertools import count
import time
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
checkpoint = torch.load('policy_net_with_tail.pth')
policy_net = convnet(config.BOARD_SIZE).float().to(device, non_blocking=True)
policy_net.load_state_dict(checkpoint['model_state_dict'])
policy_net.eval()
env = Snake(config.BOARD_SIZE)
while 1:
done = False
obs = env.reset()
cum_reward = 0
render = True
env.render()
for step in count(1):
action = select_action(obs, policy_net, 0, explore=False)
new_obs, reward, done = env.step(action)
cum_reward += reward
torch.manual_seed(7777)
torch.cuda.manual_seed(7777)
train_dir = './npy_train'
val_dir = './npy_val'
train_dataset = FontDataset(train_dir)
val_dataset = FontDataset(val_dir)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=3,
shuffle=True)
val_loader = torch.utils.data.DataLoader(dataset=val_dataset, batch_size=1)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = convnet().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001, weight_decay=1e-5)
num_epochs = 2
losses = []
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
# Assign Tensors to Configured Device
images = images.to(
device) # reshape dimensions of the input images to fit model
labels = labels.to(device)
# Forward Propagation
outputs = model(images)
means.append(np.mean(episode_rewards[-100:]))
plt.plot(means)
# if len(episode_durations) >= 100:
# # means = durations_t.unfold(0, 100, 1).mean(1).view(-1)
# # means = torch.cat((torch.zeros(99), means))
# means.append(np.mean(episode_durations[-100:]))
# plt.plot(means)
plt.pause(0.001) # pause a bit so that plots are updated
if is_ipython:
display.clear_output(wait=True)
display.display(plt.gcf())
policy_net = convnet(config.BOARD_SIZE,
in_channel=5).float().to(device,
non_blocking=True).eval()
target_net = convnet(config.BOARD_SIZE,
in_channel=5).float().to(device,
non_blocking=True).eval()
optimizer = torch.optim.RMSprop(policy_net.parameters(), lr=1e-3, momentum=0.9)
scheduler = torch.optim.lr_scheduler.MultiStepLR(
optimizer, milestones=[25000, 50000, 200000], gamma=0.1)
env = Snake(config.BOARD_SIZE)
replay_memory = ReplayMemory(capacity=100000)
steps_done = 0
ep = 0
episode_rewards = []
train_x, train_y, test_x, test_y, clean_y = get_data(
dataset=config.dataset,
noise_ratio=config.noise_ratio,
noise_type=config.noise_type,
random_shuffle=True,
seed=config.seed)
np.random.seed(config.seed)
n_samples = train_x.shape[0]
x_shape = train_x.shape[1:]
y_shape = train_y.shape[1]
n_batches = n_samples // batch_size + 1
# define model
model = convnet(config, x_shape=x_shape, y_shape=y_shape, mom2=0.1)
forget_rate = config.noise_ratio / 100.
remember_rate = 1. - forget_rate
small_loss_earlier_epochs = []
for epoch in range(config.n_epoch):
small_loss_current_epoch = []
# random permutation
perm = np.random.permutation(n_samples)
# optimizer update
model.adjust_learning_rate(model.f.optimizer, epoch)
def main(args):
data_file = FLAGS.data_file
batch_size = FLAGS.batch_size
image_size = FLAGS.image_size
num_epochs = 10
meta_data = pd.read_csv(data_file, header=0)
filenames = meta_data['image_id'].apply(lambda id: id + '.png').values
labels = meta_data['label'].values
classes = list(set(labels))
# split into test and validation
files_train, files_validate, labels_train, labels_validate = \
train_test_split(filenames, labels, test_size=0.2, random_state=42)
num_train_samples = files_train.shape[0]
num_val_samples = files_validate.shape[0]
num_classes = len(classes)
# this is the augmentation configuration we will use for training
train_gen = ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
# this is a similar generator, for validation data
# only rescaling
test_gen = ImageDataGenerator(rescale=1. / 255)
train_iterator = SingleDirectoryIterator(
directory='../data/train_img/',
filenames=files_train,
labels=labels_train,
classes=classes,
image_data_generator=train_gen,
batch_size=batch_size,
target_size=(image_size, image_size),
seed=1337)
validation_iterator = SingleDirectoryIterator(
directory='../data/train_img/',
filenames=files_validate,
labels=labels_validate,
classes=classes,
image_data_generator=test_gen,
batch_size=batch_size,
target_size=(image_size, image_size),
seed=1337)
# initialize and compile the model
model = convnet(num_classes, image_size)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['categorical_accuracy'])
# Train the model
model.fit_generator(
train_iterator,
steps_per_epoch=num_train_samples // batch_size,
epochs=num_epochs,
validation_data=validation_iterator,
validation_steps=num_val_samples // batch_size)
# test model
test_iterator = SingleDirectoryIterator(
directory='../data/train_img/',
filenames=files_validate,
image_data_generator=test_gen,
batch_size=batch_size,
target_size=(image_size, image_size),
shuffle=False)
test_steps = num_val_samples // batch_size
predictions = model.predict_generator(
generator=test_iterator,
steps=test_steps)
# binarize labels
encoder = LabelBinarizer()
y_true = encoder.fit_transform(labels_validate)
y_true = y_true[:batch_size*test_steps, :] # crop to match iterator
int_labels = np.argmax(predictions, axis=1)
y_predicted = encoder.fit_transform(int_labels)
score = f1_score(y_true, y_predicted, average='weighted')
print("model scored {} on validation set".format(score))
# always save your weights after training or during training
model_id = np.random.randint(1e4)
model_file = 'model_{}_{}.h5'.format(model_id, score)
save_model(model, model_file)
print('Training complete. model was saved as ', model_file)
