def train():
ctx = mx.gpu(0)
net = get_model('resnet18_v2', pretrained=False)
backbone = net.features[:]
backbone.initialize(mx.initializer.Xavier(factor_type='in', magnitude=2),
ctx=ctx)
out_net = OutputNet()
out_net.initialize(mx.initializer.Xavier(factor_type='in', magnitude=2),
ctx=ctx)
params = backbone.collect_params()
params.update(out_net.collect_params())
optimizer = mx.optimizer.SGD(learning_rate=0.001, wd=5e-4, momentum=0.9)
trainer = gluon.Trainer(params=params, optimizer=optimizer)
triplet_loss = gluon.loss.TripletLoss() # TripletLoss损失函数
num_step = 0
for epoch in range(30):
pdb.set_trace()
print('epoch:{}'.format(epoch))
tic = time.time()
train_data = loader.loadData(list_path_living=train_path_living,
list_path_spoof=train_path_spoof,
batch_size=batch_size,
num_seq=num_seq,
color=color,
is_train=True,
random=random)
val_data = loader.loadData(list_path_living=val_path_living,
list_path_spoof=val_path_spoof,
batch_size=batch_size,
num_seq=num_seq,
color=color,
is_train=False,
random=random)
train_loss, correct, total = [0, 0, 0]
for data, label in train_data:
num_step += 1
data = data.copyto(ctx)
label = label.copyto(ctx)
data_anchor = data[:, 0, :, :, :]
data_positive = data[:, 1, :, :, :]
data_negative = data[:, 2, :, :, :]
# data_a=data_anchor.reshape(data_anchor.shape[0]*data_anchor.shape[1],data_anchor.shape[2])
with ag.record():
feat_anchor = backbone(data_anchor)
y_anchor = out_net(feat_anchor)[1]
feat_positive = backbone(data_positive)
y_positive = out_net(feat_positive)[1]
feat_negative = backbone(data_negative)
y_negative = out_net(feat_negative)[1]
loss = triplet_loss(y_anchor, y_positive, y_negative)
loss = loss.sum()
loss.backward()
trainer.step(batch_size, ignore_stale_grad=True)
train_loss += loss.asscalar()
print('Epoch:{}. loss: {}'.format(epoch, train_loss))
import math
import pywFM
import numpy as np
import pandas as pd
import csv
from sklearn.feature_extraction import DictVectorizer
from sklearn.metrics import mean_squared_error
from data_loader import loadData
from data_loader import loadTest
(train, y_train), (valid, y_valid) = loadData("../item_recom/train_info.tsv", 1.1)
dictv = DictVectorizer()
test = loadTest("../item_recom/test_info.tsv")
print "convert to one-hot represerntation"
_ = dictv.fit_transform(train+test)
X_train = dictv.transform(train)
# X_valid = dictv.transform(valid)
X_test = dictv.transform(test)
y_test = np.ones(len(test))*2.5
fm = pywFM.FM(task='regression', num_iter=1200, k2=48, learning_method='mcmc')
model = fm.run(X_train, y_train, X_test, y_test)
# print("FM RMSE: %.6f" % math.sqrt(mean_squared_error(y_valid, model.predictions)))
#
with open('../submissions/sixteenth.csv', 'w') as csvfile:
fieldnames = ['uid#iid', 'pred']
writer = csv.DictWriter(csvfile, fieldnames)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batchSize', type=int, default=64)
parser.add_argument('--nEpochs', type=int, default=60)
parser.add_argument('--startEpoch', type=int, default=1)
parser.add_argument('--learningRate', type=float, default=1e-3)
parser.add_argument('--logDir', required=True)
parser.add_argument('--resume',
action='store_true',
default=False,
help='whether to resume from logDir if existent')
parser.add_argument('--finetune', action='store_true', default=False)
parser.add_argument('--imageSize', type=int, default=256)
parser.add_argument('--cropSize', type=int, default=224)
parser.add_argument('--seed', type=int, default=1)
parser.add_argument('--annDir', default='COCO annotation path')
parser.add_argument('--imageDir', default='COCO image path')
args = parser.parse_args()
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
if os.path.exists(args.logDir) and not args.resume:
print('Path {} exists! and not resuming'.format(args.logDir))
return
if not os.path.exists(args.logDir): os.makedirs(args.logDir)
# Log training parameters
with open(os.path.join(args.logDir, "arguments.txt"), "a") as f:
f.write(str(args))
normMean = [0.49139968, 0.48215827, 0.44653124]
normStd = [0.24703233, 0.24348505, 0.26158768]
normTransform = transforms.Normalize(normMean, normStd)
trainTransform = transforms.Compose([
transforms.Resize(args.imageSize),
transforms.RandomCrop(args.cropSize),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normTransform
])
testTransform = transforms.Compose([
transforms.Resize(args.imageSize),
transforms.CenterCrop(args.cropSize),
transforms.ToTensor(), normTransform
])
# Load data for training.
trainData, valData = data_loader.loadData(args, trainTransform,
testTransform)
# Prepare data loaders.
trainLoader = DataLoader(trainData,
batch_size=args.batchSize,
shuffle=True,
pin_memory=True,
num_workers=6)
testLoader = DataLoader(valData,
batch_size=args.batchSize,
shuffle=False,
pin_memory=False,
num_workers=4)
# Prepare model.
print('\nPreparing model...')
net = model.CocoMultilabelModel(args, trainData.numCategories())
net = nn.DataParallel(net).cuda()
# print('model summary:...')
# print(net)
best_error = 10000
if args.resume:
trainF = open(os.path.join(args.logDir, 'train.csv'), 'a')
accuracyF = open(os.path.join(args.logDir, 'accuracy.csv'), 'a')
testF = open(os.path.join(args.logDir, 'test.csv'), 'a')
if os.path.isfile(os.path.join(args.logDir, 'checkpoint.pth.tar')):
checkpoint = torch.load(
os.path.join(args.logDir, 'checkpoint.pth.tar'))
args.startEpoch = checkpoint['epoch']
best_error = checkpoint['error']
net.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint (epoch {})".format(
checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
else:
trainF = open(os.path.join(args.logDir, 'train.csv'), 'w')
accuracyF = open(os.path.join(args.logDir, 'accuracy.csv'), 'w')
testF = open(os.path.join(args.logDir, 'test.csv'), 'w')
labelWeights = trainData.getLabelWeights()
criterion = nn.BCELoss(weight=torch.FloatTensor(labelWeights).cuda(),
size_average=True)
cudnn.benchmark = True
def get_trainable_parameters(model):
for param in model.parameters():
if param.requires_grad:
yield param
optimizer = optim.SGD(get_trainable_parameters(net),
lr=args.learningRate,
momentum=0.9,
weight_decay=1e-4)
for epoch in range(args.startEpoch, args.nEpochs + 1):
train(args, epoch, net, criterion, trainLoader, optimizer, trainF,
accuracyF)
error = test(args, epoch, net, criterion, testLoader, optimizer, testF,
accuracyF)
is_best = error < best_error
best_error = min(error, best_error)
save_checkpoint(args, {
'epoch': epoch + 1,
'state_dict': net.state_dict(),
'error': error
}, is_best, os.path.join(args.logDir, 'checkpoint.pth.tar'))
os.system('python plot.py {} &'.format(args.logDir))
trainF.close()
testF.close()
accuracyF.close()
import data_loader
from helper_functions import *
patents, cutoffs, references, max_pat_id = data_loader.loadData()
seed_year = 1998
data = {}
while seed_year > 1975:
deltas = []
for diff in range(1, seed_year - 1974):
tran_year = seed_year - diff
seed_year_beg = cutoffs[seed_year]
seed_year_end = cutoffs[seed_year + 1]
tran_year_beg = cutoffs[tran_year]
tran_year_end = cutoffs[tran_year + 1]
seed_year_val = 0
tran_year_val = 0
init_val = 1
for reference in references:
pat_id = reference[0]
refs = reference[1]
if pat_id >= seed_year_beg and pat_id < seed_year_end:
seed_year_val += init_val
tran_val = float(init_val) / patents[pat_id]["deg"]
for ref_pat_id in refs:
if ref_pat_id >= tran_year_beg and ref_pat_id < tran_year_end:
tran_year_val += tran_val
elif pat_id < seed_year_beg: