In [24]:
% matplotlib inline
from matplotlib import pyplot as plt
from tqdm import tqdm
import numpy as np
class Layer():
"""Learning 'logical and' layer
"""
def __init__(self, mode, node_num, input_num):
"""init
param: mode (integer):
1: 1input&2output
2: 2input&2output
3: x0-input xor x1-input
param: node_num (integer): node num
param: input_num (integer): input number
"""
self._mode = mode
self._node_num = node_num
self._input_num = input_num
# Learning rate
self._rate = 0.01
# weight to input values default
self._weight = np.random.rand(node_num, input_num)
# bias value
self._bias = np.zeros((node_num, 1))
# output values
self._output = None
# set answer
self._set_answer(input_num)
def learn(self, inputs):
"""Learning
param: inputs (ndarray): input values
return (float): Difference between output value and correct answer value after learning
"""
"""forward process
"""
# calculate the state by input values(inputs) and weight(_weight) and(_bias)
state = self._weight.dot(inputs) + self._bias
# calculate output value
self._output = self._activation_func(state)
"""backward process(feedback)
"""
# get answer value by input values
answer = self._get_answer(inputs)
# common coefficient for update parameters
# derivative value of cost function
d_cost_func = self._output - answer
# derivative value of activate function
one_arr = np.empty((0,(self._node_num - 1)), int)
for i in range(0, self._node_num):
one_arr = np.append(one_arr, np.array([[1.]]), axis=0)
d_activate_func = self._output * (one_arr - self._output)
# common coefficient
common_coefficient = d_cost_func * d_activate_func
# update weight
self._weight -= self._rate * common_coefficient * inputs
# update bias
self._bias -= self._rate * common_coefficient
# Difference between output value and correct answer value after learning
diff = self._output - answer
return (np.power(diff[0][0], 2) / 2) + (np.power(diff[1][0], 2) / 2)
def _activation_func(self, state):
"""Activation function
"""
# calculate the output value by the state of neuron(0~1)
# logistic sigmoid
return 1 / (1 + np.exp(-state))
def _get_answer(self, inputs):
"""Get input value of correct answer derived from input value
param: inputs (ndarray): input values
return (integer): 0 or 1
"""
result = []
if self._mode == 1:
# 1input&2output
result = [
[inputs[0][0]],
[0.0 if (inputs[1][0] == 1.0) else 1.0]
]
elif self._mode == 2:
# 2input&2output
result = [
[0.0 if (inputs[inputs == 0.0].size) else 1.0],
[1.0 if (inputs[inputs == 1.0].size) else 0.0]
]
elif self._mode == 3:
# xor
for i in self._answer_matrix:
if i[0] == inputs[0][0] and i[1] == inputs[1][0]:
result = np.array([
[i[2]], [i[3]]
])
return result
def _set_answer(self, input_num):
"""Make and set answer by input num
param: input_num (integer): input number
"""
self._answer_matrix = np.array([
[0., 0., 0., 0.],
[0., 1., 0., 1.],
[1., 0., 0., 1.],
[1., 1., 1., 0.],
])
if __name__ == '__main__':
"""
1: 1input&2output
2: 2input&2output
3: xor
"""
mode = 2
# node num
node_num = 2
# input num
input_num = 2
# learn loop num
learn_num = 100000
# result output interval
interval = 50
# learning
l = Layer(
mode,
node_num,
input_num
)
output_x = []
tmp_y = []
output_y_max = []
output_y_avg = []
output_y_min = []
for i in tqdm(range(0, learn_num)):
x = np.round(np.random.rand(node_num, 1))
diff = l.learn(x)
tmp_y.append(diff)
if i % interval == 0:
# Average, max, min value for each set number of loops
output_y_max.append(max(tmp_y))
output_y_avg.append(sum(tmp_y) / len(tmp_y))
output_y_min.append(min(tmp_y))
tmp_y = []
output_x.append(i+1)
# output
line_max, line_avg, line_min = plt.plot(
output_x, output_y_max, 'r-',
output_x, output_y_avg, 'g-',
output_x, output_y_min, 'b-'
)
plt.legend((line_max, line_avg, line_min), ('$max$', '$avg$', '$min$'))
plt.xlabel('$learn-num$')
plt.ylabel('$diff-learn-value-and-answer$')
plt.show()
In [ ]: