def test_forward_prop_sigmoid_small_input(self):
layer = ActivationLayer("sigmoid")
layer.set_input_shape((4,))
input = np.array([-427562359, -329756, -86, 0], dtype=np.float64)
expected_output = np.array([0, 0, 0, 0.5], dtype=np.float64)
output = layer.forward_prop(input)
numpy.testing.assert_array_almost_equal(output, expected_output)
def test_forward_prop_relu(self):
layer = ActivationLayer("ReLU")
layer.set_input_shape((4,))
input = np.array([1536, -83741, 84597, -1543], dtype=np.float64)
expected_output = np.array([1536, 0, 84597, 0], dtype=np.float64)
output = layer.forward_prop(input)
numpy.testing.assert_array_equal(output, expected_output)
def test_forward_prop_sigmoid(self):
layer = ActivationLayer("sigmoid")
layer.set_input_shape((4,))
input = np.array([0, 0, 0, 0], dtype=np.float64)
expected_output = np.array([0.5, 0.5, 0.5, 0.5], dtype=np.float64)
output = layer.forward_prop(input)
numpy.testing.assert_array_equal(output, expected_output)
def test_forward_prop_leaky_relu(self):
layer = ActivationLayer("leakyReLU")
layer.set_input_shape((4,))
input = np.array([57287, -6154385, 14938, -54787], dtype=np.float64)
expected_output = np.array([57287, -61543.85, 14938, -547.87], dtype=np.float64)
output = layer.forward_prop(input)
numpy.testing.assert_array_almost_equal(output, expected_output)
def __init__(self,
optimizer=Optimizer.batch_gradient_descent_fixed,
initializer=Initializer.xavier,
batch_size=16,
weights_decay=0.001):
self.optimizer = optimizer
self.initializer = initializer
self.batch_size = batch_size
self.weights_decay = weights_decay
self.fc1 = FullyConnectedlayer(13, 16, self.batch_size,
self.weights_decay)
self.ac1 = ActivationLayer('relu')
self.fc2 = FullyConnectedlayer(16, 1, self.batch_size,
self.weights_decay)
self.loss = Losslayer("LeastSquareLoss")
def predict(self, data):
nn = NeuralNetwork()
l1 = Layer(56, 54)
l2 = Layer(54, 25)
nn.add(l1)
nn.add(ActivationLayer(relu, relu_derivative))
nn.add(l2)
nn.add(ActivationLayer(sigmoid, sigmoid_derivative))
l1.weights = np.load('weights1.npy')
l2.weights = np.load('weights2.npy')
l1.bias = np.load('bias1.npy')
l2.bias = np.load('bias2.npy')
out = nn.predict(data)
pred = np.argmax(out)
return pred
def crossValidation(trainingData,
atr,
days,
DAYS_AHEAD,
intervals=10,
EPOCHS=300,
LEARNING_RATE=0.2):
reshaped_x = np.reshape(trainingData, (len(trainingData), 1, atr * days))
reshaped_y = np.reshape(trainingData[:, 2], (len(trainingData), 1, 1))
x = makeBatch(reshaped_x, intervals)
y = makeBatch(reshaped_y, intervals)
errors = []
for i in range(len(x)):
x_train = getSelection(x, i)[:-DAYS_AHEAD]
y_train = getSelection(y, i)[DAYS_AHEAD:]
x_test = x[i][:-DAYS_AHEAD]
y_test = y[i][DAYS_AHEAD:]
inputSize = 2 * days
outputSize = int(inputSize / 2)
net = Network()
net.add(FCLayer(inputSize, outputSize * 3))
net.add(ActivationLayer(tanh, tanh_prime))
net.add(FCLayer(outputSize * 3, outputSize))
net.add(ActivationLayer(tanh, tanh_prime))
net.add(FCLayer(outputSize, 1))
net.add(ActivationLayer(tanh, tanh_prime))
# train
net.use(mse, mse_prime)
net.fit(x_train, y_train, epochs=EPOCHS, learning_rate=LEARNING_RATE)
# test
out, err = net.predict(x_test, y_test)
errors.append(err)
print(err)
print(np.average(errors))
def test_back_prop_sigmoid(self):
layer = ActivationLayer("sigmoid")
layer.set_input_shape((4,))
input = np.array([0, 2365836, 0, -154366], dtype=np.float64)
layer.forward_prop(input)
expected_in_grad = np.array([0.25, 0, 0.25, 0], dtype=np.float64)
out_grad = np.ones(4)
in_grad = layer.back_prop(out_grad)
numpy.testing.assert_array_almost_equal(in_grad, expected_in_grad)
def test_back_prop_leaky_relu(self):
layer = ActivationLayer("leakyReLU")
layer.set_input_shape((4,))
input = np.array([1, -1, 1, -1], dtype=np.float64)
layer.forward_prop(input)
out_grad = np.ones(4)
expected_in_grad = np.array([1, 0.01, 1, 0.01], dtype=np.float64)
in_grad = layer.back_prop(out_grad)
numpy.testing.assert_array_almost_equal(in_grad, expected_in_grad)
return quicksort(t1) + [pivot] + quicksort(t2)
## init
population = 10 #nombre total de cas tester en meme temps
nombre = 1000 #nombre de géneration
q = 0.3 #facteur de mutation (entre 0 et 1)
x_train = np.array([[[0, 0]], [[0, 1]], [[1, 0]],
[[1, 1]]]) #ce qui est en entrée
##init des reseaux de neurones aléatoirement
liste = []
for k in range(0, population): #on crée "population" réseaux de neurones
liste.append([0, Network()])
liste[-1][1].add(FCLayer(2, 3)) # construction des couches
liste[-1][1].add(ActivationLayer(tanh)) #choix fonction d'activation
liste[-1][1].add(FCLayer(3, 3))
liste[-1][1].add(ActivationLayer(tanh))
liste[-1][1].add(FCLayer(3, 1))
liste[-1][1].add(ActivationLayer(tanh))
n = 0
while (n < nombre): #tant que l'on n'est pas à la "nombre"ème génerations
n += 1
for k in range(0, population): #pour tout les réseaux de neurones
y_trouve = []
y_voulu = []
for x in x_train: #on met les 4 entrées
y = liste[k][1].predict(x) #on teste les reseaux de neurones
y_attendu = x[0][0] ^ x[0][1] #la valeur que l'on doit avoir
y_voulu.append(y_attendu) #on met les resultats dans un tableau
y_trouve.append(y)
from softmax_layer import SoftmaxLayer
from activation_layer import ActivationLayer
from activations import tanh, tanh_prime, softmax, softmax_prime
from losses import mse, mse_prime, cross_entropy, cross_entropy_prime
# TRAINING DATA
# input x_train shape is (4,1,2):
x_train = np.array([[[0, 0]], [[0, 1]], [[1, 0]], [[1, 1]]])
#y_train =np.array([ [[0]], [[1]], [[1]], [[0]] ])
y_train = np.array([[1, 0], [0, 1], [0, 1], [1, 0]]) # 1 hot vector
# NETWORK
net = Network()
net.add(FCLayer(2, 3)) # input co 2 dimension [0,0], 3 neron
# FCLayer sử dụng hàm activate là tanh, đạo hàm của tanh là tanh_prime:
net.add(ActivationLayer(tanh, tanh_prime))
#net.add(FCLayer(3, 1)) # input co 3 dimension, 1 neron
net.add(FCLayer(3, 2)) # input co 3 dimension, 2 neron
#net.add(ActivationLayer(tanh, tanh_prime))
net.add(ActivationLayer(softmax, softmax_prime))
"""
Thêm lớp ở trên thì bị lỗi sau:
Traceback (most recent call last):
File "example_xor.py", line 36, in <module>
net.fit(x_train, y_train, epochs=1000, learning_rate=0.1)
File "E:\MyProg\Python\medium_nn\network.py", line 58, in fit
error = layer.backward_propagation(error, learning_rate)
File "E:\MyProg\Python\medium_nn\fc_layer.py", line 29, in backward_propagation
weights_error = np.dot(self.input.T, output_error)
File "<__array_function__ internals>", line 6, in dot
ValueError: shapes (3,1) and (2,2) not aligned: 1 (dim 1) != 2 (dim 0)
def __init__(self, ds, classes, model, created, *args, **kwargs):
super(TrainingWindow, self).__init__(*args, **kwargs)
if created:
# Initialising network
self.network = Network()
self.network.use(mean_squared_error, mean_squared_error_prime)
else:
self.network = model[0]
# Getting inputs and outputs
self.__dataset = ds
self.__classes = classes
#fill_missing_values(self.__dataset)
#min_max_normalize_dataset(self.__dataset)
((x_train, y_train),
(x_test, y_test)) = self.network.regular_split(self.__dataset, 0.5)
# Getting inputs
if len(x_train.shape) == 2:
inputs = x_train.shape[1]
else:
inputs = x_train.shape[1:]
first = inputs[0]
second = inputs[1]
third = inputs[2]
# Getting expected outputs
expected_output = y_train.shape[1]
# Getting network name
self.networkName = model[1]
if created:
# Getting model list
self.__modelList = model[0]
self.__modelList[0].setOutput(inputs)
for i in range(1, len(self.__modelList)):
# Getting the layer name
name = self.__modelList[i].text(
)[:len(self.__modelList[i].text()) - 6]
activation = None
activ_prime = None
# Getting the activation function
if self.__modelList[i].activation() == 0:
activation = sigmoid
activ_prime = sigmoid_prime
elif self.__modelList[i].activation() == 1:
activation = tanh
activ_prime = tanh_prime
elif self.__modelList[i].activation() == 2:
activation = rectified_linear_unit
activ_prime = rectified_linear_unit_prime
elif self.__modelList[i].activation() == 3:
activation = softmax
activ_prime = softmax_prime
# Adding layer to the network
if name == "Dense":
if self.__modelList[i - 1].text()[:2] == "Fl":
self.network.add(
FullyConnectedLayer(first * second * third,
self.__modelList[i].output()))
self.network.add(
ActivationLayer(activation, activ_prime))
else:
self.network.add(
FullyConnectedLayer(
self.__modelList[i - 1].output(),
self.__modelList[i].output()))
self.network.add(
ActivationLayer(activation, activ_prime))
elif name == "Flatten":
self.network.add(FlattenLayer())
elif name == "Convolutional":
self.network.add(
ConvLayer((first, second, third),
(self.__modelList[i].kernelRows,
self.__modelList[i].kernelColumns), 1))
self.network.add(ActivationLayer(activation, activ_prime))
first = first - self.__modelList[i].kernelRows + 1
second = second - self.__modelList[i].kernelColumns + 1
self.network.add(
FullyConnectedLayer(
self.__modelList[len(self.__modelList) - 1].output(),
expected_output))
self.network.add(ActivationLayer(sigmoid, sigmoid_prime))
# Loading Fonts
QFontDatabase.addApplicationFont("fonts/BebasNeue-Light.ttf")
# Window Settings
self.setFixedSize(1280, 720)
self.setWindowTitle("Training window")
#background = QPixmap("images/menu")
#palette = QPalette()
#palette.setBrush(QPalette.Background, background)
#self.setAttribute(Qt.WA_StyledBackground, True)
#self.setPalette(palette)
self.setAutoFillBackground(True)
# Stylesheet Settings
styleFile = QFile("stylesheets/training.qss")
styleFile.open(QFile.ReadOnly)
style = str(styleFile.readAll())
self.setStyleSheet(style)
# Title Settings
self.title = QLabel("Training", self)
self.title.setFont(QFont("BebasNeue", 30, QFont.Bold))
self.title.setAlignment(Qt.AlignCenter)
self.title.setGeometry(600, 10, 300, 120)
# Epochs line edit settings
self.__epochsLineEdit = QLineEdit(self)
self.__epochsLineEdit.setValidator(QIntValidator(0, 100000, self))
# Epochs label settings
self.__epochsLabel = QLabel("Epoch number", self)
self.__epochsLabel.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Learning rate line edit settings
self.__learningRateLineEdit = QLineEdit(self)
self.__learningRateLineEdit.setValidator(
QDoubleValidator(0.0, 1.0, 3, self))
# Learning rate label settings
self.__learningRateLabel = QLabel("Learning rate", self)
self.__learningRateLabel.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Learning rate checkboxsettings (auto or not)
self.__learningRateCheckBox = QCheckBox("Auto adjustment", self)
self.__learningRateCheckBox.setFont(QFont("BebasNeue", 15, QFont.Bold))
# Dataset split settings label
self.__datasetSplitLabel = QLabel("Dataset split percentage", self)
self.__datasetSplitLabel.setFont((QFont("BebasNeue", 20, QFont.Bold)))
# Dataset split mode buttons
self.__datasetSplitRegular = QRadioButton("Regular split")
self.__datasetSplitRandom = QRadioButton("Random split")
# Dataset split mode buttons groupbox
self.__datasetSplitModeButtonsLayout = QHBoxLayout(self)
self.__datasetSplitModeButtonsGroupBox = QGroupBox(self)
self.__datasetSplitModeButtonsGroupBox.setObjectName("setting")
self.__datasetSplitModeButtonsLayout.addWidget(
self.__datasetSplitRegular)
self.__datasetSplitModeButtonsLayout.addWidget(
self.__datasetSplitRandom)
self.__datasetSplitModeButtonsGroupBox.setLayout(
self.__datasetSplitModeButtonsLayout)
self.__datasetSplitRegular.setChecked(True)
# Dataset split combo box settings
self.__datasetSplitComboBox = QComboBox(self)
self.__datasetSplitComboBox.addItems(
['90% - 10%', '80% - 20%', '70% - 30%', '60% - 40%'])
# Dataset split form layout settings
self.__datasetSplitLayout = QFormLayout(self)
self.__datasetSplitGroupBox = QGroupBox(self)
self.__datasetSplitGroupBox.setObjectName("setting")
self.__datasetSplitLayout.addWidget(self.__datasetSplitLabel)
self.__datasetSplitLayout.addWidget(self.__datasetSplitComboBox)
self.__datasetSplitGroupBox.setLayout(self.__datasetSplitLayout)
# Epochs form layout settings
self.__epochsFormLayout = QFormLayout(self)
self.__epochsGroupBox = QGroupBox(self)
self.__epochsGroupBox.setObjectName("setting")
self.__epochsFormLayout.addWidget(self.__epochsLabel)
self.__epochsFormLayout.addWidget(self.__epochsLineEdit)
self.__epochsGroupBox.setLayout(self.__epochsFormLayout)
# Learning rate form layout settings
self.__learningRateFormLayout = QFormLayout(self)
self.__learningRateGroupBox = QGroupBox(self)
self.__learningRateGroupBox.setObjectName("setting")
self.__learningRateFormLayout.addWidget(self.__learningRateLabel)
self.__learningRateFormLayout.addWidget(self.__learningRateCheckBox)
self.__learningRateFormLayout.addWidget(self.__learningRateLineEdit)
self.__learningRateGroupBox.setLayout(self.__learningRateFormLayout)
# Epochs number label
self.__epochNumberLabel = QLabel("Epoch : ", self)
self.__epochNumberLabel.setFont((QFont("BebasNeue", 15, QFont.Bold)))
# Training accuracy label
self.__trainingAccuracyLabel = QLabel("Accuracy : ", self)
self.__trainingAccuracyLabel.setFont((QFont("BebasNeue", 15,
QFont.Bold)))
# Training stats layout
self.__trainingStatsLayout = QVBoxLayout(self)
self.__trainingStatsGroupBox = QGroupBox(self)
self.__trainingStatsLayout.addWidget(self.__epochNumberLabel)
self.__trainingStatsLayout.addWidget(self.__trainingAccuracyLabel)
self.__trainingStatsGroupBox.setLayout(self.__trainingStatsLayout)
self.__trainingStatsGroupBox.setGeometry(1000, -30, 300, 150)
# Training button settings
self.__trainingButton = QPushButton("Start", self)
self.__trainingButton.setCursor(Qt.PointingHandCursor)
self.__trainingButton.setFont((QFont("BebasNeue", 30, QFont.Bold)))
self.__trainingButton.clicked.connect(self.startTraining)
# Go back button
self.goBackButton = QPushButton("Back", self)
self.goBackButton.setObjectName("retour")
# Customising go back button
self.goBackButton.setCursor(Qt.PointingHandCursor)
self.goBackButton.setIcon(QIcon("images/goback_icon"))
self.goBackButton.setIconSize(QSize(30, 30))
self.goBackButton.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Confusion matrix button
self.__confusionMatrixButton = QPushButton("Show confusion matrix",
self)
self.__confusionMatrixButton.setCursor(Qt.PointingHandCursor)
self.__confusionMatrixButton.setFont((QFont("BebasNeue", 17,
QFont.Bold)))
self.__confusionMatrixButton.clicked.connect(self.showStats)
self.__confusionMatrixButton.setGeometry(420, 20, 250, 80)
self.__confusionMatrixButton.hide()
# Parameters group box settings
self.__parametersGroupBox = QGroupBox("Training parameters", self)
self.__parametersGroupBox.setObjectName("parameters")
self.__parametersLayout = QVBoxLayout(self)
self.__parametersLayout.addWidget(self.__epochsGroupBox)
self.__parametersLayout.addWidget(self.__datasetSplitGroupBox)
self.__parametersLayout.addWidget(
self.__datasetSplitModeButtonsGroupBox)
self.__parametersLayout.addWidget(self.__learningRateGroupBox)
self.__parametersLayout.addWidget(self.__trainingButton)
self.__parametersLayout.addWidget(self.goBackButton)
self.__parametersGroupBox.setLayout(self.__parametersLayout)
self.__parametersGroupBox.setGeometry(0, 0, 400, 720)
# Chart axis settings
self.__xAxis = QtCharts.QValueAxis()
self.__xAxis.setRange(0, 5)
self.__yAxis = QtCharts.QValueAxis()
self.__yAxis.setRange(0, 100)
# Chart settings
self.__series = QtCharts.QLineSeries()
self.__chart = QtCharts.QChart()
self.__chart.addAxis(self.__xAxis, Qt.AlignBottom)
self.__chart.addAxis(self.__yAxis, Qt.AlignLeft)
self.__chart.addSeries(self.__series)
self.__series.attachAxis(self.__xAxis)
self.__series.attachAxis(self.__yAxis)
self.__chart.setTitle("Accuracy")
self.__chartView = QtCharts.QChartView(self.__chart)
self.__chartView.setRenderHint(QPainter.Antialiasing)
# Chart layout settings
self.__chartLayout = QVBoxLayout(self)
self.__chartGroupBox = QGroupBox(self)
self.__chartGroupBox.setObjectName("chart")
self.__chartLayout.addWidget(self.__chartView)
self.__chartGroupBox.setLayout(self.__chartLayout)
self.__chartGroupBox.setGeometry(390, 100, 900, 600)
# Update timer settings
#self.__timer = QTimer(self)
#self.__timer.timeout.connect(self.autoSave)
#self.__timer.start(1000)
#app = QApplication(sys.argv)
#window = TrainingWindow()
#window.show()
#app.exec_()
def relu(z):
return np.maximum(0, z)
def relu_prime(z):
z[z < 0] = 0
z[z > 0] = 1
return z
def loss(y_true, y_predict):
return 0.5 * (y_predict - y_true)**2
def loss_prime(y_true, y_predict):
return y_predict - y_true
x_train = np.array([[[0, 0]], [[0, 1]], [[1, 0]], [[1, 1]]])
y_train = np.array([[[0]], [[1]], [[1]], [[0]]])
net = Network()
net.add(FCLayer((1, 2), (1, 3)))
net.add(ActivationLayer((1, 3), (1, 3), relu, relu_prime))
net.add(FCLayer((1, 3), (1, 1)))
net.add(ActivationLayer((1, 1), (1, 1), relu, relu_prime))
net.setup_loss(loss, loss_prime)
net.fit(x_train, y_train, epochs=1000, learning_rate=0.01)
out = net.predict(np.array([[0, 1]]))
print(out)
class DNNNet:
def __init__(self,
optimizer=Optimizer.batch_gradient_descent_fixed,
initializer=Initializer.xavier,
batch_size=16,
weights_decay=0.001):
self.optimizer = optimizer
self.initializer = initializer
self.batch_size = batch_size
self.weights_decay = weights_decay
self.fc1 = FullyConnectedlayer(13, 16, self.batch_size,
self.weights_decay)
self.ac1 = ActivationLayer('relu')
self.fc2 = FullyConnectedlayer(16, 1, self.batch_size,
self.weights_decay)
self.loss = Losslayer("LeastSquareLoss")
def forward_train(self, input_data, input_label):
self.fc1.get_inputs_for_forward(input_data)
self.fc1.forward()
self.ac1.get_inputs_for_forward(self.fc1.outputs)
self.ac1.forward()
self.fc2.get_inputs_for_forward(self.ac1.outputs)
self.fc2.forward()
print(
"predict label: \n ",
np.concatenate((self.fc2.outputs[:10], input_label[:10]), axis=1))
self.loss.get_inputs_for_loss(self.fc2.outputs)
self.loss.get_label_for_loss(input_label)
self.loss.compute_loss()
print("loss: ", self.loss.loss)
def backward_train(self):
self.loss.compute_gradient()
self.fc2.get_inputs_for_backward(self.loss.grad_inputs)
self.fc2.backward()
self.ac1.get_inputs_for_backward(self.fc2.grad_inputs)
self.ac1.backward()
self.fc1.get_inputs_for_backward(self.ac1.grad_inputs)
self.fc1.backward()
def predict(self, input_data):
self.fc1.get_inputs_for_forward(input_data)
self.fc1.forward()
self.ac1.get_inputs_for_forward(self.fc1.outputs)
self.ac1.forward()
self.fc2.get_inputs_for_forward(self.ac1.outputs)
self.fc2.forward()
return self.fc2.outputs
def eval(self, input_data, input_label):
self.fc1.update_batch_size(input_data.shape[0])
self.fc1.get_inputs_for_forward(input_data)
self.fc1.forward()
self.ac1.get_inputs_for_forward(self.fc1.outputs)
self.ac1.forward()
self.fc2.update_batch_size(input_data.shape[0])
self.fc2.get_inputs_for_forward(self.ac1.outputs)
self.fc2.forward()
print("predict: \n ", self.fc2.outputs[:10])
print("label: \n", input_label[:10])
metric = MetricCalculator(label=input_label, predict=self.fc2.outputs)
metric.get_mae()
metric.get_mse()
metric.get_rmse()
metric.print_metrics()
def update(self):
self.fc1.update(self.optimizer)
self.fc2.update(self.optimizer)
def initial(self):
self.fc1.initialize_weights(self.initializer)
self.fc2.initialize_weights(self.initializer)
def test_get_output_shape(self):
layer = ActivationLayer("ReLU")
layer.set_input_shape((100,))
self.assertEqual(layer.get_output_shape(), (100,))
x_train /= 255
# encode output which is a number in range [0,9] into a vector of size 10
# e.g. number 3 will become [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
y_train = np_utils.to_categorical(y_train)
# same for test data : 10000 samples
x_test = x_test.reshape(x_test.shape[0], 1, 28 * 28)
x_test = x_test.astype('float32')
x_test /= 255
y_test = np_utils.to_categorical(y_test)
# Network
net = Network()
net.add(FCLayer(28 * 28,
100)) # input_shape=(1, 28*28) ; output_shape=(1, 100)
net.add(ActivationLayer(tanh, tanh_prime))
net.add(FCLayer(100, 50)) # input_shape=(1, 100) ; output_shape=(1, 50)
net.add(ActivationLayer(tanh, tanh_prime))
net.add(FCLayer(50, 10)) # input_shape=(1, 50) ; output_shape=(1, 10)
net.add(ActivationLayer(tanh, tanh_prime))
# train on 1000 samples
# as we didn't implemented mini-batch GD, training will be pretty slow if we update at each iteration on 60000 samples...
net.use(mse, mse_prime)
net.fit(x_train[0:1000], y_train[0:1000], epochs=50, learning_rate=0.01)
# test on 3 samples
out = net.predict(x_test[0:3])
print("\n")
print("predicted values : ")
print(out, end="\n")
import numpy as np from network import Network from fc_layer import FCLayer from activation_layer import ActivationLayer #from activations import tanh, tanh_prime from losses import mse, mse_prime from activations import sigmoid, sigmoid_prime # training data x_train = np.array([[[0, 0]], [[0, 1]], [[1, 0]], [[1, 1]]]) y_train = np.array([[[0]], [[1]], [[1]], [[0]]]) # network net = Network() net.add(FCLayer(2, 3)) net.add(ActivationLayer(sigmoid, sigmoid_prime)) net.add(FCLayer(3, 1)) net.add(ActivationLayer(sigmoid, sigmoid_prime)) # train net.use(mse, mse_prime) cost_, myerr = net.fit(x_train, y_train, epochs=10000, learning_rate=0.2) # test out = net.predict(x_train) print(out) import matplotlib.pyplot as plt plt.plot(cost_)
def neural_network_loader(hdf5_file_path, json_file_path):
"""
This function loads a json file and a hd5 file. Then it creates the model and the matrix of the neural network.
Arguments :
hdf5_file_path -- The hdf5 file's path
json_file_path -- The json file's path
Return :
an object of type network
"""
network_info = list()
layer = list()
information = list()
parameter = list()
# Loading json file and hdf5 file
with open(json_file_path) as json_file, h5py.File(hdf5_file_path,
'r') as hdf5File:
data = json.load(json_file)
group1 = hdf5File.get('Fully')
group2 = hdf5File.get('Conv')
len_groupFully = len(group1)
len_groupConv = len(group2)
groupFully = 0
groupConv = 0
for i in range(len(data)):
for key in data:
if (key[-1] == str(i)):
if key[:-2] == "Fully":
groupFully += 2
for x in data[key]:
layer.append("Fully")
parameter.append(x['input_size'])
parameter.append(x['output_size'])
information.append(
np.array(group1.get("FullyW_" + key[-1:])))
information.append(
np.array(group1.get("FullyB_" + key[-1:])))
if key[:-2] == "Flatten":
layer.append("Flatten")
if key[:-2] == "Activation":
for x in data[key]:
layer.append("Activation")
parameter.append(x['activation'])
parameter.append(x['activation_prime'])
if key[:-2] == "Conv":
groupConv += 2
for x in data[key]:
layer.append("Conv")
parameter.append(x['input_shape'])
parameter.append(x['kernel_shape'])
parameter.append(x['layer_depth'])
information.append(
np.array(group2.get("ConvW_" + key[-1:])))
information.append(
np.array(group2.get("ConvB_" + key[-1:])))
# Creation of a network object
if (groupFully != len_groupFully) or (groupConv != len_groupConv):
return 0
else:
net = Network()
i = 0
j = 0
k = 0
for l in layer:
if l == "Conv":
net.add(
ConvLayer(parameter[i], parameter[i + 1],
parameter[i + 2]))
net.layers[k].weights = np.copy(information[j])
net.layers[k].bias = np.copy(information[j + 1])
i += 3
j += 2
k += 1
if l == "Flatten":
net.add(FlattenLayer())
k += 1
if l == "Activation":
if (parameter[i] == "sigmoid"):
net.add(ActivationLayer(sigmoid, sigmoid_prime))
if (parameter[i] == "tanh"):
net.add(ActivationLayer(tanh, tanh))
if (parameter[i] == "rectified_linear_unit"):
net.add(
ActivationLayer(rectified_linear_unit,
rectified_linear_unit_prime))
if (parameter[i] == "softmax"):
net.add(ActivationLayer(softmax, softmax_prime))
k += 1
i += 2
if l == "Fully":
net.add(FullyConnectedLayer(parameter[i], parameter[i + 1]))
net.layers[k].weight = np.copy(information[j])
net.layers[k].bias = np.copy(information[j + 1])
k += 1
j += 2
i += 2
net.use(mean_squared_error, mean_squared_error_prime)
return net
