"""
numpynet_examples
Contains examples and demos for numpynet
@author: Chronocook (chronocook@gmail.com)
"""
import time
import numpy as np
from numpynet.model import NumpyNet
import numpynet.common as common
from numpynet.visualize import NumpynetVizClient
from numpynet.loggit import log
from visdom import Visdom
"""
# TODO
Add epochs (randomly subsample instead of all stuff)
weight decay is STRANGE
Activation functions are GARBAGE!!
dropout DOESN'T EXIST
Lol remember this is for fun
"""
def make_checkerboard_training_set(
num_points=0, noise=0.0, randomize=True, x_min=0.0, x_max=1.0, y_min=0.0, y_max=1.0
):
"""
Makes a binary array like a checkerboard (to work on an xor like problem)
:param num_points: (int) The number of points you want in your training set
:param noise: (float) percent to bit-flip in the training data, allows it to be imperfect
:param randomize: (bool) True if you want the locations to be random, False if you want an ordered grid
:param x_min: (float) minimum x of the 2D domain
:param x_max: (float) maximum x of the 2D domain
:param y_min: (float) minimum y of the 2D domain
:param y_max: (float) maximum y of the 2D domain
:return:
"""
log.out.info("Generating target data.")
# Select coordinates to do an XOR like operation on
coords = []
bools = []
if randomize:
for i in range(num_points):
# Add num_points randomly
coord_point = np.random.random(2)
coord_point[0] = coord_point[0] * (x_max - x_min) + x_min
coord_point[1] = coord_point[1] * (y_max - y_min) + y_min
coords.append(coord_point)
else:
x_points = np.linspace(x_min, x_max, int(np.sqrt(num_points)))
y_points = np.linspace(y_min, y_max, int(np.sqrt(num_points)))
for i in range(int(np.sqrt(num_points))):
for j in range(int(np.sqrt(num_points))):
# Add num_points randomly
coord_point = [x_points[i], y_points[j]]
coords.append(coord_point)
# Assign an xor boolean value to the coordinates
for coord_point in coords:
bool_point = np.array(
[np.round(coord_point[0]) % 2, np.round(coord_point[1]) % 2]
).astype(bool)
bools.append(np.logical_xor(bool_point[0], bool_point[1]))
# If noisy then bit flip
if noise > 0.0:
for i in enumerate(bools):
if np.random.random() < noise:
bools[i] = np.logical_not(bools[i])
# Build training vectors
train_in = None
train_out = None
for i, coord in enumerate(coords):
# Need to initialize the arrays
if i == 0:
train_in = np.array([coord])
train_out = np.array([[bools[i]]])
else:
train_in = np.append(train_in, np.array([coord]), axis=0)
train_out = np.append(train_out, np.array([[bools[i]]]), axis=1)
train_out = train_out.T
return train_in, train_out
def make_smiley_training_set(num_points=0, delta=0.05):
"""
Makes a binary array that looks like a smiley face (for fun, challenging problem)
:param num_points: (int) The number of points you want in your training set
:param delta:
:return:
"""
log.out.info("Generating happy data.")
# Select coordinates to do an XOR like operation on
coords = []
bools = []
x_min = 0.0
x_max = 1.0
y_min = 0.0
y_max = 1.0
for i in range(num_points):
# Add num_points randomly
coord_point = np.random.random(2)
coord_point[0] = coord_point[0] * (x_max - x_min) + x_min
coord_point[1] = coord_point[1] * (y_max - y_min) + y_min
coords.append(coord_point)
# Assign an xor boolean value to the coordinates
for coord_point in coords:
x = coord_point[0]
y = coord_point[1]
if (abs(x - 0.65) < delta) & (abs(y - 0.65) < (0.05 + delta)):
bools.append(True)
elif (abs(x - 0.35) < delta) & (abs(y - 0.65) < (0.05 + delta)):
bools.append(True)
elif (x > 0.2) & (x < 0.8) & (abs(y - ((1.5 * (x - 0.5)) ** 2 + 0.25)) < delta):
bools.append(True)
else:
bools.append(False)
# Build training vectors
train_in = None
train_out = None
for i, coord in enumerate(coords):
# Need to initialize the arrays
if i == 0:
train_in = np.array([coord])
train_out = np.array([[bools[i]]])
else:
train_in = np.append(train_in, np.array([coord]), axis=0)
train_out = np.append(train_out, np.array([[bools[i]]]), axis=1)
train_out = train_out.T
return train_in, train_out
def complete_a_picture(viz_client):
"""
Here we give the net some random points (1 or 0) from a function and it tries to fill the
rest of the space with what it thinks it should be
:param viz_client: An instance of NumpynetVizClient
"""
# Get a training set for a set of x-y coordinates, this one is part of a checkerboard pattern
x_min = 0.0
x_max = 2.0
y_min = 0
y_max = 1.0
train_in, train_out = make_checkerboard_training_set(
num_points=1000,
noise=0.00,
randomize=True,
x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max,
)
# Plot he training set
viz_client.plot_2d_classes(
train_in,
train_out,
title="Training data",
x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max,
delta=0.01,
)
training_size = train_in.shape[0]
batch_size = round(training_size / 3.0)
num_features = train_in.shape[1]
# Initialize a numpynet object
numpy_net = NumpyNet(
num_features,
batch_size,
num_hidden=5,
hidden_sizes=[4, 8, 16, 8, 4],
activation=["tanh", "tanh", "tanh", "tanh", "tanh", "tanh"],
learning_rate=0.0001,
dropout_rate=None,
weight_decay=None,
random_seed=1337,
)
# Hook the object up to the viz client
numpy_net.set_viz_client(viz_client)
# A basic report of the net to the logs
numpy_net.report_model()
# Train the model!
numpy_net.train(
train_in,
train_out,
epochs=10000,
visualize=True,
visualize_percent=1,
save_best="./numpynet_best_model.pickle",
debug_visualize=True,
)
# A silly viz of the network architecture (if the net isn't too huge to make it muddled)
if max(numpy_net.layer_sizes) <= 16:
numpy_net.viz.network_svg(numpy_net)
def plot_activations():
for activation in common.Activation.available:
x = np.linspace(-10.0, 10.0, 100)
y = common.Activation(activation).function(x, deriv=False)
dy = common.Activation(activation).function(x, deriv=True)
viz_client.plot_func(x, y, title=activation)
viz_client.plot_func(x, dy, title="d_" + activation)
# TODO write this!
def paint_a_picture():
"""
Here we give the net many examples of how to paint something like a square based on
coordinates and try to get it to learn how to make that shape given input coords
"""
# Make a training set (many random i,j coord and an x by y box around that coord to start with)
# Throw it into the net
# Test how it does for some random coordinate inputs
pass
def load_a_model(filename, viz_client):
my_net = NumpyNet.load(filename)
prediction_matrix, axis_x, axis_y = common.predict_2d_space(my_net, delta=0.002)
viz_client.plot_2d_prediction(
prediction_matrix, axis_x, axis_y, title="Best Prediction"
)
if __name__ == "__main__":
"""
Main driver.
"""
# Set the logging level to normal and start run
start_time = time.time()
# Set up visdom configuration and kick up a connection
viz = Visdom()
viz.close()
# Set up NumpynetVizClient
viz_client = NumpynetVizClient(viz=viz)
complete_a_picture(viz_client)
# load_a_model("./numpynet_best_model.pickle", viz_client)
# Shut down and clean up
total_time = round((time.time() - start_time), 0)
log.out.info("Execution time: " + str(total_time) + " sec")
log.out.info("All Done!")
log.stopLog()
