def run_epoch(model, train_iterator, val_iterator, epoch): train_losses = [] val_accuracies = [] losses = [] # Reduce learning rate as number of epochs increase if (epoch == int(model.config.max_epochs / 3)) or (epoch == int(2 * model.config.max_epochs / 3)): model.reduce_lr() for i, batch in enumerate(train_iterator): model.optimizer.zero_grad() x_times, x_features, x_labels = batch if torch.cuda.is_available(): x_times, x_features, x_labels = x_times.cuda(), x_features.cuda(), x_labels.cuda() y = (x_labels[:, -1]).type(torch.cuda.LongTensor) else: y = (x_labels[:, -1]).type(torch.LongTensor) y_pred = model(x_times, x_features) loss = model.loss_op(y_pred, y) loss.backward() losses.append(loss.data.cpu().numpy()) model.optimizer.step() if i % 100 == 0: print("Iter: {}".format(i + 1)) avg_train_loss = np.mean(losses) train_losses.append(avg_train_loss) print("\tAverage training loss: {:.5f}".format(avg_train_loss)) losses = [] # Evalute Accuracy on validation set evaluate(model, val_iterator) model.train() return train_losses, val_accuracies
def __init__(self, image): super(Final, self).__init__() root = Tk() root.title("Final") root.geometry("600x600") root.resizable(0, 0) load_model = model() load_model.load_model("cnn1.h5") images = load_model.predict(image) height, width, no_channels = images["orignal_image"].shape frame = Frame(root, width=width, height=height, highlightthickness=1, highlightbackground="black") canvas = Canvas(frame, width=width, height=height) c_img = cv2.cvtColor(images["orignal_image"].copy(), cv2.COLOR_BGR2RGB) photo = PIL.ImageTk.PhotoImage(image=PIL.Image.fromarray(c_img)) image_on_canvas = canvas.create_image(0, 0, image=photo, anchor=NW) canvas.pack() frame.pack() frame1 = Frame(root, width=350, height=30) frame1.pack() canvas1 = Canvas(frame1, bg='#FFFFFF', width=300, height=300, scrollregion=(0, 0, 30 * len(images["images"]), 100)) hbar = Scrollbar(frame1, orient=HORIZONTAL) hbar.pack(side=BOTTOM, fill=X) hbar.config(command=canvas1.xview) canvas1.config(width=300, height=300) canvas1.config(xscrollcommand=hbar.set) canvass = [] photo1 = [] i = 0 for img in images["images"]: canvass.append(Canvas(canvas1, width=28, height=80)) im = img["image"].copy() photo1.append( PIL.ImageTk.PhotoImage(image=PIL.Image.fromarray(im))) canvass[i].create_text(12, 10, fill="darkblue", font="Times 20 italic bold", text=img["output"]) image_on_canvas = canvass[i].create_image(0, 30, image=photo1[i], anchor=NW) canvass[i].pack(side=LEFT) i += 1 canvas1.pack(side=LEFT, expand=True, fill=BOTH) root.mainloop()
def transform_fn(model, request_body, content_type, accept_type): try: input_object=json.loads(request_body) board=input_object["board"] count=input_object["session"].get("count",0) input_object["session"]["count"]=count+1 if count>10: board=nd.array(board) board=nd.concat( (board==1).expand_dims(axis=0), (board==2).expand_dims(axis=0),dim=0 ) board=board.expand_dims(axis=0) mask=board.clip(0,1) mask=-(mask-1) mask=mask.reshape((2,-1)) p=nd.softmax(model(board).reshape((-1,))) p=p*mask[0]*mask[1] while True: loc=int(p.argmax(axis=0).asscalar()) y=loc//board.shape[2] x=loc%board.shape[2] if input_object["board"][y][x]==0: break else: p[loc]=0 else: while True: x=random.randint(0,len(input_object["board"][0])-1) y=random.randint(0,len(input_object["board"])-1) if input_object["board"][y][x]==0: break input_object["session"]["shootType"]="CNNNet" return bytearray(json.dumps({ "shot":{ "x":x, "y":y }, "session":input_object["session"] }),'utf-8'),accept_type except Exception as e: print(traceback.format_exc()) print(e)
def main(): args = arg_parser().parse_args() image_ph = tf.placeholder(tf.uint8, shape=(50, 200, 3)) with tf.variable_scope('model'): logits = model(image_ph[None]) labels = tf.argmax(logits, axis=-1)[0] with tf.Session() as sess: sess.run(tf.global_variables_initializer()) load_vars(sess, args.model, relaxed=True, log_fn=load_log_fn) for image_path in args.images: image = np.array(Image.open(image_path)) labels_out = sess.run(labels, feed_dict={image_ph: image}) print('%s: %s' % (image_path, ''.join(map(str, labels_out))))
def evaluate(model, iterator, output_metrics_result=None, output_confusion_result=None): y_preds = [] y_truths = [] example_feature, example_pred = None, None for idx, batch in enumerate(iterator): x_times, x_features, x_labels = batch if torch.cuda.is_available(): x_times, x_features, x_labels = x_times.cuda(), x_features.cuda(), x_labels.cuda() y_pred = model(x_times, x_features) predicted = torch.max(y_pred.cpu().data, 1)[1] if example_feature is None and example_pred is None: example_feature, example_pred = x_features, predicted y_preds.extend(predicted.numpy()) y_truths.extend(x_labels[:, -1].cpu().data.numpy()) print("Example-----") print("-----Feature: {}".format(example_feature)) print("-----Prediction: {}".format(example_pred)) return evaluate_multi_class(y_preds, y_truths, output_metrics_result, output_confusion_result)
def model_fn(model_dir): print("loading from %s"%(model_dir)) with open('%s/hyperparameters.json'%(model_dir), 'r') as fp: hyperparameters = json.load(fp) net=model( depth=int(hyperparameters.get("depth",2)), width=int(hyperparameters.get("width",3)), ) try: print("trying to load float16") net.cast("float16") net.collect_params().load("%s/model-0000.params"%(model_dir), ctx) except Exception as e: print(e) print("trying to load float32") net.cast("float32") net.collect_params().load("%s/model-0000.params"%(model_dir), ctx) net.cast("float32") return net
def get_total(self): image = self.image.copy() image = imutils.resize(image, height=500) crop_imgs = [] crop_imgs.append(image[443:488, 107:216]) crop_imgs.append(image[443:488, 220:323]) crop_imgs.append(image[443:488, 325:450]) crop_imgs.append(image[443:488, 451:604]) section_and_total = [] total = 0 for crop_img in crop_imgs: img = crop_img.copy() im = Image(img) img = im.covert_to_gray() img = im.apply_gaussian_blur() img = im.apply_threshold() img = im.apply_canny() img = im.apply_morphology_close() con = im.find_contours() images = im.get_images(con) load_model = model() load_model.load_model("cnn1.h5") images = load_model.predict(images) output = "" if len(images["images"]) == 1: output += images["images"][0]["output"] else: if images["images"][0]["location"]["x"] < images["images"][1][ "location"]["x"]: output += images["images"][0]["output"] output += images["images"][1]["output"] else: output += images["images"][1]["output"] output += images["images"][0]["output"] total += int(output) section_and_total.append(int(output)) section_and_total.append(total) return section_and_total
''' This file calls all the methods declared datagen: loading the data from the directories model: defining the model architecture train: training the model and saving it ''' from datagen import datagen from cnn import model from train import train training_path = 'dataset/training_set' test_path = 'dataset/test_set' '''loading the data ''' training_set, validation_set, test_set = datagen(training_path, test_path) ''' defining the model architecture ''' base_model = base_model() model = model() ''' training and savinf the model ''' train(base_model, 'base_model', training_set, validation_set, 32, 50) train(model, 'model', training_set, validation_set, 32, 50)
def train(hyperparameters, hosts, num_gpus, **kwargs): try: _ = mx.nd.array([1], ctx=mx.gpu(0)) ctx = [mx.gpu(i) for i in range(num_gpus)] print("using GPU") DTYPE = "float16" host_ctx = mx.cpu_pinned(0) except mx.MXNetError: ctx = [mx.cpu()] print("using CPU") DTYPE = "float32" host_ctx = mx.cpu(0) model_dir = os.environ.get("SM_CHANNEL_MODEL") if model_dir: print("using prebuild model") shutil.unpack_archive("%s/model.tar.gz" % (model_dir), model_dir) with open('%s/hyperparameters.json' % (model_dir), 'r') as fp: saved_hyperparameters = json.load(fp) net = model( depth=int(saved_hyperparameters.get("depth", 2)), width=int(saved_hyperparameters.get("width", 3)), ) try: print("trying to load float16") net.cast("float16") net.collect_params().load("%s/model-0000.params" % (model_dir), ctx) except Exception as e: print(e) print("trying to load float32") net.cast("float32") net.collect_params().load("%s/model-0000.params" % (model_dir), ctx) net.cast(DTYPE) else: print("building model from scratch") net = model( depth=int(hyperparameters.get("depth", 2)), width=int(hyperparameters.get("width", 3)), ) net.cast(DTYPE) net.collect_params().initialize(mx.init.Xavier(), ctx=ctx) net.hybridize() print(net) dice = DiceLoss() dice.cast(DTYPE) dice.hybridize() trainer = gluon.Trainer( net.collect_params_layers(2) if model_dir else net.collect_params(), 'adam', { "multi_precision": (DTYPE == 'float16'), 'learning_rate': float(hyperparameters.get("learning_rate", .001)) }) train_iter, test_iter = get_data(int(hyperparameters.get("batch_size", 8)), DTYPE, host_ctx) Loss = gluon.loss.SoftmaxCrossEntropyLoss(sparse_label=False) best = float("inf") warm_up = int(hyperparameters.get("warm_up", 30)) patience = int(hyperparameters.get("patience", 10)) wait = 0 for e in range(hyperparameters.get("epochs", 11)): print("Epoch %s" % (e)) val_loss = 0 st = time.time() training_count = 0 testing_count = 0 training_loss = 0 for batch in train_iter: batch_size = batch.data[0].shape[0] training_count += batch_size data = gluon.utils.split_and_load(batch.data[0].astype(DTYPE), ctx) label = gluon.utils.split_and_load( batch.label[0].astype(DTYPE).reshape((batch_size, -1)), ctx) mask = gluon.utils.split_and_load( batch.label[1].astype(DTYPE).reshape((batch_size, -1)), ctx) with autograd.record(): output = [net(x) for x in data] losses = [ -dice(x, y, z) for x, y, z in zip(output, label, mask) ] for loss in losses: loss.backward() trainer.step(batch_size) training_loss += sum(loss.sum().asscalar() for loss in losses) for batch in test_iter: batch_size = batch.data[0].shape[0] testing_count += batch_size data = gluon.utils.split_and_load(batch.data[0].astype(DTYPE), ctx) label = gluon.utils.split_and_load( batch.label[0].astype(DTYPE).reshape((batch_size, -1)), ctx) mask = gluon.utils.split_and_load( batch.label[1].astype(DTYPE).reshape((batch_size, -1)), ctx) output = [net(x) for x in data] losses = [-dice(x, y, z) for x, y, z in zip(output, label, mask)] val_loss += sum(loss.sum().asscalar() for loss in losses) et = time.time() print("Hyperparameters: %s;" % (hyperparameters)) print("Training loss: %s;" % (-training_loss / training_count)) print("Testing loss: %s;" % (-val_loss / (testing_count))) print("Throughput=%2.2f;" % ((training_count + testing_count) / (et - st))) print("Validation Loss=%2.2f;" % val_loss) print("Best=%2.2f;" % best) if e >= warm_up: if val_loss < best: print("best model: %s;" % (-val_loss / (testing_count))) save(net, hyperparameters) best = val_loss wait = 0 else: wait += 1 if wait > patience: print("stoping early") break train_iter.reset() test_iter.reset()
def main(*argv): data_dir = "/tmp/tensorflow/mnist/input_data" # load dataset mnist = input_data.read_data_sets(data_dir) graph = tf.Graph() with graph.as_default(): # import data as placeholder # batch_size * height * width * channels # as bs*28*28*1 x = tf.placeholder(tf.float32, [None, 784]) # true label y_ = tf.placeholder(tf.int64, [None]) dropout_rate = tf.placeholder(tf.float32) y, loss, train_step = cnn.model(x, y_, dropout_rate) with tf.Session(graph=graph) as sess: init = tf.global_variables_initializer() sess.run(init) correct_prediction = tf.equal(tf.argmax(y, 1), y_) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # Train for step in range(30): print("step", step) for i in range(500): batch_xs, batch_ys = mnist.train.next_batch(100) opt, l = sess.run([train_step, loss], feed_dict={ x: batch_xs, y_: batch_ys, dropout_rate: 0.4 }) if i == 499: print( "train acc & loss: ", sess.run([accuracy, loss], feed_dict={ x: batch_xs, y_: batch_ys, dropout_rate: 1.0 })) tx, ty = mnist.test.next_batch(1000) print( "partial test acc & loss: ", sess.run([accuracy, loss], feed_dict={ x: tx, y_: ty, dropout_rate: 1.0 })) # final with all test # use dirty workaround # since the complete test data # cannot fit into GPU block_count = 10 total_acc = 0.0 total_loss = 0.0 for i in range(block_count): tx, ty = mnist.test.next_batch(1000) entry = sess.run([accuracy, loss], feed_dict={ x: tx, y_: ty, dropout_rate: 1.0 }) total_acc += entry[0] total_loss += entry[1] final_acc = total_acc / block_count final_loss = total_loss / block_count print("final test acc & loss: ", [final_acc, final_loss])
def main(): parser = ArgumentParser(description='PyTorch DQN') parser.add_argument('--exp', type=str, default=None) args = parser.parse_args() D = 1e6 # Amnt in replay memory M = 1000000 # Number of epsiodes to run T = 150 # Number of steps to take maximum epsilon = 1 # Choose random actions prob save_iter = 200 gamma = .99 # Forgetting factor of the past batch_size = 32 # Number of elements to sample from replay memory num_frames = 0 # Counter for the number of frames frame_skip = 4 # Number of frames to wait before selecting a new action env = gym.make('CartPole-v0') er = erp.experience_replay(D) reward_ls = [] loss_fn = torch.nn.MSELoss() writer = SummaryWriter(args.exp) loss = 1 checkpoint = torch.load('model/model.pt') cnn.model.load_state_dict(checkpoint['model_state_dict']) cnn.optimizer.load_state_dict(checkpoint['optimizer_state_dict']) num_frames = checkpoint['epoch'] epsilon = checkpoint['epsilon'] uniform_state = torch.load('uniform_init.pt') # uniform_state = fill_uniform_state_buf(env, frame_skip) # torch.save(torch.stack(uniform_state), 'uniform_init.pt') # writer.add_graph(cnn.model, torch.autograd.Variable( # torch.Tensor(4, 84, 84))) for eps in range(M): env.reset() batch = create_new_batch(env, frame_skip, act=-1) reward_gl = 0 print(eps, epsilon, num_frames) for t in range(T): if random.random() < epsilon: act = env.action_space.sample() else: with torch.no_grad(): Q = cnn.model(batch) act = torch.argmax(Q).item() _, reward, done, _ = env.step(act) reward = bound_reward(reward) # reward_ls.append(reward) num_frames += frame_skip reward_gl += reward if done: er.add_mem(batch, act, reward, False) else: new_batch = create_new_batch(env, frame_skip, act=act) er.add_mem(batch, act, reward, new_batch) batch = new_batch if len(er.replay) > batch_size: state_batch, action_batch, reward_batch, next_state_batch = er.sample_batch( batch_size) state_back = torch.stack(state_batch) act = torch.tensor(action_batch) rew = torch.tensor(reward_batch) mask_nd = torch.tensor( [type(mem) == torch.Tensor for mem in next_state_batch]) non_final_next_states = torch.stack([ s.squeeze(0) for i, s in enumerate(next_state_batch) if mask_nd[i] ]) Q = cnn.model(state_back).gather(1, act.unsqueeze(1)) Q_opt = torch.zeros(batch_size) Q_opt[mask_nd] = cnn.model(non_final_next_states).detach().max( 1)[0] expected_reward = rew.float() + gamma * Q_opt loss = loss_fn(Q.squeeze(1), expected_reward) #print(loss) cnn.optimizer.zero_grad() loss.backward() cnn.optimizer.step() if done: break writer.add_scalar('data/eps_len', t, num_frames) writer.add_scalar('data/reward', reward_gl, num_frames) writer.add_scalar('data/eps', epsilon, num_frames) with torch.no_grad(): writer.add_scalar( 'data/avg_Q', torch.mean(torch.max(cnn.model(uniform_state), 1)[0]), num_frames) epsilon = eps_anneal(epsilon) if eps % save_iter == 0: torch.save( { 'epoch': num_frames, 'model_state_dict': cnn.model.state_dict(), 'optimizer_state_dict': cnn.optimizer.state_dict(), 'epsilon': epsilon }, 'model/model.pt') env.close() writer.close()