# Create the target array for net_x with value 0.01 for each element.
x_target = np.zeros(onodes_x)
# Set the value of the index which results from the correct x-value to 0.99.
x_target[int(x_value * 100 + 200)] = 0.99
# Create the target array for net_y with value 0.01 for each element.
y_target = np.zeros(onodes_y)
# Set the value of the index which results from the correct y-value to 0.99.
y_target[int(y_value * 100 + 200)] = 0.99
# Create the target array for net_z with value 0.01 for each element.
z_target = np.zeros(onodes_z)
# Set the value of the index which results from the correct z-value to 0.99.
z_target[int(z_value * 100 + 100)] = 0.99
# Train the neural networks.
net_x.train(traininginput, x_target)
net_y.train(traininginput, y_target)
net_z.train(traininginput, z_target)
# After 'test'-number of trainings, test the network.
if e % test == 0:
# Create an empty array to save all errors of one training and calculate mean error and
# standard deviation in the end.
errorlist = []
# Test the networks for 500 angle combinations
for i in range(500):
# Depending on the degrees of freedom, 1, 2 or 3 angles are drawn randomly from the list
# containing all integer numbers from -180 to 180.
# and 3 are random numbers out of the array angles. Theta 1 is 0.
trainingangles = np.asarray(
[0, random.choice(angles),
random.choice(angles)])
# Set the input to a range between 0.01 and 1.00.
traininginput = (((trainingangles + 180) / 360) * 0.99) + 0.01
# Calculate the real result for the randomly chosen input with homogenous transformation matrices.
result = manipulator.calculate(trainingangles[0], trainingangles[1],
trainingangles[2])
# Set the result to a range between 0.2 and 0.8 for the targets of the net.
target = (((result[:3] + 2) / 4) * 0.6) + 0.2
target[2] = (((result[2] + 1) / 4) * 0.6) + 0.2
# Train the neural network.
net.train(traininginput, target)
# After test-number of trainings, test the network.
if e % test == 0:
# Create an empty array to save all errors of one training and calculate mean error and
# standard deviation in the end.
errorlist = []
# Test the network for 500 angle combinations
for i in range(500):
# An array of 3 angles as input. Depending on the degrees of freedom, 1, 2 or 3 angles
# are randomly chosen.
testangles = np.asarray(
[0, random.choice(angles),
random.choice(angles)])
epochs = 60000
# Number of trainings, after which the network is tested.
test = epochs / 5
for e in range(epochs+1):
# Set the input to a range between 0.01 and 1.00.
x = ((random.random()) * 0.99) + 0.01
y = 3 * x * (1 - x)
# Define the target for the network avoiding 0 because it can not be reached by the
# sigmoid activation function.
target = y + 0.1
# Train the neural network.
net.train(x, target)
# After 'test'-number of trainings, test the network.
if e % test == 0:
# Create empty arrays for each test to plot the function calculated by the network
# and calculate mean error and deviation.
outputarray = []
errorlist = []
# Test the network for 300 input values between 0 and 1.
input = (np.linspace(0, 1, num=300))
for i in range(len(input)):
# Subtract 0.1 from the output, to compensate the previously set target.
output = float(net.query(input[i])) - 0.1
# Save the outputs in an array.
x = random.choice(np.linspace(0, 1, num=101))
# Create the input array with value 0.01 for each element
xlist = np.zeros(inodes) + 0.01
# Set the value of the index which results from the multiplication of x with 100 to 1.0.
xlist[int(x * 100)] = 1.00
# Calculate the result for the given input with the function. Round the result to 2 decimals
# which is the accuracy, the network is limited to due to the discretization of the output.
y = (3 * x * (1 - x)).__round__(2)
# Create the target array with value 0.01.
targetlist = np.zeros(onodes) + 0.01
# Set the value of the index which results from the multiplication of y with 100 to 0.99.
targetlist[int(y * 100)] = 0.99
# Train the neural network.
net.train(xlist, targetlist)
# After 'test'-number of trainings, test the network.
if e % test == 0:
# Create empty arrays for each test to plot the function calculated by the network
# and calculate mean error and deviation.
outputarray = []
errorlist = []
# Test the network for 300 input values between 0 and 1.
input = np.linspace(0, 1, num=300)
for i in range(len(input)):
# Create the input array the same way as in training.
inputlist = np.zeros(inodes)
inputlist[int(input[i] * 100)] = 1.00
for e in range(epochs + 1):
# Set the input to a range between 0.01 and 1.00.
x = ((random.random()) * 0.99) + 0.01
# Calculate the result for the given input with the function. Round the result to 2 decimals
# which is the accuracy, the network is limited to due to the discretization of the output.
y = (3 * x * (1 - x)).__round__(2)
# Create the target array with value 0.01.
targetlist = np.zeros(onodes) + 0.01
# Set the value of the index which results from the multiplication of y with 100 to 0.99.
targetlist[int(y * 100)] = 0.99
# Train the neural network.
net.train(x, targetlist)
# After 'test'-number of trainings, test the network.
if e % test == 0:
# Create empty arrays for each test to plot the function calculated by the network
# and calculate mean error and deviation.
outputarray = []
errorlist = []
# Test the network for 300 input values between 0 and 1.
input = (np.linspace(0, 1, num=300))
for i in range(len(input)):
# Ask the network for the result, being an array similar to the target array.
result = net.query(input[i])
# The value being compared to the result of the function is the index of the result