def addLayer(self,
file_name=None,
neurons=None,
output=False,
trainable=True):
"""Add a layer to the network
"""
if len(self.layers) == 0:
input_size = self.input_size
else:
input_size = self.layers[-1].num_neurons
if file_name:
if output:
self.layers.append(
OutputLayer(weight_file=file_name, trainable=trainable))
else:
self.layers.append(
HiddenLayer(weight_file=file_name, trainable=trainable))
else:
if output:
self.layers.append(
OutputLayer(num_neurons=neurons,
inputs=input_size,
trainable=trainable))
else:
self.layers.append(
HiddenLayer(num_neurons=neurons,
inputs=input_size,
trainable=trainable))
def __init__(self, userid):
self.inputLayer = InputLayer()
self.hiddenLayers = []
self.outputLayer = OutputLayer()
self.userid = userid
self.outputs = []
def __init__(self, train_x, train_y, test_x, test_y):
self.train_x = train_x
self.train_y = train_y
self.test_x = test_x
self.test_y = test_y
self.preprocess()
self.input_layer = InputLayer(self.train_x.shape[1])
self.output_layer = OutputLayer(len(self.train_y), self.input_layer)
self.input_layer.prev_layer = self.output_layer
self.accuracy = 0
self.loss = 0
self.add_layer(LayerDense(self.train_x.shape[1], 64))
self.add_layer(LayerDense(64, 32))
self.add_layer(LayerDense(32, len(self.train_y)))
self.optimizer = OptimizerAdam(learning_rate=0.05, decay=5e-7)
varF, F, init = bn.getRandomParameters(N + I, K, isConstantConnectivity=False)
res = Reservoir(I, L, bn_directory + 'time_series_data_3.csv',
directory + 'test_2018-08-03.csv', N, varF, F, init)
print('reservoir initialized')
functionInputs = [f_utils.getInputTuple(window) for i in range(O)]
functionsToApproximate, functionVectors = [], []
for i in range(O):
function_vector = f_utils.convertIntToBinaryVector(i, 2**window)
func = f_utils.convertVectorToFunction(function_vector)
functionsToApproximate.append(func)
# Only for printing purposes
functionVectors.append(function_vector)
output = OutputLayer(res, O, functionsToApproximate, functionInputs, delay,
dataStreamLength)
output.train(trainingSize)
output.test(testSize)
print(f'N = {N}')
print(f'K = {K}')
print(f'I = {I}')
print(f'L = {output.reservoir.L}')
print(f'window = {window}')
print(f'delay = {delay}')
print(f'dataStreamLength = {dataStreamLength}')
print(f'trainingSize = {trainingSize}')
print(f'testSize = {testSize}')
print(f'seed = {seed}')
print(f'O = {O}')
print()
def __init__(self, n_input, n_output):
self.input_layer = InputLayer(n_input)
self.output_layer = OutputLayer(n_output, self.input_layer)
self.input_layer.prev_layer = self.output_layer
self.accuracy = 0
self.loss = 0
# Initialize reservoir
bn_directory = os.getcwd() + '/BN_realization/'
directory = os.getcwd() + '/'
varF, F, init = bn.getRandomParameters(N_list[i] + I,
K + (L / N_list[i]),
isConstantConnectivity=False)
res = Reservoir(I, L, bn_directory + 'time_series_data_3.csv',
directory + 'experiment1_2018-08-03.csv', N_list[i],
varF, F, init)
# Train and test output layer
output = OutputLayer(res,
O,
functionsToApproximate,
functionInputs,
delay,
dataStreamLength,
nonRecursiveArgs=[[(0, 2)]])
output.train(trainingSize)
output.test(testSize)
# add results to data
print('adding data')
data[i, j] = sum([output.successRates[k] for k in range(O)]) / O
time = int(time.clock() - start)
# Write metadata to file
f_utils.printParameters(N_list, K, I, L_list, window, delay, dataStreamLength,
trainingSize, testSize, O, 'recursiveParity', seed,
time)
self.inputs[:, np.newaxis]
assert self.weights.shape == gradient.shape
self.weights -= gradient*learning_rate
def calculate_delta(self):
"""
Calculate the delta values associated with neurons in this hidden layer.
equivalent to g'(a(j))*sum(delta(k)w(kj))
"""
next_deltas = self.next_layer.get_deltas()
next_weights = self.next_layer.get_weights()
next_errors = np.sum(np.tile(next_deltas, (len(next_weights), 1))*\
next_weights, axis=1)
return self.output_wrt_inputs()*next_errors
if __name__ == "__main__":
from output_layer import OutputLayer
from functions import *
hl = HiddenLayer(2, 2, sigmoid_vectorized, sigmoid_derv_vectorized, 0)
ol = OutputLayer(2, 2, sigmoid_vectorized, sigmoid_derv_vectorized, error_derv, 0)
hl.set_next_layer(ol)
inputs = np.array([-0.7, 0.7])
targets = np.array([0.0, 0.5])
for i in range(10000):
print(hl.bias)
hl.forward_pass(inputs)
ol.forward_pass(hl.outputs)
ol.update_weight(targets, 0.5)
hl.update_weight(0.4)
print(ol.outputs)
weight_relation_vector = []
for _ in range(quantity_cluster):
t = [
round((random.uniform(0.4, 0.6)), 5) for _ in range(QUANTITY_INPUT)
]
weight_relation_vector.append(t)
return weight_relation_vector
if __name__ == '__main__':
epoch = 10
size_sample = 100
quantity_cluster = 5
output_layer = OutputLayer(form_weight_relation(quantity_cluster),
quantity_cluster)
input_layer = InputLayer(form_sample(size_sample),
output_layer,
size_sample=size_sample)
help_epoch = []
help_function = []
speed_function_start = 0.5
delta_function_start = 0.5
for i in range(epoch):
delta_function = (-i / (epoch + 1) + 1)
#delta_function = 1
speed_function = speed_function_start * e**(i / epoch)
k = input_layer.epoch(output_layer.weight_relation_vector,
output_layer.quantity_cluster, delta_function,
def add_output_layer(self, num_units):
l = OutputLayer(self.layers[-1], num_units)
self.layers.append(l)
np.random.seed(3148)
# np.random.seed(45)
# n_nodes = 30
in_dim = XI.shape[1]
# --------------------------------------------------------------------------
# np.random.seed(3148) good combo
# n_nodes = 30
# L1 = layer('tanh',n_nodes ,in_dim, True) # no bias
# L2 = output_layer('sse','tanh',1, n_nodes, True) # bias
n_nodes = 60
L1 = Layer('tanh', n_nodes, in_dim)
L2 = OutputLayer('sse', 'linear', 1, n_nodes) #
eta = 0.001
iters, sErr = 200, np.Infinity
TrEnt = []
TeEnt = []
for i in range(iters):
# np.random.shuffle(X)
for obs in range(Xtr.shape[0]):
o0, y = Xtr[obs, :], float(Ytr[obs])
o1 = L1.feed(o0)
o2 = float(L2.feed(o1))
dCost_do2 = L2.costFuncDeriv(y, o2)
from neural_network import NeuralNetwork
from input_layer import InputLayer
from output_layer import OutputLayer
from hidden_layer import HiddenLayer
# test train xor function
model = NeuralNetwork(InputLayer(2), HiddenLayer(2, "sigmoid"),
OutputLayer(1, "sigmoid"))
train_input = [[1, 1], [1, 0], [0, 1], [0, 0]]
train_output = [0, 1, 1, 0]
model.train(train_input, train_output, 1, 0.1, 20)
model.predict([1, 1])
model.predict([1, 0])
model.predict([0, 1])
model.predict([0, 0])
