def trainer(args):
if not os.path.isdir(args.model):
os.makedirs(args.model, )
print("Use Device: {}".format(DEVICE))
lang = Lang.load(args.lang)
dataset = VisDialFeature(
dialFile=args.data,
cocoDir=args.coco,
sentFeatureFile=args.feature,
featureTransform=torch.FloatTensor,
sentTransform=lambda s: torch.LongTensor(lang.sentenceToVector(s)),
imgTransform=cnnTransforms,
)
loader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch,
shuffle=True,
num_workers=4,
collate_fn=collate_fn)
image_setting = {"output_size": 1024, "pretrained": False}
question_setting = {"word_size": len(lang), "output_size": 512}
answer_setting = {
"output_size": 512,
}
model = VQAFeatureModel(image_setting, question_setting,
answer_setting).to(DEVICE)
model.train()
criterion = torch.nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=args.lr)
recLoss = Average()
print(
"\nStart trainning....\nEpoch\t:{}\nBatch\t:{}\nDataset\t:{}\n".format(
args.epoch, args.batch, len(dataset)))
for epoch in range(args.epoch):
pbar = tqdm(loader)
pbar.set_description("Epoch: {}, Loss: {:.4f}".format(epoch, 0))
for i, data in enumerate(pbar, 0):
loss = step(model=model,
data=data,
criterion=criterion,
optimizer=optimizer,
lang=lang,
device=DEVICE)
recLoss.addData(loss.item())
pbar.set_description("Ep: {}, Loss: {:.2f}".format(
epoch, loss.item()))
if i % 10 == 0:
pass
#pbar.set_description("Epoch: {}, Loss: {:.5f}".format(epoch, recLoss.getAndReset()))
torch.save(model,
os.path.join(args.model, "VQAmodel.{}.pth".format(epoch)))
def trainer(args):
if not os.path.isdir(args.model):
os.makedirs(args.model, )
print("Decode feature")
print("Use Device: {}".format(DEVICE))
lang = Lang.load(args.lang)
dataset = VisDialDataset(dialFile = args.data,
cocoDir = args.coco,
sentTransform = torch.LongTensor,
imgTransform = cnnTransforms,
convertSentence = lang.sentenceToVector)
loader = torch.utils.data.DataLoader(dataset.data["answers"],
batch_size=args.batch,
shuffle=True,
num_workers=4,
collate_fn=collate_fn)
encodeModel = torch.load(args.encode).to(DEVICE).eval()
sentence_setting = {
"word_size": len(lang),
"feature_size": 512,
}
model = SentenceDecoder(**sentence_setting).to(DEVICE)
model.train()
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=args.lr)
recLoss = Average()
print("\nStart trainning....\nEpoch\t:{}\nBatch\t:{}\nDataset\t:{}\n".format(args.epoch, args.batch, len(dataset)))
for epoch in range(args.epoch):
pbar = tqdm(loader)
pbar.set_description("Epoch: {}, Loss: {:.4f}".format(epoch, 0))
for i, data in enumerate(pbar, 0):
loss = step(model=model,
encodeModel=encodeModel,
data=data,
criterion=criterion,
optimizer=optimizer,
lang=lang,
device=DEVICE)
recLoss.addData(loss.item())
pbar.set_description("Ep: {}, Loss: {:.5f}".format(epoch, loss.item()))
if i % 10 == 0:
pass
#pbar.set_description("Epoch: {}, Loss: {:.5f}".format(epoch, recLoss.getAndReset()))
torch.save(model, os.path.join(args.model, "DecodeModel.{}.pth".format(epoch)))
def trainer(args):
if not os.path.isdir(args.model):
os.mkdir(args.model)
print("Use Device: {}".format(DEVICE))
lang = Lang.load(args.lang)
dataset = VisDialDataset(dialFile=args.data,
cocoDir=args.coco,
sentTransform=torch.LongTensor,
imgTransform=cnnTransforms,
convertSentence=lang.sentenceToVector)
loader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch,
shuffle=True,
num_workers=4,
collate_fn=collate_fn)
imgcnn = ImageEncoder(1024, 1024, pretrained=True).to(DEVICE)
sentDecoder = SentenceDecoder(word_size=len(lang),
em_size=256,
hidden_size=256,
feature_size=1024).to(DEVICE)
imgcnn.train()
sentDecoder.train()
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.Adam(list(imgcnn.parameters()) +
list(sentDecoder.parameters()),
lr=args.lr)
recLoss = Average()
for epoch in range(args.epoch):
pbar = tqdm(loader)
pbar.set_description("Epoch: {}, Loss: {:.4f}".format(epoch, 0))
for i, data in enumerate(pbar, 0):
loss = step(imageModel=imgcnn,
sentModel=sentDecoder,
data=data,
criterion=criterion,
optimizer=optimizer,
lang=lang)
recLoss.addData(loss.item())
pbar.set_description("Epoch: {}, Loss: {:.4f}".format(
epoch, loss.item()))
if i % 10 == 0:
pass
#pbar.set_description("Epoch: {}, Loss: {:.5f}".format(epoch, recLoss.getAndReset()))
torch.save(imgcnn, os.path.join(args.model,
"image{}.pkl".format(epoch)))
torch.save(sentDecoder,
os.path.join(args.model, "sentence{}.pkl".format(epoch)))
def trainer(args):
modelDir = args.model
LangFile = os.path.join(modelDir, "Lang.pkl")
modelFile = args.checkpoint
MaxEpoch = args.epoch
BatchSize = args.batch
DataDir = args.data
lr = args.lr
print("=========Use GPU: {}=========\n".format(use_cuda))
lang, model = Loadmodel(modelDir, LangFile, modelFile, dataDir=DataDir)
datasets = DramaDataset(basedir=DataDir,
maxFrame=0,
timeOffset=0.2,
startSeries=0,
maxSeries=40000,
subOffset=0,
subMax=None)
loader = torch.utils.data.DataLoader(datasets,
batch_size=BatchSize,
shuffle=True,
num_workers=1)
print("Data size\t: {}".format(len(datasets)))
print("Max epoch\t: {}\nBatch size\t: {}\nLearning rate\t: {}\n".format(
MaxEpoch, BatchSize, lr))
print("Start training........\n")
writer = SummaryWriter(modelDir)
if use_cuda:
model.cuda()
model.train()
optimizer = optim.Adam(model.parameters(), lr=lr)
criterion = nn.BCELoss()
recLoss = Average()
timer = Timer()
trainStep = 0
for epoch in range(MaxEpoch):
for i, data in enumerate(loader, 1):
#try:
pre, nex, imgs = data
pre, nex, scores = makeNegSample(pre, nex, negSize=1)
loss = step(model=model,
optimizer=optimizer,
criterion=criterion,
subtitles=pre,
targets=nex,
scores=scores,
lang=lang)
recLoss.addData(loss.item())
writer.add_scalar('loss', loss.item(), trainStep)
trainStep += 1
loss = None
if i % 50 == 0:
print(
"Epoch: {:2d}, Step: {:5d}, Time: {:6.3f}, Loss: {:7.5f}".
format(epoch, i, timer.getAndReset(),
recLoss.getAndReset()))
# except Exception as exp:
#print("Step error: {}".format(i))
#print(exp)
if i % 50 != 0:
print("Epoch: {:2d}, Step: {:5d}, Time: {:6.3f}, Loss: {:7.5f}".
format(epoch, i, timer.getAndReset(), recLoss.getAndReset()))
modelName = os.path.join(
modelDir, "SimilarityModel.{}.pth".format(int((epoch + 1) / 10)))
print("Saving Epoch model: {}.....\n".format(modelName))
torch.save(model, modelName)
def trainer(args):
ModalDir = args.modal
LangFile = os.path.join(ModalDir, "Lang.pkl")
ModalFile = os.path.join(ModalDir, "MainModal.pth")
MaxEpoch = args.epoch
BatchSize = args.batch
DataDir = args.data
lr = args.lr
use_cuda = torch.cuda.is_available()
#load data
with open(DataDir, 'rb') as f:
trainset = pickle.load(f)
loader = torch.utils.data.DataLoader(trainset,
batch_size=BatchSize,
shuffle=True,
num_workers=2)
lang, modal = loadModal(ModalDir=ModalDir,
LangFile=LangFile,
ModalFile=ModalFile,
dataset=trainset)
print("Data size: {}".format(len(trainset)))
print("Max epoch:{}\nBatch size:{}\nLearning rate:{}\n".format(
MaxEpoch, BatchSize, lr))
print("Start training........\n")
if use_cuda:
global Variable
Variable = Variable.cuda
modal.cuda()
modal.train()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(modal.parameters(), lr=lr)
recLoss = Average()
timer = Timer()
for epoch in range(1, MaxEpoch):
for i, data in enumerate(loader, 1):
fras, engs = data
in_fras, in_engs, out_engs = transData(fras, engs, lang)
outputs, hidden = modal(in_fras, in_engs)
outputs = flatMutileLength(outputs, out_engs[1])
out_engs = flatMutileLength(out_engs[0], out_engs[1])
loss = criterion(outputs, out_engs)
recLoss.addData(loss.data[0])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i % 100 == 0:
print(
"Epoch: {:2d}, Step: {:5d}, Time: {:6.3f}, Loss: {:7.5f}".
format(epoch, i, timer.getAndReset(),
recLoss.getAndReset()))
print("Fra: {}\nEng: {}\nModal:{}\n".format(
fras[0], engs[0], predit(modal, lang, fras[0])))
if epoch % 10 == 0:
print("Saving Epoch modal.....\n")
torch.save(
modal,
os.path.join(ModalDir, "SubSubModal.{}.pth".format(epoch)))
print("Fra: {}\nEng{}\nModal:{}\n".format(
fras[0], engs[0], predit(modal, lang, fras[0])))
def trainer(args):
modelDir = args.model
LangFile = os.path.join(modelDir, "Lang.pkl")
modelFile = args.checkpoint
MaxEpoch = args.epoch
BatchSize = args.batch
DataDir = args.data
lr = args.lr
print("=========Use Device: {}=========\n".format(device))
print("=========SubToSub=========")
#load data
datasets = DramaDataset(
basedir=DataDir,
maxFrame=0,
maxSeries=5,
)
loader = torch.utils.data.DataLoader(datasets,
batch_size=BatchSize,
shuffle=True,
num_workers=2)
lang, model = loadModel(modelDir=modelDir,
LangFile=LangFile,
modelFile=modelFile,
dataset=datasets)
print("Data size\t: {}".format(len(datasets)))
print("Max epoch\t: {}\nBatch size\t: {}\nLearning rate\t: {}\n".format(
MaxEpoch, BatchSize, lr))
print("Start training........\n")
model.to(device)
model.train()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr)
writer = SummaryWriter(modelDir)
recLoss = Average()
timer = Timer()
trainStep = 0
for epoch in range(MaxEpoch):
for i, data in enumerate(loader, 1):
try:
pre, nex, imgs = data
in_pre, in_nex, out_nex = transData(pre, nex, lang)
outputs, hidden = model(in_pre, in_nex)
outputs = flatMutileLength(outputs, out_nex[1])
out_nexs = flatMutileLength(out_nex[0], out_nex[1])
loss = criterion(outputs, out_nexs)
optimizer.zero_grad()
loss.backward()
optimizer.step()
recLoss.addData(loss.item())
writer.add_scalar('loss', loss.item(), trainStep)
trainStep += 1
if i % 100 == 0:
model.eval()
print(
"Epoch: {:2d}, Step: {:5d}, Time: {:6.3f}, Loss: {:7.5f}"
.format(epoch, i, timer.getAndReset(),
recLoss.getAndReset()))
print("F: {}\nS: {}\nP: {}\n".format(
pre[0], nex[0], predit(model, lang, pre[0])))
model.train()
except Exception as exp:
print(exp)
if i % 100 != 0:
print("Epoch: {:2d}, Step: {:5d}, Time: {:6.3f}, Loss: {:7.5f}".
format(epoch, i, timer.getAndReset(), recLoss.getAndReset()))
modelName = os.path.join(
modelDir, "SubSubModel.{}.pth".format(int((epoch + 1) / 5)))
print("Saving Epoch model: {}.....\n".format(modelName))
torch.save(model, modelName)
def trainer(args):
modelDir = args.model
LangFile = os.path.join(modelDir, "Lang.pkl")
modelFile = args.checkpoint
MaxEpoch = args.epoch
BatchSize = args.batch
DataDir = args.data
lr = args.lr
print("=========Start training ImgSubToSub=========\n")
print("=========Use Device: {}=========\n".format(device))
lang, model = Loadmodel(modelDir, LangFile, modelFile, dataDir=DataDir)
datasets = DramaDataset(basedir=DataDir,
maxFrame=1,
maxSeries=5,
timeOffset=0.2,
useBmp=True,
randomStart=False,
transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]))
loader = torch.utils.data.DataLoader(datasets,
batch_size=BatchSize,
shuffle=True,
num_workers=4)
print("Data size\t: {}".format(len(datasets)))
print("Max epoch\t: {}\nBatch size\t: {}\nLearning rate\t: {}\n".format(
MaxEpoch, BatchSize, lr))
print("Start training........\n")
writer = SummaryWriter(modelDir)
model.to(device)
model.train()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr)
recLoss = Average()
timer = Timer()
trainStep = 0
for epoch in range(MaxEpoch):
for i, data in enumerate(loader, 1):
try:
pre, nex, imgs = data
loss = step(model=model,
criterion=criterion,
optimizer=optimizer,
imgs=imgs[0],
subtitles=pre,
targets=nex,
lang=lang)
recLoss.addData(loss.item())
writer.add_scalar('loss', loss.item(), trainStep)
loss = None
if i % 50 == 0:
print(
"Epoch: {:2d}, Step: {:5d}, Time: {:6.3f}, Loss: {:7.5f}"
.format(epoch, i, timer.getAndReset(),
recLoss.getAndReset()))
model.eval()
pred = predit(model, lang, imgs[0][:1], pre[0])
model.train()
print("F: {}\nS: {}\nP: {}\n".format(pre[0], nex[0], pred))
except Exception as exp:
print("Step error: {}".format(i))
print(exp)
trainStep += 1
if i % 50 != 0:
print("Epoch: {:2d}, Step: {:5d}, Time: {:6.3f}, Loss: {:7.5f}".
format(epoch, i, timer.getAndReset(), recLoss.getAndReset()))
modelName = os.path.join(
modelDir, "SubImgModel.{}.pth".format(int((epoch + 1) / 5)))
print("Saving Epoch model: {}.....\n".format(modelName))
torch.save(model, modelName)