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])