def NN_complete_search(X,
Y,
input_dim,
output_dim,
stochastic=False,
batch_size=500,
max_dim=5,
max_hidden_layers=2):
criteria = ['accuracy', 'precision', 'recall', 'f1_score', None]
results = []
for criterion in criteria:
min_loss = np.inf
max_score = 0
best_nn = None
for hidden_layers in range(max_hidden_layers + 1):
dims = [np.arange(1, max_dim + 1)] * hidden_layers
products = product(*dims)
for p in products:
net = NN(input_dim, *p, output_dim)
net.load(X, Y)
net.back_prop_learning(criterion,
batch_size if stochastic else None)
if criterion:
nn_score = net.score
nn_dims = net.dims
if nn_score > max_score:
max_score = nn_score
best_nn = net
else:
nn_loss = net.loss
nn_dims = net.dims
if nn_loss < min_loss:
min_loss = nn_loss
best_nn = net
results.append((criterion if criterion else 'loss', best_nn))
return results
def __init__(self):
self.nn = NN.load("nn.json")
self.root = tk.Tk()
self.active = False
self.img = Image.new("L", (Window.imgsize, Window.imgsize))
self.hidden_canvas = ImageDraw.Draw(self.img)
self.canvas = tk.Canvas(self.root,
width=Window.imgsize,
height=Window.imgsize,
background="black")
self.canvas.pack()
self.canvas.focus()
self.root.bind("<Button-1>", self.on_click)
self.root.bind("<ButtonRelease-1>", self.on_release)
self.root.bind("<Motion>", self.on_move)
self.root.mainloop()
from nn import NN
from dataparser import train_test_split, submit
input_size, output_size, train_data, test_data = train_test_split(
False, False, 0.1, True)
layers = [input_size, 64, 128, output_size]
print(layers)
# layers = [input_size, output_size]
lr = (0.001, 0.001)
transfer = "logistic"
brain = NN(layers, lr, transfer, 32)
brain.load('weights/weights4_final.npz')
print("Error 1:", brain.get_error(train_data))
print("Accuracy 1:", brain.get_correct(train_data))
print("Error 2:", brain.get_error(test_data))
print("Accuracy 2:", brain.get_correct(test_data))
submit(brain, 'submission.csv', True)
def load_one_all(self, L, path=None):
nn = NN([1, 1, 1], multi_start=self.n_start)
if path is None:
path = self.save_path
nn.load("{0}/basis_{1}".format(path, L))
return nn
