def naive_ai(board: Board, feature=None):
if feature is None:
feature = get_features(board)
score = lambda x: naive_score(x, board.current_player)
result = numpy.apply_along_axis(score, 2, feature) + gauss_noise(
10e-6, board.shape)
mask = (board.data == 0)
return numpy.unravel_index((result * mask).argmax(), board.shape)
def main():
lc_super_data = {}
for grade in valid_grades:
lc_super_data[grade] = {
'training': {
'data': [],
'targets': []
},
'testing': {
'data': [],
'targets': []
}
}
loans = storage.load_from_file(config.StorageFile.LC_LOAN_EXTENDED_DATA)
feature.print_feature_name_idx(loans[0])
for loan in loans:
if need_to_drop(loan):
continue
grade = loan['grade'].upper()
if loan['loanStatus'] in good_status_list:
target = 1
elif loan['loanStatus'] in bad_status_list:
target = 0
else:
raise Exception("bad loan status input: " + loan['loanStatus'])
features = feature.get_features(loan)
feature.validate(features)
if random.random() >= 0.1:
key = 'training'
else:
key = 'testing'
if target == 1:
if grade == 'A' and random.random() >= 0.301:
key = 'testing'
if grade == 'B' and random.random() >= 0.706:
key = 'testing'
if grade == 'C' and random.random() >= 0.5:
key = 'testing'
if grade == 'D' and random.random() >= 0.8:
key = 'testing'
if grade == 'E' and random.random() >= 0.8:
key = 'testing'
lc_super_data[grade][key]['data'].append(features)
lc_super_data[grade][key]['targets'].append(target)
print_training_data_stats(lc_super_data)
storage.save_to_file(lc_super_data, config.StorageFile.model_training_file)
print "Saved model training data to %s" % config.StorageFile.model_training_file
def ai_move(board: Board, feature=None, policy: str = "max"):
if board.turn == 1:
return naive_ai(board)
if feature is None:
feature = get_features(board)
score = lambda x: naive_score(x, board.current_player)
result = model_manager["reinforce"].predict(numpy.array(
[feature])).reshape(15, 15)
if policy != "sample":
result += numpy.apply_along_axis(score, 2, feature)
result = result * (board.data == 0)
result /= result.sum()
if policy == "max":
choice = numpy.unravel_index(result.argmax(), board.shape)
elif policy == "sample":
choice = numpy.unravel_index(
numpy.random.choice(225, p=result.flatten()), board.shape)
return choice
def setup_architecture(self):
expected_output = []
feature_vector = []
count = 0
for f in os.listdir(self.training_folder):
if count > 0:
break
if '.png' in f:
feature_vector = feature.get_features('train/'+f)
f = f.split('.')
f = f[0]
theline = linecache.getline('trainLabels.csv', int(f) + 1)
theline = theline.strip(' ')
theline = theline.strip('\n')
theline = theline.split(',')
theline = theline[1]
expected_output = self.get_expected_output(theline)
count += 1
self.input_layer = layers.InputLayer(len(feature_vector))
self.get_hidden_layers(self.hidden_layer_sizes)
self.output_layer = layers.OutputLayer(len(expected_output))
if len(self.hidden_layer_sizes) == 0:
self.input_layer.set_architecture(self.output_layer)
else:
self.input_layer.set_architecture(self.hidden_layers[0])
for i, hidden_layer in enumerate(self.hidden_layers):
prevLayer = None
nextLayer = None
if i == 0:
prevLayer = self.input_layer
else:
prevLayer = self.hidden_layers[i-1]
if i == len(self.hidden_layers) - 1:
nextLayer = self.output_layer
else:
nextLayer = self.hidden_layers[i+1]
hidden_layer.set_architecture(prevLayer, nextLayer)
self.output_layer.set_architecture(self.hidden_layers[-1])
def train(self):
count = 0
for f in os.listdir(self.training_folder):
count += 1
if count%100 == 0:
print count
if '.png' in f:
f = f.split('.')
f = f[0]
if int(f) < 30000:
feature_vector = feature.get_features('train/'+f+'.png')
theline = linecache.getline('trainLabels.csv', int(f) + 1)
theline = theline.strip(' ')
theline = theline.strip('\n')
theline = theline.split(',')
theline = theline[1]
expected_output = self.get_expected_output(theline)
self.input_layer.put_values(feature_vector)
for hidden_layer in self.hidden_layers:
hidden_layer.calc_neuron_vals()
self.output_layer.calc_neuron_vals()
self.output_layer.put_values(expected_output)
self.back_propagate()
def test(self):
for f in os.listdir(self.training_folder):
if '.png' in f:
f = f.split('.')
f = f[0]
if int(f) >= 30000:
feature_vector = feature.get_features('train/'+f + '.png')
theline = linecache.getline('trainLabels.csv', int(f) + 1)
theline = theline.strip(' ')
theline = theline.strip('\n')
theline = theline.split(',')
theline = theline[1]
expected_output = self.get_expected_output(theline)
self.input_layer.put_values(feature_vector)
for hidden_layer in self.hidden_layers:
hidden_layer.calc_neuron_vals()
self.output_layer.calc_neuron_vals()
self.output_layer.put_values(expected_output)
output = self.output_layer.get_output()
if output == theline:
self.p += 1
else:
self.f += 1
def main():
lc_super_data = {}
for grade in valid_grades:
lc_super_data[grade] = {
'training': {
'data': [],
'targets': []
},
'testing': {
'data': [],
'targets': []
}
}
train_data = storage.load_from_file(config.StorageFile.model_training_file)
for grade, lc_data in train_data.iteritems():
if not grade in valid_grades:
continue
for i in xrange(len(lc_data['testing']['targets'])):
if lc_data['testing']['targets'][i] == 0:
lc_super_data[grade]['testing']['targets'].append(0)
lc_super_data[grade]['testing']['data'].append(
lc_data['testing']['data'][i])
print_training_data_stats(lc_super_data)
loans = storage.load_from_file(config.StorageFile.LC_LOAN_EXTENDED_DATA)
feature.print_feature_name_idx(loans[0])
for loan in loans:
if need_to_drop(loan):
continue
grade = loan['grade'].upper()
if loan['loanStatus'] in good_status_list:
target = 1
elif loan['loanStatus'] in bad_status_list:
target = 0
else:
raise Exception("bad loan status input: " + loan['loanStatus'])
if target == 0:
raise Exception("Not possible")
features = feature.get_features(loan)
feature.validate(features)
if target == 1:
if grade == 'A' and random.random() >= 0.1:
continue
if grade == 'B' and random.random() >= 0.2:
continue
# if grade == 'C' and random.random() >= 0.05:
# continue
# if grade == 'D' and random.random() >= 0.1:
# continue
# if grade == 'E' and random.random() >= 0.1:
# continue
lc_super_data[grade]['testing']['data'].append(features)
lc_super_data[grade]['testing']['targets'].append(target)
print_training_data_stats(lc_super_data)
storage.save_to_file(lc_super_data,
config.StorageFile.model_evaluating_file)
print "Saved model training data to %s" % config.StorageFile.model_evaluating_file
def model_handler(features, labels, mode, params, config):
extractor = tf.make_template(
'extractor',
get_model(params),
create_scope_now_=True,
)
feature_fn = get_features(params)
model_input = features['data']
predictions = extractor(model_input, params,
mode == tf.estimator.ModeKeys.TRAIN)
if mode == tf.estimator.ModeKeys.TRAIN:
loss = tf.losses.absolute_difference(labels=labels,
predictions=predictions)
# some lr tuner, you could use move interesting functions
def learning_rate_decay_fn(learning_rate, global_step):
return tf.train.exponential_decay(learning_rate,
global_step,
decay_steps=5000,
decay_rate=0.97)
train_op = tf.contrib.layers.optimize_loss(
loss=loss,
global_step=tf.contrib.framework.get_global_step(),
learning_rate=params.learning_rate,
#optimizer=lambda lr: tf.train.MomentumOptimizer(lr, 0.9, use_nesterov=True),
optimizer='Adam',
#learning_rate_decay_fn=learning_rate_decay_fn,
clip_gradients=params.clip_gradients,
variables=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES))
specs = dict(
mode=mode,
loss=loss,
train_op=train_op,
)
if mode == tf.estimator.ModeKeys.EVAL:
loss = tf.losses.absolute_difference(labels=labels,
predictions=predictions)
specs = dict(
mode=mode,
loss=loss,
)
if mode == tf.estimator.ModeKeys.PREDICT:
predictions = {
'pred': predictions,
'target': features['target'],
'cur': features['cur'],
'future': features['future'],
'buy': features['buy'],
'sell': features['sell'],
}
specs = dict(
mode=mode,
predictions=predictions,
)
return tf.estimator.EstimatorSpec(**specs)
import data_loader
import feature
import adaboost
import numpy as np
import pickle
import matplotlib.pyplot as plt
import visulization
import metrics
import classifiers
import cascade
train_x, train_y, test_x, test_y = data_loader.load()
train_f, i_f = feature.get_features(train_x)
test_selection_index = np.concatenate(
[range(472),
np.random.choice(19572, 2000, replace=False) + 472])
test_x = test_x[test_selection_index]
test_y = test_y[test_selection_index]
try:
with open("classifier.pkl", "rb") as f:
classifier = pickle.load(f)
except:
classifier = adaboost.train(train_f, train_y, 10)
with open("classifier.pkl", "wb") as f:
pickle.dump(classifier, f, protocol=pickle.HIGHEST_PROTOCOL)
# 0.99, 0.4, 0.01
try:
with open("cascade.pkl", "rb") as f:
def expand(self, board: easyBoard): sz = board.board_size if self.is_root: features = get_features(board) result = policy_network.predict(np.array([features])).reshape(15, 15) * (board.data == 0) k_select = 5 k_argmax = self.kth(result, sz, k=k_select) #print(k_argmax) value_me = [] value_op = [] vme_max = -1 vop_max = -1 for k_pos in k_argmax: if k_pos[0] == -1 and k_pos[1] == -1: continue vme = self.check_win(board, k_pos, 3 - board.current_player) vop = self.check_win(board, k_pos, board.current_player) value_me.append(vme) value_op.append(vop) if vme > vme_max: vme_max = vme if vop > vop_max: vop_max = vop if vme_max >= vop_max: for i in range(k_select): if k_argmax[i][0] == -1 and k_argmax[i][1] == -1: continue if value_me[i] == vme_max: self.childs.append(mcts_node(False, self, tuple(k_argmax[i]))) if len(self.childs) == 3: break else: for i in range(k_select): if k_argmax[i][0] == -1 and k_argmax[i][1] == -1: continue if value_op[i] == vop_max: self.childs.append(mcts_node(False, self, tuple(k_argmax[i]))) if len(self.childs) == 3: break #print(k_argmax) #for k_pos in k_argmax: # self.childs.append(mcts_node(False, self, tuple(k_pos))) else: available = np.zeros((sz, sz), int) dirs = np.array([(-2, 0), (-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1), (2, 0)]) locations = [] for i in range(sz): for j in range(sz): if board.data[i][j] != 0: for dir in dirs: ask = (i, j) + dir if board.is_empty(ask): available[tuple(ask)] = 1 for i in range(sz): for j in range(sz): if available[i][j] == 1: locations.append((i, j)) random.shuffle(locations) for location in locations: self.childs.append(mcts_node(False, self, location))