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)