def __init__(self, p1=None, p2=None, p3=None, p4=None):
"""
Initialize a game with given player types.
Possible player types:
'first': always moves first token
'last': always moves last token
'random': moves random token
'firstbeat': Beats other player if it can, otherwise moves first token
'lastbeat': Beats other player if it can, otherwise moves last token
:param p1: String describing player type
:type p1: str
:param p2: String describing player type
:type p2: str
:param p3: String describing player type
:type p3: str
:param p4: String describing player type
:type p4: str
"""
self.players = [
self.create_player(p, i) for i, p in enumerate((p1, p2, p3, p4))
if p is not None
]
self.game_running = True
self.p1, self.p2, self.p3, self.p4 = self.players
self.board = Board(self.players)
mprint("Starting game with {} players.".format(len(self.players)))
for player in self.players:
mprint("Player {index} is a {type}".format(
index=player.id, type=type(player).__name__))
# Start TF session (respecting OMP_NUM_THREADS)
nthr = os.getenv('OMP_NUM_THREADS')
if nthr is None:
sess = tf.Session()
else:
sess = tf.Session(config=tf.ConfigProto(
intra_op_parallelism_threads=int(nthr)))
sess.run(tf.global_variables_initializer())
########################################################################
# Load saved weights if any
if niter > 0:
mfn = wts+"/iter_%06d.model.npz" % niter
sfn = wts+"/iter_%06d.state.npz" % niter
ut.mprint("Restoring model from " + mfn )
ut.loadNet(mfn,model,sess)
ut.mprint("Restoring state from " + sfn )
ut.loadAdam(sfn,opt,model.weights,sess)
ut.mprint("Done!")
else:
# Load the last model in pretraining
wcard = os.path.dirname(wts)+"/pretrain/iter_*.model.npz"
lst=[(l,int(re.match('.*/.*_(\d+)',l).group(1))) for l in glob(wcard)]
mfn = max(lst, key=lambda x: x[1])[0]
ut.mprint("Start with pre-trained model " + mfn )
ut.loadNet(mfn,model,sess)
#########################################################################
# Main Training loop
'''
Exploring properties of the Kronecker product
'''
import numpy as np
from utils import mprint
a = np.random.randint(6, size=(3, 4))
b = np.random.randint(6, size=(2, 3))
mprint('a')
mprint('b')
def kronecker_prod(A, B):
'''
Kronecker multiplication for matrices A, B
'''
bigB = np.tile(B, A.shape)
bigA = np.repeat(np.repeat(A, B.shape[0], axis=0), B.shape[1], axis=1)
# Funny - below we use Hadamard product as well
return bigA * bigB
axb = kronecker_prod(a, b)
print '\n Kronecker Product axb = \n', axb
# For inverses need square full rank matrices
a2 = np.array([[1, 0], [1, 1]])
os.system('mkdir -p {}'.format(exp_dir))
# redirect stdout and stderr to log files
if prm.log_file:
sys.stdout = open(exp_dir + '/train.log', 'a')
sys.stderr = open(exp_dir + '/info.log', 'a')
# Check for saved weights & find iter
vsave = ut.ckpter(exp_dir + '/iter_*.vmodel.npz')
osave = ut.ckpter(exp_dir + '/iter_*.opt.npz')
vpath = lambda itr: '%s/iter_%07d.vmodel.npz' % (exp_dir, itr)
opath = lambda itr: '%s/iter_%07d.opt.npz' % (exp_dir, itr)
niter = vsave.iter
# Load annotations
ut.mprint("Loading annotations")
tbchr = ut.batcher(prm.trn_anns, prm.batch_size, niter)
vbchr = ut.batcher(prm.val_anns, prm.batch_size, niter)
ut.mprint("Done!")
#########################################################################
# Set up data fetch
camera_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
pts_xyz_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
pts_rgb_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
pts_sift_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
gt_depth_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
getfeed = lambda fps: \
dict([(ph,'data/'+fps[i,3]) for i,ph in enumerate(camera_fps)]+\
vlist = [f.rstrip('\n') for f in open('data/val.txt').readlines()]
ESIZE=len(tlist)//BSZ
VESIZE=len(vlist)//BSZ
# Setup save/restore
origiter = saver.iter
rs = np.random.RandomState(0)
if origiter > 0:
ut.loadNet(saver.latest,net,sess)
if os.path.isfile('wts/opt.npz'):
ut.loadAdam('wts/opt.npz',opt,net.weights,sess)
for k in range( (origiter+ESIZE-1) // ESIZE):
idx = rs.permutation(len(tlist))
ut.mprint("Restored to iteration %d" % origiter)
# Main Training Loop
niter = origiter
touts = 0.
while niter < MAXITER+1:
if niter % VALITER == 0:
vouts = 0.
for j in range(VALREP):
off = j % (len(vlist)%BSZ + 1)
for b in range(VESIZE):
blst = vlist[(b*BSZ+off):((b+1)*BSZ+off)]
outs = sess.run(vals,feed_dict=d.fdict(blst))
vouts = vouts + np.float32(outs)
prm.input_attr)
# redirect stdout and stderr to log files
if prm.log_file:
sys.stdout = open(exp_dir + '/train.log', 'a')
sys.stderr = open(exp_dir + '/info.log', 'a')
# Check for saved weights & find iter
csave = ut.ckpter(exp_dir + '/iter_*.cmodel.npz')
osave = ut.ckpter(exp_dir + '/iter_*.opt.npz')
cpath = lambda itr: '%s/iter_%07d.cmodel.npz' % (exp_dir, itr)
opath = lambda itr: '%s/iter_%07d.opt.npz' % (exp_dir, itr)
niter = csave.iter
# Load annotations
ut.mprint("Loading annotations")
tbchr = ut.batcher(prm.trn_anns, prm.batch_size, niter)
vbchr = ut.batcher(prm.val_anns, prm.batch_size, niter)
ut.mprint("Done!")
#########################################################################
# Set up data fetch
camera_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
pts_xyz_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
pts_rgb_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
pts_sift_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
gt_rgb_fps = [tf.placeholder(tf.string) for i in range(prm.batch_size)]
getfeed = lambda fps: \
dict([(ph,'data/'+fps[i,3]) for i,ph in enumerate(camera_fps)]+\
[(ph,'data/'+fps[i,0]) for i,ph in enumerate(pts_xyz_fps)]+\
d = data.dataset(BSZ)
cv = tf.reshape(d.cv, [-1, 3])
mu, v = tf.nn.moments(cv, [0])
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# Load Data File Names
tlist = [f.rstrip('\n') for f in open('data/train.txt').readlines()]
ESIZE = len(tlist) // BSZ
rs = np.random.RandomState(0)
mus, vs = [], []
# Loop through a bunch of batches
ut.mprint("Running forward")
niter = 0
while niter < MAXITER:
ut.mprint("Running iteration %d" % niter)
if niter % ESIZE == 0:
idx = rs.permutation(len(tlist))
blst = [tlist[idx[(niter % ESIZE) * BSZ + b]] for b in range(BSZ)]
mv, vv = sess.run([mu, v], feed_dict=d.fdict(blst))
mus.append(mv)
vs.append(vv)
niter = niter + 1
mus, vs = np.float32(np.stack(mus, 0)), np.float32(np.stack(vs, 0))
vs = np.mean(vs, 0) + np.var(mus, 0)
bnms = [[] for k in range(len(blyrs))]
bnms_ = [net.bnvals[blyrs[k] + '_m'] for k in range(len(blyrs))]
bnvs = [[] for k in range(len(blyrs))]
bnvs_ = [net.bnvals[blyrs[k] + '_v'] for k in range(len(blyrs))]
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# Load Data File Names
tlist = [f.rstrip('\n') for f in open('data/train.txt').readlines()]
ESIZE = len(tlist) // BSZ
rs = np.random.RandomState(0)
ut.loadNet(sys.argv[1], net, sess)
ut.mprint("Loaded weights from " + sys.argv[1])
# Loop through a bunch of batches
ut.mprint("Running forward")
niter = 0
while niter < MAXITER:
ut.mprint("Running iteration %d" % niter)
if niter % ESIZE == 0:
idx = rs.permutation(len(tlist))
blst = [tlist[idx[(niter % ESIZE) * BSZ + b]] for b in range(BSZ)]
ms, vs = sess.run([bnms_, bnvs_], feed_dict=d.fdict(blst))
for k in range(len(blyrs)):
bnms[k].append(ms[k])
bnvs[k].append(vs[k])