def train(config): """Trains the ReInspect model using SGD with momentum and prints out the logging information.""" net = apollocaffe.ApolloNet() net_config = config["net"] data_config = config["data"] solver = config["solver"] logging = config["logging"] image_mean = load_data_mean( data_config["idl_mean"], net_config["img_width"], net_config["img_height"], image_scaling=1.0) input_gen = load_idl(data_config["train_idl"], image_mean, net_config) input_gen_test = load_idl(data_config["test_idl"], image_mean, net_config) forward(net, input_gen.next(), config["net"]) #net.draw_to_file(logging["schematic_path"]) if solver["weights"]: net.load(solver["weights"]) else: net.load(googlenet.weights_file()) loss_hist = {"train": [], "test": []} loggers = [ apollocaffe.loggers.TrainLogger(logging["display_interval"], logging["log_file"]), apollocaffe.loggers.TestLogger(solver["test_interval"], logging["log_file"]), apollocaffe.loggers.SnapshotLogger(logging["snapshot_interval"], logging["snapshot_prefix"]), ] for i in range(solver["start_iter"], solver["max_iter"]): if i % solver["test_interval"] == 0: net.phase = 'test' test_loss = [] for _ in range(solver["test_iter"]): forward(net, input_gen_test.next(), config["net"], False) test_loss.append(net.loss) loss_hist["test"].append(np.mean(test_loss)) net.phase = 'train' forward(net, input_gen.next(), config["net"]) loss_hist["train"].append(net.loss) net.backward() learning_rate = (solver["base_lr"] * (solver["gamma"])**(i // solver["stepsize"])) net.update(lr=learning_rate, momentum=solver["momentum"], clip_gradients=solver["clip_gradients"]) for logger in loggers: logger.log(i, {'train_loss': loss_hist["train"], 'test_loss': loss_hist["test"], 'apollo_net': net, 'start_iter': 0})
def train(config): net = apollocaffe.ApolloNet() net_config = config["net"] data_config = config["data"] logging = config["logging"] image_mean = load_data_mean( data_config["idl_mean"], net_config["img_width"], net_config["img_height"], image_scaling=1.0 ) input_gen = load_idl_list(data_config["train_idl"], image_mean, net_config) input_gen_test = load_idl_list(data_config["test_idl"], image_mean, net_config) forward(net, input_gen.next(), config["net"]) net.draw_to_file(logging["schematic_path"]) solver = config["solver"] if solver["weights"]: net.load(solver["weights"]) else: net.load(googlenet.weights_file()) train_loss_hist = [] test_loss_hist = [] loggers = [ apollocaffe.loggers.TrainLogger(logging["display_interval"]), apollocaffe.loggers.TestLogger(solver["test_interval"]), apollocaffe.loggers.SnapshotLogger(logging["snapshot_interval"], logging["snapshot_prefix"]), ] for i in range(solver["start_iter"], solver["max_iter"]): if i % solver["test_interval"] == 0: net.phase = "test" for _ in range(solver["test_iter"]): forward(net, input_gen_test.next(), config["net"], False) test_loss_hist.append(net.loss) net.phase = "train" forward(net, input_gen.next(), config["net"]) train_loss_hist.append(net.loss) net.backward() lr = solver["base_lr"] * (solver["gamma"]) ** (i // solver["stepsize"]) net.update(lr=lr, momentum=solver["momentum"], clip_gradients=solver["clip_gradients"]) for logger in loggers: logger.log( i, {"train_loss": train_loss_hist, "test_loss": test_loss_hist, "apollo_net": net, "start_iter": 0} )
def train(config): """Trains the ReInspect model using SGD with momentum and prints out the logging information.""" net = apollocaffe.ApolloNet() net_config = config["net"] data_config = config["data"] solver = config["solver"] logging = config["logging"] image_mean = load_data_mean( data_config["idl_mean"], net_config["img_width"], net_config["img_height"], image_scaling=1.0) input_gen = load_idl(data_config["train_idl"], image_mean, net_config) input_gen_test = load_idl(data_config["test_idl"], image_mean, net_config) forward(net, input_gen.next(), config["net"]) net.draw_to_file(logging["schematic_path"]) if solver["weights"]: net.load(solver["weights"]) net.draw_to_file("net.png") print ("fine-tuning from " + solver["weights"]) else: net.load(googlenet.weights_file()) print ("fine-tuning from google net") loss_hist = {"train": [], "test": []} loggers = [ apollocaffe.loggers.TrainLogger(logging["display_interval"], logging["log_file"]), apollocaffe.loggers.TestLogger(solver["test_interval"], logging["log_file"]), apollocaffe.loggers.SnapshotLogger(logging["snapshot_interval"], logging["snapshot_prefix"]), ] for i in range(solver["start_iter"], solver["max_iter"]): if i % solver["test_interval"] == 0: net.phase = 'test' test_loss = [] loss0 = 0 loss1 = 0 loss2 = 0 for _ in range(solver["test_iter"]): forward(net, input_gen_test.next(), config["net"], False) test_loss.append(net.loss) loss0 += net.blobs["numberloss"].data[0] loss1 += net.blobs["hungarian"].data[0] loss2 += net.blobs["box_loss"].data[0] loss_hist["test"].append(np.mean(test_loss)) loss0 = loss0 / solver["test_iter"] loss1 = loss1 / solver["test_iter"] loss2 = loss2 / solver["test_iter"] print "Number Loss", loss0, "Hungarian Loss", loss1, "Box Loss", loss2 net.phase = 'train' forward(net, input_gen.next(), config["net"]) loss_hist["train"].append(net.loss) net.backward() learning_rate = (solver["base_lr"] * (solver["gamma"])**(i // solver["stepsize"])) net.update(lr=learning_rate, momentum=solver["momentum"], clip_gradients=solver["clip_gradients"]) for logger in loggers: logger.log(i, {'train_loss': loss_hist["train"], 'test_loss': loss_hist["test"], 'apollo_net': net, 'start_iter': 0})
def train(config): """Trains the ReInspect model using SGD with momentum and prints out the logging information.""" net = apollocaffe.ApolloNet() net_config = config["net"] data_config = config["data"] solver = config["solver"] logging = config["logging"] image_mean = load_data_mean(data_config["idl_mean"], net_config["img_width"], net_config["img_height"], image_scaling=1.0) input_gen = load_idl(data_config["train_idl"], image_mean, net_config) input_gen_test = load_idl(data_config["test_idl"], image_mean, net_config, jitter=False) forward(net, input_gen.next(), config["net"]) net.draw_to_file(logging["schematic_path"]) if solver["weights"]: net.load(solver["weights"]) else: net.load(googlenet.weights_file()) loss_hist = {"train": [], "test": []} loggers = [ apollocaffe.loggers.TrainLogger(logging["display_interval"], logging["log_file"]), apollocaffe.loggers.TestLogger(solver["test_interval"], logging["log_file"]), apollocaffe.loggers.SnapshotLogger(logging["snapshot_interval"], logging["snapshot_prefix"]), ] for i in range(solver["start_iter"], solver["max_iter"]): # # test and evaluation if i % solver["test_interval"] == 0: net.phase = 'test' test_loss = [] test_loss2 = [] cc_list = [] ce_list = [] ca_list = [] cp_list = [] for _ in range(solver["test_iter"]): input_en = input_gen_test.next() forward(net, input_en, net_config, False) test_loss.append(net.loss) (count_cover, count_error, count_anno, count_pred) = get_accuracy(net, input_en, net_config) cc_list.append(count_cover) ce_list.append(count_error) ca_list.append(count_anno) cp_list.append(count_pred) loss_hist["test"].append(np.mean(test_loss)) precision = np.sum(cc_list) / np.sum(cp_list) recall = np.sum(cc_list) / np.sum(ca_list) print 'hungarian loss:', np.mean(test_loss) print 'iterate: %6.d error, recall, F1: (%.3f %.3f) -> %.3f' % ( i, 1 - precision, recall, 2 * precision * recall / (precision + recall)) net.phase = 'train' forward(net, input_gen.next(), config["net"]) loss_hist["train"].append(net.loss) net.backward() learning_rate = (solver["base_lr"] * (solver["gamma"])**(i // solver["stepsize"])) net.update(lr=learning_rate, momentum=solver["momentum"], clip_gradients=solver["clip_gradients"]) for logger in loggers: logger.log( i, { 'train_loss': loss_hist["train"], 'test_loss': loss_hist["test"], 'apollo_net': net, 'start_iter': 0 })
def train(datasize, batchsize, numIter): # batch_size = 100 # num_batches = 200 google_net = apollocaffe.ApolloNet() net = apollocaffe.ApolloNet() val_datasize = datasize / train_val_ratio X_train, y_train, X_val, y_val = load_dataset(datasize, val_datasize) batch_size = batchsize num_batches = datasize / batchsize num_val_batches = val_datasize / batchsize start = time.time() # f = open('/deep/u/vinaya/cs231n/yelp_shubham/loss_%d.txt'% datasize, 'w+') forward_google_net(google_net, np.expand_dims(X_train[0], axis=0), [y_train[0]]) google_net.load(googlenet.weights_file()) for i in range(numIter): if (i + 1) % val_iter == 0: f = open("/deep/u/vinaya/cs231n/yelp_shubham/loss_val_%d_%d.txt" % (datasize, numIter), "a+") predicted_labels = [] for j in range(num_val_batches): X = X_val[j * batch_size : (j + 1) * batch_size, :, :, :] y = y_val[j * batch_size : (j + 1) * batch_size] predicted_label, loss = forward(google_net, net, X, y) print >> f, "val epoch -", (i + 1) / val_iter, "batch -", j print "val epoch -", (i + 1) / val_iter, "batch -", j, "loss - ", loss print >> f, "val loss", loss predicted_labels.extend(predicted_label) log_predicted_labels(i, datasize, predicted_labels, y_val, True) accuracy = getAccuracy(predicted_labels, y_val) print >> f, "val accuracy", accuracy f.close() f = open("/deep/u/vinaya/cs231n/yelp_shubham/loss_train_%d_%d.txt" % (datasize, numIter), "a+") predicted_labels = [] for j in range(num_batches): X = X_train[j * batch_size : (j + 1) * batch_size, :, :, :] y = y_train[j * batch_size : (j + 1) * batch_size] # forward_google_net(google_net, X, y) # inp_net = google_net.blobs['inception_5b/output'].data # forward_net(net, inp_net, y) # ip_data = net.blobs['ip'].data predicted_label, loss = forward(google_net, net, X, y) net.backward() net.update(lr=0.2) print >> f, "epoch -", i, "batch -", j print "epoch -", i, "batch -", j, "loss - ", loss print >> f, "training loss", loss # predicted_label = np.ravel(np.argmax(ip_data, axis = 1)) predicted_labels.extend(predicted_label) # print 'predicted_label', np.ravel(np.argmax(ip_data, axis = 1)) # print 'actual_label', y log_predicted_labels(i, datasize, predicted_labels, y_train, False) accuracy = getAccuracy(predicted_labels, y_train) print >> f, "train accuracy", accuracy # count = 0 # for idx, i in enumerate(predicted_labels): # if i == y_train[idx]: # count += 1 # print >> f, 'accuracy', count/float(len(y_train)) f.close() f = open("/deep/u/vinaya/cs231n/yelp_shubham/loss_%d.txt" % datasize, "a+") print >> f, "time taken:", (time.time() - start) f.close()