def main():
batch_size = 100
mnist_train = datasets.MNIST("/hdd/Data/MNIST/",
train=True,
transform=transforms.ToTensor(),
download=True)
mnist_test = datasets.MNIST("/hdd/Data/MNIST/",
train=False,
transform=transforms.ToTensor(),
download=True)
data_feeder = DataFeeder(mnist_train,
preprocess_workers=1,
cuda_workers=1,
cpu_size=10,
cuda_size=10,
batch_size=batch_size,
use_cuda=True,
volatile=False)
data_feeder.start_queue_threads()
cnn = ModelStruct(CNN().cuda(), 0.001)
fcc = ModelStruct(FCC().cuda(), 0.001)
test_data = make_batch(len(mnist_test), 0, mnist_test, use_cuda=True)
for i in range(100001):
images, labels = data_feeder.get_batch()
train(cnn, images, labels, i)
train(fcc, images, labels, i)
if i % 100 == 0:
evaluate_acc(cnn, test_data, i)
evaluate_acc(fcc, test_data, i)
if i in [33333, 66666]:
decrease_lr(cnn)
decrease_lr(fcc)
if i % 20000 == 0:
torch.save(cnn.model, "savedir/cnn_it" + str(i // 1000) + "k.pt")
torch.save(fcc.model, "savedir/fcc_it" + str(i // 1000) + "k.pt")
print(max(cnn.acc))
print(max(fcc.acc))
graph(fcc, cnn)
cnn.losses = losses_to_ewma(cnn.losses)
cnn.val_losses = losses_to_ewma(cnn.val_losses, alpha=0.3)
cnn.acc = losses_to_ewma(cnn.acc)
fcc.losses = losses_to_ewma(fcc.losses)
fcc.val_losses = losses_to_ewma(fcc.val_losses, alpha=0.3)
fcc.acc = losses_to_ewma(fcc.acc)
graph(fcc, cnn)
data_feeder.kill_queue_threads()
def main():
batch_size = 100
train_data, val_data, test_data = create_train_val_test_split(batch_size)
data_feeder = DataFeeder(train_data,
preprocess_workers=1,
cuda_workers=1,
cpu_size=10,
cuda_size=10,
batch_size=batch_size,
use_cuda=True,
volatile=False)
data_feeder.start_queue_threads()
val_data = make_batch(len(val_data),
0,
val_data,
use_cuda=True,
volatile=True)
test_data = make_batch(len(test_data),
0,
test_data,
use_cuda=True,
volatile=True)
cnn = CNN().cuda()
fcc = FCC().cuda()
optimizer_cnn = optim.SGD(cnn.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.00001)
optimizer_fcc = optim.SGD(fcc.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.00001)
cnn_train_loss = Logger("cnn_train_losses.txt")
cnn_val_loss = Logger("cnn_val_losses.txt")
cnn_val_acc = Logger("cnn_val_acc.txt")
fcc_train_loss = Logger("fcc_train_losses.txt")
fcc_val_loss = Logger("fcc_val_losses.txt")
fcc_val_acc = Logger("fcc_val_acc.txt")
#permute = Variable(torch.from_numpy(np.random.permutation(28*28)).long().cuda(), requires_grad=False)
permute = None
for i in range(100001):
images, labels = data_feeder.get_batch()
train(cnn, optimizer_cnn, images, labels, i, cnn_train_loss, permute)
train(fcc, optimizer_fcc, images, labels, i, fcc_train_loss, permute)
if i % 100 == 0:
print(i)
evaluate_acc(batch_size, cnn, val_data, i, cnn_val_loss,
cnn_val_acc, permute)
evaluate_acc(batch_size, fcc, val_data, i, fcc_val_loss,
fcc_val_acc, permute)
if i in [70000, 90000]:
decrease_lr(optimizer_cnn)
decrease_lr(optimizer_fcc)
if i % 1000 == 0:
torch.save(cnn.state_dict(),
"savedir/cnn_it" + str(i // 1000) + "k.pth")
torch.save(fcc.state_dict(),
"savedir/fcc_it" + str(i // 1000) + "k.pth")
data_feeder.kill_queue_threads()
import evaluate
evaluate.main(permute)
from utils import show_image, graph_losses
from data_feeder import DataFeeder
from PIL import Image
coco_path = "/hdd/Data/MSCOCO2017/images"
annFile = "/hdd/Data/MSCOCO2017/annotations"
train_data_feeder = DataFeeder(coco_path + "/train2017/",
annFile + "/captions_train2017.json",
preprocess_workers=1,
cuda_workers=1,
numpy_size=20,
cuda_size=2,
batch_size=1)
train_data_feeder.start_queue_threads()
image_transformer_network = ImageTransformerNetwork().cuda()
#image_transformer_network = torch.load("savedir/model_2_acidcrop_it90k.pt")
vgg = VGG().cuda()
vgg.eval()
loss = Loss().cuda()
for param in vgg.parameters():
param.requires_grad = False
learning_rate = 0.0001
optimizer = optim.Adam(image_transformer_network.parameters(),
lr=learning_rate)
style = Variable(
torch.from_numpy(
