def get_validation_split(data_file, data_split=0.8, overwrite=False):
if overwrite or not os.path.exists(config["training_file"]):
print("Creating validation split...")
nb_samples = data_file.root.data.shape[0]
sample_list = range(nb_samples)
training_list, testing_list = split_list(sample_list, split=data_split)
pickle_dump(training_list, config["training_file"])
pickle_dump(testing_list, config["testing_file"])
return training_list, testing_list
else:
print("Loading previous validation split...")
return pickle_load(config["training_file"]), pickle_load(
config["testing_file"])
def _file2nnet(layers, set_layer_num = -1, filename='nnet.in', activation='sigmoid', withfinal=True, factor=1.0, gradients=False, factors=None):
logger = logging.getLogger(__name__)
logger.info("Loading "+filename)
# if is KALDI binary
if fileIsBinary(filename):
print "Warning dropout factors ignored here"
nnet = file2nnet_binary(filename)
n_layers = len(nnet)
if set_layer_num == -1:
set_layer_num = n_layers - 1
for i in xrange(set_layer_num):
layers[i].params[0].set_value(factor * nnet[i]["weights"].astype(dtype=theano.config.floatX))
layers[i].params[1].set_value(nnet[i]["bias"].astype(dtype=theano.config.floatX))
if withfinal:
#print nnet[-1]["weights"][0][0:10]
layers[-1].params[0].set_value(nnet[-1]["weights"].astype(dtype=theano.config.floatX))
layers[-1].params[1].set_value(nnet[-1]["bias"].astype(dtype=theano.config.floatX))
return
# else, it's pdnn format
n_layers = len(layers)
if factors is None:
factors = [1.0 for l in layers]
if len(factors) != n_layers:
raise Exception("number of factors does not equal number of hidden + softmax")
nnet_dict = {}
if set_layer_num == -1:
set_layer_num = n_layers - 1
nnet_dict = utils.pickle_load(filename)
for i in xrange(set_layer_num):
logger.info("Loading hidden layer "+str(i))
dict_key = str(i) + ' ' + activation + ' W'
layers[i].params[0].set_value(factors[i] * factor * np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = str(i) + ' ' + activation + ' b'
layers[i].params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if gradients:
dict_key = str(i) + ' ' + activation + ' dW'
layers[i].delta_params[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = str(i) + ' ' + activation + ' db'
layers[i].delta_params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
else:
zero(layers[i].delta_params[0])
zero(layers[i].delta_params[1])
dict_key = str(i) + ' ' + activation + ' W_carry'
if layers[i].kahan and dict_key in nnet_dict:
logger.info("Loading hidden kahan")
dict_key = str(i) + ' ' + activation + ' W_carry'
layers[i].params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = str(i) + ' ' + activation + ' b_carry'
layers[i].params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = str(i) + ' ' + activation + ' dW_carry'
#layers[i].delta_params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = str(i) + ' ' + activation + ' db_carry'
#layers[i].delta_params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if layers[i].sync:
layers[i].params_sync[0].set_value(layers[i].params[0].get_value().astype('float32'))
layers[i].params_sync[1].set_value(layers[i].params[1].get_value().astype('float32'))
logger.info("Copy params to sync")
if withfinal:
logger.info("Loading final layer ")
dict_key = 'logreg W'
layers[-1].params[0].set_value(factors[-1] * np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = 'logreg b'
layers[-1].params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if gradients:
dict_key = 'logreg dW'
layers[-1].delta_params[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = 'logreg db'
layers[-1].delta_params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
else:
zero(layers[-1].delta_params[0])
zero(layers[-1].delta_params[1])
dict_key = 'logreg W_carry'
if layers[-1].kahan and dict_key in nnet_dict:
logger.info("Loading softmax kahan")
dict_key = 'logreg W_carry'
layers[-1].params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = 'logreg b_carry'
layers[-1].params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = 'logreg dW_carry'
#layers[-1].delta_params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = 'logreg db_carry'
#layers[-1].delta_params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if layers[-1].sync:
layers[-1].params_sync[0].set_value(layers[-1].params[0].get_value().astype('float32'))
layers[-1].params_sync[1].set_value(layers[-1].params[1].get_value().astype('float32'))
logger.info("Copy softmax params to sync")
if gradients:
logger.info("Loading gradients")
else:
logger.info("Zero-ing gradients")
def _nnet2kaldi_main(nnet_spec, set_layer_num = -1, filein='nnet.in',
fileout='nnet.out', activation='sigmoid', withfinal=True, maxout=False):
elements = nnet_spec.split(':')
layers = []
for x in elements:
layers.append(int(x))
if set_layer_num == -1:
layer_num = len(layers) - 1
else:
layer_num = set_layer_num + 1
nnet_dict = {}
nnet_dict = utils.pickle_load(filein)
fout = open(fileout, 'wb')
for i in xrange(layer_num - 1):
input_size = int(layers[i])
if maxout:
output_size = int(layers[i + 1]) * pool_size
else:
output_size = int(layers[i + 1])
W_layer = []
b_layer = ''
for rowX in xrange(output_size):
W_layer.append('')
dict_key = str(i) + ' ' + activation + ' W'
matrix = string_2_array(nnet_dict[dict_key])
for x in xrange(input_size):
for t in xrange(output_size):
W_layer[t] = W_layer[t] + str(matrix[x][t]) + ' '
dict_key = str(i) + ' ' + activation + ' b'
vector = string_2_array(nnet_dict[dict_key])
for x in xrange(output_size):
b_layer = b_layer + str(vector[x]) + ' '
fout.write('<affinetransform> ' + str(output_size) + ' ' + str(input_size) + '\n')
fout.write('[' + '\n')
for x in xrange(output_size):
fout.write(W_layer[x].strip() + '\n')
fout.write(']' + '\n')
fout.write('[ ' + b_layer.strip() + ' ]' + '\n')
if maxout:
fout.write('<maxout> ' + str(int(layers[i + 1])) + ' ' + str(output_size) + '\n')
else:
fout.write('<sigmoid> ' + str(output_size) + ' ' + str(output_size) + '\n')
if withfinal:
input_size = int(layers[-2])
output_size = int(layers[-1])
W_layer = []
b_layer = ''
for rowX in xrange(output_size):
W_layer.append('')
dict_key = 'logreg W'
matrix = string_2_array(nnet_dict[dict_key])
for x in xrange(input_size):
for t in xrange(output_size):
W_layer[t] = W_layer[t] + str(matrix[x][t]) + ' '
dict_key = 'logreg b'
vector = string_2_array(nnet_dict[dict_key])
for x in xrange(output_size):
b_layer = b_layer + str(vector[x]) + ' '
fout.write('<affinetransform> ' + str(output_size) + ' ' + str(input_size) + '\n')
fout.write('[' + '\n')
for x in xrange(output_size):
fout.write(W_layer[x].strip() + '\n')
fout.write(']' + '\n')
fout.write('[ ' + b_layer.strip() + ' ]' + '\n')
fout.write('<softmax> ' + str(output_size) + ' ' + str(output_size) + '\n')
fout.close();
def _nnet2kaldi_main(nnet_spec,
set_layer_num=-1,
filein='nnet.in',
fileout='nnet.out',
activation='sigmoid',
withfinal=True,
maxout=False):
elements = nnet_spec.split(':')
layers = []
for x in elements:
layers.append(int(x))
if set_layer_num == -1:
layer_num = len(layers) - 1
else:
layer_num = set_layer_num + 1
nnet_dict = {}
nnet_dict = utils.pickle_load(filein)
fout = open(fileout, 'wb')
for i in xrange(layer_num - 1):
input_size = int(layers[i])
if maxout:
output_size = int(layers[i + 1]) * pool_size
else:
output_size = int(layers[i + 1])
W_layer = []
b_layer = ''
for rowX in xrange(output_size):
W_layer.append('')
dict_key = str(i) + ' ' + activation + ' W'
matrix = string_2_array(nnet_dict[dict_key])
for x in xrange(input_size):
for t in xrange(output_size):
W_layer[t] = W_layer[t] + str(matrix[x][t]) + ' '
dict_key = str(i) + ' ' + activation + ' b'
vector = string_2_array(nnet_dict[dict_key])
for x in xrange(output_size):
b_layer = b_layer + str(vector[x]) + ' '
fout.write('<affinetransform> ' + str(output_size) + ' ' +
str(input_size) + '\n')
fout.write('[' + '\n')
for x in xrange(output_size):
fout.write(W_layer[x].strip() + '\n')
fout.write(']' + '\n')
fout.write('[ ' + b_layer.strip() + ' ]' + '\n')
if maxout:
fout.write('<maxout> ' + str(int(layers[i + 1])) + ' ' +
str(output_size) + '\n')
else:
fout.write('<sigmoid> ' + str(output_size) + ' ' +
str(output_size) + '\n')
if withfinal:
input_size = int(layers[-2])
output_size = int(layers[-1])
W_layer = []
b_layer = ''
for rowX in xrange(output_size):
W_layer.append('')
dict_key = 'logreg W'
matrix = string_2_array(nnet_dict[dict_key])
for x in xrange(input_size):
for t in xrange(output_size):
W_layer[t] = W_layer[t] + str(matrix[x][t]) + ' '
dict_key = 'logreg b'
vector = string_2_array(nnet_dict[dict_key])
for x in xrange(output_size):
b_layer = b_layer + str(vector[x]) + ' '
fout.write('<affinetransform> ' + str(output_size) + ' ' +
str(input_size) + '\n')
fout.write('[' + '\n')
for x in xrange(output_size):
fout.write(W_layer[x].strip() + '\n')
fout.write(']' + '\n')
fout.write('[ ' + b_layer.strip() + ' ]' + '\n')
fout.write('<softmax> ' + str(output_size) + ' ' + str(output_size) +
'\n')
fout.close()
def _file2nnet(layers, set_layer_num = -1, filename='nnet.in', activation='sigmoid', withfinal=True, factor=1.0, gradients=False, factors=None):
logger = logging.getLogger(__name__)
logger.info("Loading "+filename)
# if is KALDI binary
if fileIsBinary(filename):
print("Warning dropout factors ignored here")
nnet = file2nnet_binary(filename)
n_layers = len(nnet)
if set_layer_num == -1:
set_layer_num = n_layers - 1
for i in xrange(set_layer_num):
layers[i].params[0].set_value(factor * nnet[i]["weights"].astype(dtype=theano.config.floatX))
layers[i].params[1].set_value(nnet[i]["bias"].astype(dtype=theano.config.floatX))
if withfinal:
#print(nnet[-1]["weights"][0][0:10])
layers[-1].params[0].set_value(nnet[-1]["weights"].astype(dtype=theano.config.floatX))
layers[-1].params[1].set_value(nnet[-1]["bias"].astype(dtype=theano.config.floatX))
return
# else, it's pdnn format
n_layers = len(layers)
if factors is None:
factors = [1.0 for l in layers]
if len(factors) != n_layers:
raise Exception("number of factors does not equal number of hidden + softmax")
nnet_dict = {}
if set_layer_num == -1:
set_layer_num = n_layers - 1
nnet_dict = utils.pickle_load(filename)
for i in xrange(set_layer_num):
logger.info("Loading hidden layer "+str(i))
dict_key = str(i) + ' ' + activation + ' W'
layers[i].params[0].set_value(factors[i] * factor * np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = str(i) + ' ' + activation + ' b'
layers[i].params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if gradients:
dict_key = str(i) + ' ' + activation + ' dW'
layers[i].delta_params[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = str(i) + ' ' + activation + ' db'
layers[i].delta_params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
else:
zero(layers[i].delta_params[0])
zero(layers[i].delta_params[1])
dict_key = str(i) + ' ' + activation + ' W_carry'
if layers[i].kahan and dict_key in nnet_dict:
logger.info("Loading hidden kahan")
dict_key = str(i) + ' ' + activation + ' W_carry'
layers[i].params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = str(i) + ' ' + activation + ' b_carry'
layers[i].params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = str(i) + ' ' + activation + ' dW_carry'
#layers[i].delta_params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = str(i) + ' ' + activation + ' db_carry'
#layers[i].delta_params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if layers[i].sync:
layers[i].params_sync[0].set_value(layers[i].params[0].get_value().astype('float32'))
layers[i].params_sync[1].set_value(layers[i].params[1].get_value().astype('float32'))
logger.info("Copy params to sync")
if withfinal:
logger.info("Loading final layer ")
dict_key = 'logreg W'
layers[-1].params[0].set_value(factors[-1] * np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = 'logreg b'
layers[-1].params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if gradients:
dict_key = 'logreg dW'
layers[-1].delta_params[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = 'logreg db'
layers[-1].delta_params[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
else:
zero(layers[-1].delta_params[0])
zero(layers[-1].delta_params[1])
dict_key = 'logreg W_carry'
if layers[-1].kahan and dict_key in nnet_dict:
logger.info("Loading softmax kahan")
dict_key = 'logreg W_carry'
layers[-1].params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
dict_key = 'logreg b_carry'
layers[-1].params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = 'logreg dW_carry'
#layers[-1].delta_params_carry[0].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
#dict_key = 'logreg db_carry'
#layers[-1].delta_params_carry[1].set_value(np.asarray(string_2_array(nnet_dict[dict_key]), dtype=theano.config.floatX))
if layers[-1].sync:
layers[-1].params_sync[0].set_value(layers[-1].params[0].get_value().astype('float32'))
layers[-1].params_sync[1].set_value(layers[-1].params[1].get_value().astype('float32'))
logger.info("Copy softmax params to sync")
if gradients:
logger.info("Loading gradients")
else:
logger.info("Zero-ing gradients")
def main():
np.set_printoptions(precision=2, linewidth=128, suppress=True)
path = 'test'
config.device = torch.device('cuda:1')
config.set_device(-1)
model = Model('model_201912080009')
model.restore()
files = os.listdir('gen/%s/' % path)
files.sort(key=lambda k: k.split('_')[0], reverse=True)
# print(files[-1])
file = np.random.choice(files[:100])
# file = '201912101326_85d94af6fe1a588b.pkl'
print(file)
data = pickle_load('gen/%s/%s' % (path, file))
# data = pickle_load('gen/test/' + files[-2])
# np.random.shuffle(data)
player = 2
init, actions, _v = [None, [], -1.0]
init = [[2, 1, 2, 1, 0, 1, 3, 1, 2, 1, 0, 1, 2, 0, 0],
[2, 1, 1, 2, 1, 1, 0, 3, 1, 2, 0, 2, 0, 0, 1],
[0, 1, 1, 1, 3, 2, 0, 0, 1, 1, 3, 1, 2, 1, 0]]
actions = [
352, 352, 353, 338, 343, 347, 123, 0, 0, 20, 22, 23, 24, 26, 0, 28, 0,
29, 0, 0, 39, 0, 0, 116, 0, 0, 76, 324, 0, 0, 41, 42, 0, 0, 92, 317,
320, 0, 0, 31, 42, 0, 0, 15, 18
]
init = np.array(init, dtype=np.int32)
# actions = [353, 352, 352, 339, 349, 349, 15]
# init = [[2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0],
# [2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0],
# [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4, 4, 4, 1, 1]]
# init = np.array(init, dtype=np.int32)
# actions = [353, 352, 352, 344, 345, 346, 151]
# init, actions, _v = data[player]
print(_v, player)
print(init)
print(actions)
print('=============================================')
print('player:', player)
histories = unpack(init, actions, player)
histories, lengths = history_regularize(histories)
histories, lengths = to_cuda(histories, lengths)
vs, ps, _ = model(histories, lengths, None)
env = GameEnv(False)
env.load(init)
game = Game(env, player)
for v, p, action in zip(vs, ps, actions):
print('----------------------------------')
print('my_player: %d, curr_player: %d' % (player, game.curr_player()))
# for action, _dist in enumerate(dist):
# print(action, _dist)
idx = np.argsort(p)[::-1]
for i in range(8):
print(game.could_move(idx[i]), end=' ')
print('(%d, %.2f%%)' % (idx[i], p[idx[i]] * 100), end='\n')
print('action: %d, %.2f%%' % (action, p[action] * 100))
if idx[0] == 60 and p[idx[0]] > 0.3:
print(game)
print(game.policy())
print(game.hand_cards_num())
print(game.bottom())
print(game.curr_player(), game.lord_player())
return 0
# model_input = game.to_model_input()
# for channel in range(26, 28):
# print(channel)
# print(model_input[channel])
print('%.1f, %.3f' % (_v, v[0]))
game.move(action)
print(game)
print('Gauss:', game.gauss())
def get_test_indices():
return pickle_load(config["testing_file"])
