def main():
parser = argparse.ArgumentParser()
parser.add_argument('--no-cuda', action='store_true')
parser.add_argument('--nTrials', type=int, default=5)
# parser.add_argument('--boardSz', type=int, default=2)
# parser.add_argument('--batchSz', type=int, default=150)
parser.add_argument('--Qpenalty', type=float, default=0.1)
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
setproctitle.setproctitle('bamos.sudoku.prof-sparse')
print('=== nTrials: {}'.format(args.nTrials))
print('| {:8s} | {:8s} | {:21s} | {:21s} |'.format(
'boardSz', 'batchSz', 'dense forward (s)', 'sparse forward (s)'))
for boardSz in [2,3]:
with open('data/{}/features.pt'.format(boardSz), 'rb') as f:
X = torch.load(f)
with open('data/{}/labels.pt'.format(boardSz), 'rb') as f:
Y = torch.load(f)
N, nFeatures = X.size(0), int(np.prod(X.size()[1:]))
for batchSz in [1, 64, 128]:
dmodel = models.OptNetEq(boardSz, args.Qpenalty, trueInit=True)
spmodel = models.SpOptNetEq(boardSz, args.Qpenalty, trueInit=True)
if args.cuda:
dmodel = dmodel.cuda()
spmodel = spmodel.cuda()
dtimes = []
sptimes = []
for i in range(args.nTrials):
Xbatch = Variable(X[i*batchSz:(i+1)*batchSz])
Ybatch = Variable(Y[i*batchSz:(i+1)*batchSz])
if args.cuda:
Xbatch = Xbatch.cuda()
Ybatch = Ybatch.cuda()
# Make sure buffers are initialized.
# dmodel(Xbatch)
# spmodel(Xbatch)
start = time.time()
# dmodel(Xbatch)
dtimes.append(time.time()-start)
start = time.time()
spmodel(Xbatch)
sptimes.append(time.time()-start)
print('| {:8d} | {:8d} | {:.2e} +/- {:.2e} | {:.2e} +/- {:.2e} |'.format(
boardSz, batchSz, np.mean(dtimes), np.std(dtimes),
np.mean(sptimes), np.std(sptimes)))
def get_net(args):
if args.model == 'densenet':
net = densenet.DenseNet(growthRate=12,
depth=100,
reduction=0.5,
bottleneck=True,
nClasses=10)
elif args.model == 'lenet':
net = models.Lenet(args.nHidden, 10, args.proj)
elif args.model == 'lenet-optnet':
net = models.LenetOptNet(args.nHidden, args.nineq)
elif args.model == 'fc':
net = models.FC(args.nHidden, args.bn)
elif args.model == 'optnet':
net = models.OptNet(28 * 28, args.nHidden, 10, args.bn, args.nineq)
elif args.model == 'optnet-eq':
net = models.OptNetEq(28 * 28, args.nHidden, 10, args.neq)
else:
assert (False)
return net
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--no-cuda', action='store_true')
parser.add_argument('--boardSz', type=int, default=2)
parser.add_argument('--batchSz', type=int, default=150)
parser.add_argument('--testBatchSz', type=int, default=200)
parser.add_argument('--nEpoch', type=int, default=100)
parser.add_argument('--testPct', type=float, default=0.1)
parser.add_argument('--save', type=str)
parser.add_argument('--work', type=str, default='work')
subparsers = parser.add_subparsers(dest='model')
subparsers.required = True
fcP = subparsers.add_parser('fc')
fcP.add_argument('--nHidden', type=int, nargs='+', default=[100, 100])
fcP.add_argument('--bn', action='store_true')
convP = subparsers.add_parser('conv')
convP.add_argument('--nHidden', type=int, default=50)
convP.add_argument('--bn', action='store_true')
spOptnetEqP = subparsers.add_parser('spOptnetEq')
spOptnetEqP.add_argument('--Qpenalty', type=float, default=0.1)
optnetEqP = subparsers.add_parser('optnetEq')
optnetEqP.add_argument('--Qpenalty', type=float, default=0.1)
optnetIneqP = subparsers.add_parser('optnetIneq')
optnetIneqP.add_argument('--Qpenalty', type=float, default=0.1)
optnetIneqP.add_argument('--nineq', type=int, default=100)
optnetLatent = subparsers.add_parser('optnetLatent')
optnetLatent.add_argument('--Qpenalty', type=float, default=0.1)
optnetLatent.add_argument('--nLatent', type=int, default=100)
optnetLatent.add_argument('--nineq', type=int, default=100)
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
t = '{}.{}'.format(args.boardSz, args.model)
if args.model == 'optnetEq' or args.model == 'spOptnetEq':
t += '.Qpenalty={}'.format(args.Qpenalty)
elif args.model == 'optnetIneq':
t += '.Qpenalty={}'.format(args.Qpenalty)
t += '.nineq={}'.format(args.nineq)
elif args.model == 'optnetLatent':
t += '.Qpenalty={}'.format(args.Qpenalty)
t += '.nLatent={}'.format(args.nLatent)
t += '.nineq={}'.format(args.nineq)
elif args.model == 'fc':
t += '.nHidden:{}'.format(','.join([str(x) for x in args.nHidden]))
if args.bn:
t += '.bn'
if args.save is None:
args.save = os.path.join(args.work, t)
setproctitle.setproctitle('bamos.sudoku.' + t)
with open('data/{}/features.pt'.format(args.boardSz), 'rb') as f:
X = torch.load(f)
with open('data/{}/labels.pt'.format(args.boardSz), 'rb') as f:
Y = torch.load(f)
N, nFeatures = X.size(0), int(np.prod(X.size()[1:]))
nTrain = int(N * (1. - args.testPct))
nTest = N - nTrain
trainX = X[:nTrain]
trainY = Y[:nTrain]
testX = X[nTrain:]
testY = Y[nTrain:]
assert (nTrain % args.batchSz == 0)
assert (nTest % args.testBatchSz == 0)
save = args.save
if os.path.isdir(save):
shutil.rmtree(save)
os.makedirs(save)
npr.seed(1)
print_header('Building model')
if args.model == 'fc':
nHidden = args.nHidden
model = models.FC(nFeatures, nHidden, args.bn)
if args.model == 'conv':
model = models.Conv(args.boardSz)
elif args.model == 'optnetEq':
model = models.OptNetEq(args.boardSz, args.Qpenalty, trueInit=False)
elif args.model == 'spOptnetEq':
model = models.SpOptNetEq(args.boardSz, args.Qpenalty, trueInit=False)
elif args.model == 'optnetIneq':
model = models.OptNetIneq(args.boardSz, args.Qpenalty, args.nineq)
elif args.model == 'optnetLatent':
model = models.OptNetLatent(args.boardSz, args.Qpenalty, args.nLatent,
args.nineq)
else:
assert False
if args.cuda:
model = model.cuda()
fields = ['epoch', 'loss', 'err']
trainF = open(os.path.join(save, 'train.csv'), 'w')
trainW = csv.writer(trainF)
trainW.writerow(fields)
trainF.flush()
fields = ['epoch', 'loss', 'err']
testF = open(os.path.join(save, 'test.csv'), 'w')
testW = csv.writer(testF)
testW.writerow(fields)
testF.flush()
if 'optnet' in args.model:
# if args.tvInit: lr = 1e-4
# elif args.learnD: lr = 1e-2
# else: lr = 1e-3
lr = 1e-1
else:
lr = 1e-3
optimizer = optim.Adam(model.parameters(), lr=lr)
# writeParams(args, model, 'init')
test(args, 0, model, testF, testW, testX, testY)
for epoch in range(1, args.nEpoch + 1):
# update_lr(optimizer, epoch)
train(args, epoch, model, trainF, trainW, trainX, trainY, optimizer)
test(args, epoch, model, testF, testW, testX, testY)
torch.save(model, os.path.join(args.save, 'latest.pth'))
# writeParams(args, model, 'latest')
os.system('./plot.py "{}" &'.format(args.save))
ranges = {2: np.linspace(0.1, 2.0, num=11), 3: np.linspace(0.1, 1.0, num=10)}
for i in range(nBatches):
nSeen = (i + 1) * batchSz
print('=== {} Boards Seen ==='.format(nSeen))
for boardSz in (2, 3):
unsolvedBoards, solvedBoards = boards[boardSz]
print('--- Board Sz: {} ---'.format(boardSz))
print('| {:15s} | {:15s} | {:15s} |'.format('Qpenalty',
'% Boards Wrong',
'# Blanks Wrong'))
for j, Qpenalty in enumerate(ranges[boardSz]):
model = models.OptNetEq(boardSz, Qpenalty, trueInit=True).cuda()
X_batch = unsolvedBoards[startIdx:startIdx + batchSz]
Y_batch = solvedBoards[startIdx:startIdx + batchSz]
preds = model(X_batch).data
err = computeErr(preds)
# nWrong is not an exact metric because a board might have multiple solutions.
predBoards = torch.max(preds, 3)[1].squeeze().view(batchSz, -1)
trueBoards = torch.max(Y_batch.data,
3)[1].squeeze().view(batchSz, -1)
nWrong = ((predBoards - trueBoards).abs().cpu().numpy() >
1e-7).sum(axis=1)
results_key = (boardSz, j)
if results_key not in results:
results_j = {'err': err, 'nWrong': nWrong}