def load_fv(fv='fv0'):
if fv == 'fv0':
gmm_data = fvloader.load_train_data(size=0, balance=False)
weights, means, covs = load_gmm(gmm_data, gmmdir='gmm/fv0')
train_data = fvloader.load_train_data(size=0, balance=True)
val_data = fvloader.load_val_data(size=0)
test_data = fvloader.load_test_data(size=0)
elif fv == 'matlab':
gmm_data = matloader.load_train_data(size=0, balance=False)
weights, means, covs = load_gmm(gmm_data, gmmdir='gmm/matlab')
train_data = matloader.load_train_data(size=0, balance=True)
val_data = matloader.load_val_data(size=0)
test_data = matloader.load_test_data(size=0)
train_items = data2fisher(train_data, weights, means, covs)
val_items = data2fisher(val_data, weights, means, covs)
test_items = data2fisher(test_data, weights, means, covs)
return train_items, val_items, test_items
def load_fv(fv='fv0'):
if fv == 'fv0':
kmean_data = fvloader.load_train_data(size=0, balance=False)
kmeans = cluster(kmean_data)
train_data = fvloader.load_train_data(size=0, balance=True)
val_data = fvloader.load_val_data(size=0)
test_data = fvloader.load_test_data(size=0)
bovdir = 'bov/fv0'
elif fv == 'matlab':
kmean_data = matloader.load_train_data(size=0, balance=False)
kmeans = cluster(kmean_data)
train_data = matloader.load_train_data(size=0, balance=True)
val_data = matloader.load_val_data(size=0)
test_data = matloader.load_test_data(size=0)
bovdir = 'bov/matlab'
train_items = data2bov(train_data, kmeans, bovdir=bovdir)
val_items = data2bov(val_data, kmeans, bovdir=bovdir)
test_items = data2bov(test_data, kmeans, bovdir=bovdir)
return train_items, val_items, test_items
def load_fv(fv='fv0'):
if fv == 'fv0':
vlad_data = fvloader.load_train_data(size=0, balance=False)
kmeans = cluster(vlad_data)
train_data = fvloader.load_train_data(size=0, balance=True)
val_data = fvloader.load_val_data(size=0)
test_data = fvloader.load_test_data(size=0)
vladdir = 'vlad/fv0'
elif fv == 'matlab':
vlad_data = matloader.load_train_data(size=0, balance=False)
kmeans = cluster(vlad_data)
train_data = matloader.load_train_data(size=0, balance=True)
val_data = matloader.load_val_data(size=0)
test_data = matloader.load_test_data(size=0)
vladdir = 'vlad/matlab'
train_items = data2vlad(train_data, kmeans, vladdir=vladdir)
val_items = data2vlad(val_data, kmeans, vladdir=vladdir)
test_items = data2vlad(test_data, kmeans, vladdir=vladdir)
return train_items, val_items, test_items
def train(fv="res18-128", size=0):
# train_data = fvloader.load_train_data(size=size, balance=True)
# val_data = fvloader.load_val_data(size=size)
# test_data = fvloader.load_test_data(size=size)
train_data = matloader.load_train_data(size=size, balance=True)
val_data = matloader.load_val_data(size=size)
test_data = matloader.load_test_data(size=size)
model_name = "imgrnn_%s_size%d_bce_gbalance" % (fv, size)
model_dir = os.path.join("./modeldir/%s" % model_name)
model_pth = os.path.join(model_dir, "model.pth")
# INPUT_DIM = int(fv.split("-")[-1])
INPUT_DIM = 1097
writer = tensorboardX.SummaryWriter(model_dir)
if os.path.exists(model_pth):
print("------load model--------")
rnn = torch.load(model_pth)
else:
rnn = ImageRNN(INPUT_DIM, HIDDEN_SIZE, NUM_CLASSES).cuda()
optimizer = torch.optim.Adam(rnn.parameters(), lr=0.00001)
criterion = torch.nn.BCELoss(reduce=True, size_average=True)
epochs = 10000
step = 1
val_step = 1
max_f1 = 0.0
for e in range(epochs):
print("------epoch--------", e)
rnn.train()
st = time.time()
# train_shuffle = fvloader.shuffle(train_data)
# for item in fvloader.batch_fv(train_shuffle, batch=256):
train_shuffle = matloader.shuffle(train_data)
for item in matloader.batch_fv(train_shuffle, batch=64):
rnn.zero_grad()
genes, nimgs, labels, timesteps = item
idx = np.argsort(np.array(-timesteps))
# s_genes = genes[idx]
s_nimgs = torch.from_numpy(np.stack(nimgs[idx])).type(
torch.cuda.FloatTensor)
s_labels = torch.from_numpy(labels[idx]).type(
torch.cuda.FloatTensor)
s_timesteps = timesteps[idx]
# print("timesteps", timesteps, len(timesteps))
# print("sorted timesteps", s_timesteps)
# print("s_nimgs", s_nimgs.shape, s_nimgs[0].shape)
# print("s_labels", s_labels.shape)
out, hidden = rnn(s_nimgs, s_timesteps)
# print("pd", out.shape)
loss = criterion(out, s_labels)
writer.add_scalar("loss", loss, step)
loss.backward()
optimizer.step()
step += 1
et = time.time()
writer.add_scalar("train time", et - st, e)
if e % 1 == 0:
val_loss, val_f1 = run_val(rnn, val_data, writer, val_step,
criterion)
val_step += 1
if e == 0:
start_loss = val_loss
min_loss = start_loss
# if val_loss > 2 * min_loss:
# print("early stopping at %d" % e)
# break
# if e % 50 == 0:
# pt = os.path.join(model_dir, "%d.pt" % e)
# torch.save(rnn.state_dict(), pt)
# result = os.path.join(model_dir, "result_epoch%d.txt" % e)
# run_test(rnn, test_data, result)
if min_loss > val_loss or max_f1 < val_f1:
if min_loss > val_loss:
print("---------save best----------", "loss", val_loss)
min_loss = val_loss
if max_f1 < val_f1:
print("---------save best----------", "f1", val_f1)
max_f1 = val_f1
torch.save(rnn, model_pth)
result = os.path.join(model_dir, "result_epoch%d.txt" % e)
run_test(rnn, test_data, result)