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()
