def calculate_territory(img_path, corners, predictor=Classifier()):
print(img_path, corners)
img = Image.open(img_path)
rect_img, homography, H = rectify_image(img, corners)
stones = extract_stones(rect_img)
predictions = [(x, y, predictor.predict(stone)) for stone, x, y in stones]
gf = build_gamefield(predictions)
area = fill_territory_onlinego(gf)
score = calc_score(area)
return gf, area, H.tolist(), score
def randomize_training_params(self):
"""
Creates classifier and network with randomized parameters
:return: None
"""
self.nn = Classifier()
self.nn.perc_train = random.choice(self.perc_train_values)
self.nn.batch_size = random.randint(*self.range_batch_size)
self.nn.learning_rate = random.choice(self.learning_rates)
self.nn.neurons_per_layer = [random.randint(*self.range_hidden_neuron)
for _ in range(random.randint(*self.range_hidden))]
self.nn.activation_h = random.choice(self.activations_names)
self.nn.regularization_type = random.choice(self.regularization_names)
self.nn.regularization_rate = random.choice(self.regularization_rates)
feature_ids = [DataSet.FEATURE_X1, DataSet.FEATURE_X2]
# select which input features to use
self.nn.features_ids = feature_ids
self.nn.build()
def randomize_training_params(self):
"""
Creates classifier and network with randomized parameters
:return: None
"""
self.nn = Classifier()
self.nn.perc_train = random.choice(self.perc_train_values)
self.nn.batch_size = random.randint(*self.range_batch_size)
self.nn.learning_rate = random.choice(self.learning_rates)
self.nn.neurons_per_layer = [
random.randint(*self.range_hidden_neuron)
for _ in range(random.randint(*self.range_hidden))
]
self.nn.activation_h = random.choice(Classifier.activations_names)
self.nn.regularization_type = random.choice(
Classifier.regularization_names)
self.nn.regularization_rate = random.choice(self.regularization_rates)
feature_ids = [i for i in range(DataSet.NUM_FEATURES)]
random.shuffle(feature_ids)
feature_ids = feature_ids[0:random.randint(1, len(feature_ids))]
feature_ids.sort()
self.nn.features_ids = feature_ids
self.nn.build()
def randomize_training_params(self):
"""
Creates classifier and network with randomized parameters
:return: None
"""
self.nn = Classifier()
self.nn.perc_train = random.choice(self.perc_train_values)
self.nn.batch_size = random.randint(*self.range_batch_size)
self.nn.learning_rate = random.choice(self.learning_rates)
self.nn.neurons_per_layer = [random.randint(*self.range_hidden_neuron)
for _ in range(random.randint(*self.range_hidden))]
self.nn.activation_h = random.choice(self.activations_names)
self.nn.regularization_type = random.choice(self.regularization_names)
self.nn.regularization_rate = random.choice(self.regularization_rates)
# select which input features to use
if self.fixed_feature_ids is not None:
self.nn.features_ids = self.feature_ids
else:
# random
feature_bits = random.randint(0, pow(2, DataSet.NUM_FEATURES))
self.nn.features_ids = [i for i in range(DataSet.NUM_FEATURES) if feature_bits & pow(2, i) != 0]
self.nn.build()
class Run():
num_samples = 500 # always a fixed number of data points
noise_values = [0]
perc_train_values = [60] # percentage of training to test
range_batch_size = [10,10]
learning_rates = [0.03]
regularization_rates = [0.0]
range_hidden = [2,2]
range_hidden_neuron = [4,4]
epochs_per_config = [950] # number of epochs to run each nnet configuration for
activations_names = [Classifier.ACTIVATION_TANH]
regularization_names = [Classifier.REGULARIZATION_NONE]
PARAM_TYPE_INT = 'int'
PARAM_TYPE_DOUBLE = 'double'
PARAM_TYPE_STR = 'string'
PARAM_TYPE_OUTPUT = 'output'
MODE_FULL = 'full' # a single directory, with randomized data for each run
MODE_PSA_RUNS = 'psa_runs' # a few randomized data, in separate directories
fixed_noise = 0
# mode_psa_datasets = DataSet.all_data_names
mode_psa_datasets = [DataSet.DATA_GAUSS] # debug
def __init__(self):
self.data = None
self.nn = None
def randomize_data(self, dataset_name=None, noise=None):
"""
Build dataset with randomized parameters
:param dataset_name: dataset name. if None, will randomize
:param noise: noise [0 .. 50]. if None will randomly pick
:return: None
"""
# dataset parameters
dataset_name = random.choice(DataSet.all_data_names) if dataset_name is None else dataset_name
noise = random.choice(self.noise_values) if noise is None else noise
self.data = DataSet(dataset_name, self.num_samples, noise)
def randomize_training_params(self):
"""
Creates classifier and network with randomized parameters
:return: None
"""
self.nn = Classifier()
self.nn.perc_train = random.choice(self.perc_train_values)
self.nn.batch_size = random.randint(*self.range_batch_size)
self.nn.learning_rate = random.choice(self.learning_rates)
self.nn.neurons_per_layer = [random.randint(*self.range_hidden_neuron)
for _ in range(random.randint(*self.range_hidden))]
self.nn.activation_h = random.choice(self.activations_names)
self.nn.regularization_type = random.choice(self.regularization_names)
self.nn.regularization_rate = random.choice(self.regularization_rates)
feature_ids = [DataSet.FEATURE_X1, DataSet.FEATURE_X2]
# select which input features to use
self.nn.features_ids = feature_ids
self.nn.build()
@staticmethod
def param_info_header():
return ['label', 'name', 'type', 'info']
def param_info(self):
max_hidden = self.range_hidden[1]
return ([['data', 'Data', self.PARAM_TYPE_STR, 'Which dataset do you want to use?'],
['noise', 'Noise', self.PARAM_TYPE_INT, 'Noise'],
['training_ratio', 'Training Ratio', self.PARAM_TYPE_INT, 'Ratio of training to test data'],
['batch_size', 'Batch Size', self.PARAM_TYPE_INT, 'Batch Size']] +
[[f, f, self.PARAM_TYPE_INT, f] for f in DataSet.feature_idx_to_name] +
[['layer_count', 'Layers Count', self.PARAM_TYPE_INT, 'Number of hidden layers'],
['neuron_count', 'Neurons Count', self.PARAM_TYPE_INT, 'Total number of neurons in hidden layers']] +
[['H'+str(i), 'H'+str(i), self.PARAM_TYPE_INT, 'H'+str(i)] for i in range(1, max_hidden + 1)] +
[['learning_rate', 'Learning rate', self.PARAM_TYPE_DOUBLE, 'Learning rate'],
['activation', 'Activation', self.PARAM_TYPE_STR, 'Activation'],
['regularization', 'Regularization', self.PARAM_TYPE_STR, 'Regularization'],
['regularization_rate', 'Regularization rate', self.PARAM_TYPE_DOUBLE, 'Regularization rate']])
def param_names(self):
"""
returns array of string names for the parameters. matching 1-to-1 with param_str
:return:
"""
info = self.param_info()
return [info[i][0] for i in range(len(info))]
def param_str(self):
"""
returns array of parameter values in string format. matching 1-to-1 to the param_names()
:return:
"""
layer_count = len(self.nn.neurons_per_layer)
max_hidden = self.range_hidden[1]
return ([self.data.dataset_name,
str(self.data.noise),
str(self.nn.perc_train),
str(self.nn.batch_size)] +
['1' if i in self.nn.features_ids else '0' for i in DataSet.all_features] +
[str(layer_count),
str(sum(self.nn.neurons_per_layer))] +
[str(self.nn.neurons_per_layer[i]) if i < layer_count else '0' for i in range(max_hidden)] +
[str(self.nn.learning_rate),
self.nn.activation_h,
self.nn.regularization_type,
str(self.nn.regularization_rate)])
def save_plot(self, filename):
"""
Generates the plot using the current data and training state
:param filename: output filename
:return: None
"""
colormap = colors.ListedColormap(["#f59322", "#e8eaeb", "#0877bd"])
x_min, x_max = -6, 5.5 # grid x bounds
y_min, y_max = -6, 5.5 # grid y bounds
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 900),
np.linspace(y_min, y_max, 900))
data_points = np.c_[xx.ravel(), yy.ravel()]
data_grid = DataSet(None, len(data_points), 0, data_points=data_points)
try:
z = self.nn.predict_labels(data_grid.features).reshape(xx.shape)
except:
z = np.zeros(np.shape(xx))
fig = plt.figure(figsize=(4, 4), dpi=175)
# plt.imshow(z, cmap=colormap, interpolation='nearest')
plt.contourf(xx, yy, z, cmap=colormap, alpha=0.8)
num_training = self.data.num_training(self.nn.perc_train)
point_color = self.data.labels
# plot training data points
plt.scatter(self.data.points[:num_training, 0], self.data.points[:num_training, 1],
c=point_color[:num_training], edgecolors='w', s=40, cmap=colormap)
# plot test data points
plt.scatter(self.data.points[num_training:, 0], self.data.points[num_training:, 1],
c=point_color[num_training:], edgecolors='k', s=30, cmap=colormap)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
fig.savefig(filename)
plt.close()
@staticmethod
def create_dir(dirname, clean=False):
"""
Creates the directory if doesn't exist
:param dirname: directory path
:param clean: whether to clean the directory
:return: None
"""
if clean:
shutil.rmtree(dirname, ignore_errors=True)
if not os.path.exists(dirname):
os.makedirs(dirname)
def save_current_run(self, filename):
try:
yp = self.nn.predict_labels(self.data.features)
except:
yp = 1 - self.data.labels
if Config.SAVE_LABELS_NEG_POS:
yp = [-1 if label == 0 else 1 for label in yp]
header = 'label_pred'
with open(filename, 'w') as f:
f.write(header + '\n')
for v in yp:
f.write(str(v) + '\n')
def calc_tpr_fpr(self):
"""
calculates the true positive rate and false positive rate
:return: [train_tpr, train_fpr, test_tpr, test_fpr]
"""
labels_pred = self.nn.predict_labels(self.data.features)
num_training = self.data.num_training(self.nn.perc_train)
stats = []
for population in ['train', 'test']:
if population == 'train':
y = self.data.labels[:num_training] # true labels for training
yp = labels_pred[:num_training] # predicted labels for training
else: # population == 'test'
y = self.data.labels[num_training:] # true labels for test
yp = labels_pred[num_training:] # predicted labels for test
num_p = list(y).count(1) # number of positive labels
num_n = list(y).count(0) # number of negative labels
num_tp = [l == 1 and lp == 1 for l, lp in zip(y, yp)].count(True) # true positives
num_fp = [l == 0 and lp == 1 for l, lp in zip(y, yp)].count(True) # false positives
# num_tn = [l == 0 and lp == 0 for l, lp in zip(y, yp)].count(True) # true positives
# num_fn = [l == 1 and lp == 0 for l, lp in zip(y, yp)].count(True) # true positives
tpr = 0 if num_tp == 0 else num_tp/num_p # true positive rate
fpr = 0 if num_fp == 0 else num_fp/num_n # false positive rate
# tnr = 0 if num_tn == 0 else num_tn/num_n # true negative rate
# fnr = 0 if num_fn == 0 else num_fn/num_p # false negative rate
stats = stats + [tpr, fpr]
return stats
def execute_runs(self, mode, num_runs, resume=False, test=False):
"""
Executes several training runs, each with different parameters and saves the results
:param mode: experiment mode.
MODE_FULL randomizes all parameters including the input data, per run
MODE_PSA_RUNS generates different datasets and runs the psa separately for each
:param num_runs: number of runs per experiment to add to the output
:param resume: whether to resume the runs. if True, the runs will continue until there are num_runs records.
:return:
"""
iter_index = -1
while True:
iter_index += 1
if mode == self.MODE_FULL:
if iter_index == 1:
break
out_dir = '../output/full'
self.create_dir(out_dir, clean=not resume)
curr_data = None
elif mode == self.MODE_PSA_RUNS:
if iter_index >= len(self.mode_psa_datasets):
break
noise = self.fixed_noise
dataset_name = self.mode_psa_datasets[iter_index]
out_dir = '../output/' + dataset_name + '_' + str(noise)
l = 0
check_folder = True
while check_folder is True:
if os.path.isdir(out_dir):
for l in range(0,100):
out_dir = '../output/' + 'eqml' + '_' + str(noise)\
+ '_' + str(l)
if not os.path.isdir(out_dir):
check_folder = False
break
self.create_dir(out_dir, clean=not resume)
if test is True:
input_filename = '../testdata/testml.txt'
else:
input_filename = 'data.txt'
if resume and os.path.exists(input_filename):
curr_data = DataSet.create_from_file(input_filename)
curr_data.noise = noise
curr_data.dataset_name = dataset_name
Run.num_samples = curr_data.num_samples()
assert(curr_data.num_samples() == Run.num_samples)
else:
print("Invalid mode:" + str(mode))
return
run_id = 0
index_filename = out_dir + '/runsInfo.txt'
print('index table: ' + index_filename)
if resume and os.path.exists(index_filename):
index_table = np.genfromtxt(index_filename, dtype=None, delimiter='\t', names=True, autostrip=False)
if len(index_table) > 0 and 'ID' in index_table.dtype.fields:
run_id = index_table['ID'][-1] + 1
print('Resuming from ID {}'.format(run_id))
write_header = (not os.path.exists(index_filename)) or (not resume)
# create write the header for the runs.txt file
f_runs = open(index_filename, 'a+' if resume else 'w+')
all_param_info = \
([['ID', 'ID', self.PARAM_TYPE_OUTPUT, 'ID'],
['imagePath', 'Image path', self.PARAM_TYPE_OUTPUT, 'Output image path']] +
self.param_info() +
[['epoch', 'Epoch', self.PARAM_TYPE_INT, 'Number of Epochs (of processing all training data)'],
['iteration', 'Iterations', self.PARAM_TYPE_INT, 'Number of Iterations (of processing a batch)'],
['success', 'Success', self.PARAM_TYPE_OUTPUT, 'Whether the training finished successfully'],
['total_time', 'Total time (ms)', self.PARAM_TYPE_OUTPUT, 'Total time at this epoch'],
['mean_time', 'Mean time (ms)', self.PARAM_TYPE_OUTPUT, 'Mean time per epoch'],
['train_loss', 'Training loss', self.PARAM_TYPE_OUTPUT, 'Training loss at epoch'],
['test_loss', 'Test loss', self.PARAM_TYPE_OUTPUT, 'Test loss at epoch'],
['train_TPR', 'TPR for train', self.PARAM_TYPE_OUTPUT, 'True positive rate for training data'],
['train_FPR', 'FPR for train', self.PARAM_TYPE_OUTPUT, 'False positive rate for training data'],
# ['train_TNR', 'TNR for train', self.PARAM_TYPE_OUTPUT, 'True negative rate for training data'],
# ['train_FNR', 'FNR for train', self.PARAM_TYPE_OUTPUT, 'False negative Rate for training data'],
['test_TPR', 'TPR for test', self.PARAM_TYPE_OUTPUT, 'True positive rate for test data'],
['test_FPR', 'FPR for test', self.PARAM_TYPE_OUTPUT, 'False positive rate for test data'],
# ['test_TNR', 'TNR for test', self.PARAM_TYPE_OUTPUT, 'True negative rate for test data'],
# ['test_FNR', 'FNR for test', self.PARAM_TYPE_OUTPUT, 'False negative Rate for test data'],
])
# save the paramInfo.txt
with open(out_dir + '/paramInfo.txt', 'w') as fpi:
fpi.write('\t'.join(self.param_info_header()) + '\n')
fpi.write('\n'.join(['\t'.join(i) for i in all_param_info]))
# write the header for the runs.txt
if write_header:
f_runs.write('\t'.join([i[0] for i in all_param_info]) + '\n')
f_runs.flush()
images_dir = out_dir + '/images'
runs_dir = out_dir + '/runs'
self.create_dir(images_dir, clean=not resume)
self.create_dir(runs_dir, clean=not resume)
while run_id < num_runs:
if curr_data is None:
self.data = curr_data # reuse the same data
else:
self.data = curr_data # reuse the same data
self.randomize_training_params()
# print the parameters
print('configuration (%d of %d)' % (int(run_id / len(self.epochs_per_config)) + 1,
int(num_runs / len(self.epochs_per_config))))
print(', '.join(a[0] + ': ' + a[1] for a in zip(self.param_names(), self.param_str())))
prev_step = 0
total_time = 0
for epoch in self.epochs_per_config:
curr_step = int(epoch * curr_data.num_samples() / self.nn.batch_size)
# curr_step = epoch # in the online demo epoch == iter: https://github.com/tensorflow/playground/blob/67cf64ffe1fc53967d1c979d26d30a4625d18310/src/playground.ts#L898
time_start = time.time()
# train the network
success = True
try:
train_loss, test_loss = self.nn.train(self.data, restart=False, num_steps=curr_step - prev_step)
except:
train_loss, test_loss = 1, 1
success = False
total_time += (time.time() - time_start) * 1000.0
mean_time = total_time / epoch
try:
train_tpr, train_fpr, test_tpr, test_fpr = self.calc_tpr_fpr()
except:
train_tpr, train_fpr, test_tpr, test_fpr = 0, 1, 0, 1
success = False
print('(epoch: %d, step: %d), '
'(total_time: %g, mean_time: %g), '
'(training loss: %g, test loss: %g), '
'(train_tpr: %g, train_fpr: %g test_tpr: %g, test_fpr: %g)' %
(epoch, curr_step,
round(total_time, 2), round(mean_time, 2),
round(train_loss, 2), round(test_loss, 2),
round(train_tpr, 2), round(train_fpr, 2), round(test_tpr, 2), round(test_fpr, 2)))
image_filename = images_dir + '/' + str(run_id) + ".png"
run_filename = runs_dir + '/' + str(run_id) + ".txt"
self.save_plot(image_filename)
self.save_current_run(run_filename)
f_runs.write('\t'.join(
[str(run_id),
image_filename[len(out_dir)+1:]] +
self.param_str() +
[str(epoch),
str(curr_step),
str(success),
str(round(total_time, 3)),
str(round(mean_time, 3)),
str(round(train_loss, 3)),
str(round(test_loss, 3)),
str(round(train_tpr, 3)),
str(round(train_fpr, 3)),
str(round(test_tpr, 3)),
str(round(test_fpr, 3)),
]) +
'\n')
f_runs.flush()
prev_step = curr_step
run_id += 1
if run_id >= num_runs:
break
f_runs.close()
from nn import Classifier
from flask import Flask, render_template, request
from flask_cors import CORS
import base64
import os
import numpy as np
app = Flask(__name__)
classifier = Classifier()
CORS(app, headers=['Content-Type'])
@app.route("/", methods=["POST", "GET", 'OPTIONS'])
def index_page():
return render_template('index.html')
@app.route("/about")
def about():
return render_template('about.html')
@app.route('/hook', methods=["GET", "POST", 'OPTIONS'])
def predict():
answer = ""
if request.method == 'POST':
image_b64 = request.values['imageBase64']
image_encoded = image_b64.split(',')[1]
image = base64.decodebytes(image_encoded.encode('utf-8'))
prediction = classifier.predict(image)
# debug_img.save(input_file + '_debug2.png')
stones = extract_stones(rect_img)
if args.extract_stones:
label_map = {}
for folder in ['white', 'black', 'empty', 'unknown']:
for img_file in os.listdir(f'train/{folder}/'):
label_map[img_file] = folder
img_name = os.path.basename(input_file)
for stone, x, y in stones:
stone_name = f'{img_name}_{x}_{y}.png'
label = label_map.get(stone_name, 'unknown')
stone.save(f'train/{label}/{stone_name}')
predictor = Classifier()
predictions = [(x, y, predictor.predict(stone)) for stone, x, y in stones]
gf = build_gamefield(predictions)
debug_img = draw_stones(debug_img, gf)
# debug_img.save(input_file + '_debug3.png')
debug_img = draw_territory(img, gf, homography)
score = calc_score(gf)
debug_img = draw_score(debug_img, score)
debug_img.save(input_file + '_debug1.png')
print_gamefield(gf)
gf = fill_territory_onlinego(gf)
print_gamefield(gf)
debug_img = draw_stones(debug_img, gf)
# debug_img.save(input_file + '_debug4.png')
# iris dataset from sklearn
iris = load_iris()
x_data = iris.data
y_data = iris.target
# split on train and test sets
x_train, x_test, y_train, y_test = train_test_split(x_data,
y_data,
test_size=0.2)
# The energy function - cross-entropy loss
criterion = torch.nn.CrossEntropyLoss()
model = Classifier()
model = model.to(device)
if arg.optimizer == 'sa':
optimizer = SimulatedAnnealing(params=model.parameters(),
device=device,
model=model,
features=torch.Tensor(x_train).float(),
labels=torch.Tensor(y_train).long(),
loss=nn.CrossEntropyLoss(),
T_init=arg.start_T,
cool_rate=arg.cool_rate,
annealing_schedule=arg.ann_schedule,
ann_iter=arg.ann_iters,
mus=arg.mus,
std=arg.std)