def test_xor_gate(self):
"""Simulate XOR gate and ensure working"""
inputs = [[1.0, 1.0],
[1.0, 0.0],
[0.0, 1.0],
[0.0, 0.0]]
output_vector = [[0.0],
[1.0],
[1.0],
[0.0]]
inputs = np.array(inputs, dtype='float32')
output_vector = np.array(output_vector)
net = NeuralNetwork(inputs, output_vector)
net.train()
output = net.feed(np.array([[0, 1]], dtype='float32'))[0][0]
output = round(output, 3)
self.assertAlmostEqual(output, 1)
output = net.feed(np.array([[1, 0]], dtype='float32'))[0][0]
output = round(output, 3)
self.assertAlmostEqual(output, 1)
output = net.feed(np.array([[0, 0]], dtype='float32'))[0][0]
output = round(output, 3)
self.assertAlmostEqual(output, 0)
output = net.feed(np.array([[1, 1]], dtype='float32'))[0][0]
output = round(output, 3)
self.assertAlmostEqual(output, 0)
def main():
# load data
_input = torch.tensor(data.training_input, dtype=torch.float)
_output = torch.tensor(data.training_expected_output, dtype=torch.float)
# This section is for plotting ##############################
gene_array = []
loss_array = []
fig, ax = plt.subplots()
ax.set(xlabel='generation',
ylabel='mean sum squared error',
title='Neural network, error loss after each generation')
# This section is for plotting ##############################
ANN = NeuralNetwork(i=45, o=10, h=5) # input,output,hidden layer size
# weight training
for i in range(15000):
# mean sum squared error
mean_error = torch.mean((_output - ANN(_input))**2).detach().item()
print("Generation: " + str(i) + " error: " + str(mean_error))
gene_array.append(i)
loss_array.append(mean_error)
ANN.train(_input, _output)
torch.save(ANN, "algo1.weights")
ANN = torch.load("14_good.weights")
test_trained_network(ANN)
ax.plot(gene_array, loss_array)
plt.show()
def main():
inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
labels = np.array([[0], [1], [1], [0]])
architecture = (2, 3, 1)
nn = NeuralNetwork(architecture, activation="sigmoid", cost="mse")
costs = nn.train(inputs, labels, alpha=1, iterations=5000)
print("\nCost always decreases:",
all([costs[i + 1] < costs[i] for i in range(len(costs) - 1)]))
print("Lowest cost:", min(costs))
print("\nResults:", "\n", np.round(nn.evaluate(inputs), 0))
plotCosts(costs)
# GRAPHING
plt.style.use(["dark_background"])
#plt.rc("grid", alpha=0.25)
start, end = -0.5, 1.5
fidelity = 0.01
n = int((end - start) / fidelity)
points = np.meshgrid(np.linspace(start, end, n + 1),
np.linspace(start, end, n + 1))
values = np.zeros((n + 1, n + 1))
for i in range(n + 1):
for j in range(n + 1):
values[i, j] = nn.evaluate(
np.array([points[0][i, j], points[1][i, j]]))
x, y = points
# RdYlGn
plt.contourf(x, y, values, np.linspace(0, 1, 51), cmap="jet_r")
plt.colorbar()
plt.contour(x,
y,
values,
0.5,
linewidths=2,
linestyles="dashed",
colors="black")
plt.grid(color="black", alpha=0.25)
plt.axhline(y=0, color="k", lw=2)
plt.axvline(x=0, color="k", lw=2)
plt.title("Neural Network XOR Boundary")
plt.xlabel("X Axis")
plt.ylabel("Y Axis")
plt.show()
def main(mnist_path, output_path, activation, hl_sizes):
f = gzip.open(mnist_path, 'rb')
training_set, test_set = pickle.load(f, encoding='latin1')
training_examples = transform_examples(training_set)
test_examples = transform_examples(test_set)
if activation == "sigmoid":
activation = neural_net.sigmoid
d_activation = neural_net.d_sigmoid
elif activation == "relu":
activation = neural_net.relu
d_activation = neural_net.d_relu
elif activation == "elu":
activation = neural_net.elu
d_activation = neural_net.d_elu
network = NeuralNetwork([PIXEL_COUNT] + hl_sizes + [NUM_CHARACTERS],
output_path,
act_func=activation,
act_func_deriv=d_activation)
network.train(training_generator(training_examples), test_examples)
pickle.dump(network, open(output_path, 'wb'))
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.preprocessing import MinMaxScaler
from neural_net import NeuralNetwork
#1D artificial data
X = np.arange(0, 20).reshape(20, 1) + np.random.randn(20, 1)
y = (np.arange(0, 20) + np.random.randn(20)).reshape(20, 1)
scaler = MinMaxScaler()
X = scaler.fit_transform(X)
y = scaler.fit_transform(y)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.3,
random_state=101)
plt.plot(X, y, '*', label='train data')
plt.xlabel('features')
plt.ylabel('labels')
plt.title('DNN Regressor')
nn = NeuralNetwork(mode='regression')
nn.train(X_train, y_train, 1000)
y_pred = nn.predict(X_test)
print()
r2 = r2_score(y_test, y_pred)
print('The R^2 score is:', r2)
plt.plot(X_test, y_pred, 'r*', label='test data')
plt.legend()
# functions
def n():
return input('Ingrese un numero: ')
# input data
inputs = np.array([[0, 1, 0], [0, 0, 0], [0, 1, 1], [0, 0, 0], [1, 0, 0],
[1, 1, 1], [1, 0, 1]])
# output data
outputs = np.array([[0], [0], [0], [0], [1], [1], [1]])
# create a neural network
NeuralN = NeuralNetwork(inputs, outputs)
NeuralN.train()
# create two new examples to test and predict
example1 = np.array([[1, 1, 0]])
example2 = np.array([[0, 1, 1]])
exampleUser = np.array([n(), n(), n()])
# print and predict the examples
print(NeuralN.predict(example1), '- Correct: ', example1[0][0])
print(NeuralN.predict(example2), '- Correct: ', example2[0][0])
print(NeuralN.predict(exampleUser), '- Correct: ', exampleUser[0][0])
# plot the error over the entire training duration
plt.figure(figsize=(15, 5))
plt.plot(NeuralN.iters_hist, NeuralN.costerror_hist)
plt.xlabel('Iters')
from neural_net import NeuralNetwork
nn = NeuralNetwork("parkinsons_supervised.csv",
"initial_model",
model_type='regression')
nn.train()
years, spots = split_data(data)
# normalise data
norm_spots = norm(spots, 0, 1)
# split for training and validation
train_spots = norm_spots[:200]
valid_spots = norm_spots[200:]
# converted data to matrices - ready to work with it
training_out = np.array(train_spots[N:]).reshape(-1, 1)
training_in = create_input_matrix(train_spots, N)
# learn
neur_net = NeuralNetwork(N)
neur_net.train(training_in, training_out, 100000, 0.0001)
print("Weights after training:")
print(neur_net.synaptic_weights)
# test data preparation
valid_test_out = np.array(valid_spots[N:]).reshape(-1, 1)
valid_test_in = create_input_matrix(valid_spots, N)
# count error
res = []
for i, line in enumerate(valid_test_in):
prediciton = neur_net.think(line)
error = valid_test_out[i-1] - prediciton
res.append(error**2)
print(denorm(valid_test_out[i], spots), denorm(prediciton, spots))
