Форум программистов, компьютерный форум, киберфорум
Наши страницы
Konst2016
Войти
Регистрация
Восстановить пароль
Оценить эту запись

Две реализации нейросети на Python

Запись от Konst2016 размещена 03.05.2019 в 20:39

Здравствуйте!Хочу предложить посмотреть код где я сделал сначала простую нейросеть из трех слоев без постороннего пакета затем такую же нейросеть с пакетом Keras.Сеть должна эмулировать логическое ИЛИ:
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
"""
   Трехслойный перпецетрон
"""
InputN=4 # Входные нейроны
OutN=1   # Выходные нейроны
 
InputW=2 # Веса на входе
OutW=4   # Веса на выходе
 
import numpy as np
 
class NN:
 
  def nonlin(self,x,deriv=False):
  
     if deriv==True:
           return x*(1-x)
 
     return 1 / (1+np.exp(-x))
   
  def __init__(self):
 
     self.INPUT_RESULT=None
     self.OUTPUT_RESULT=None
   
     self.OUTPUT_ERROR=None
     self.INPUT_ERROR=None
 
     self.etta=0.001
  
     self.init_net()
  
  def  init_net(self):
    
     """
       Трехслойный перпецетрон
       1слой-2 нейрона.
       2слой-4 нейрона.
       3слой-1 нейрон.
 
 
               o
 
        ->  o  o
                   o->
        ->  o  o
 
               o
  
     """
   
     self.INPUT_W=np.random.normal(0,1,(InputN,InputW)) # Входной слой
     self.OUTPUT_W=np.random.normal(0,1,(OutN,OutW))    # Выходной слой
    
  def DirectMotion(self,_vector:list):
 
     assert (len(_vector)==InputW)
 
     vector=self.getListAsNumpyArray(_vector)
 
     self.INPUT_RESULT=self.nonlin(np.dot(self.INPUT_W,vector.T))
     
     self.OUTPUT_RESULT=self.nonlin(np.dot(self.OUTPUT_W,self.INPUT_RESULT))
 
  def getListAsNumpyArray(self,_list):
   
    return np.array([_list])
 
  def calculate_global_error(self):
 
     return np.mean(np.abs(self.OUTPUT_ERROR))
   
 
  def BackPropaganation(self,vector:list, target:list):
  
      assert (len(target)==OutN)
 
      """
         Прямой проход
      """
      self.DirectMotion(vector)
 
      """
           Расчет ошибки 
      """
      # Ошибка на выходе
      self.OUTPUT_ERROR=self.getListAsNumpyArray(target)-self.OUTPUT_RESULT
      # Ошибка на входе
      self.INPUT_ERROR=np.dot(self.OUTPUT_ERROR,self.OUTPUT_W)
 
      """
         Коррекция ошибки
      """
      # Входной слой
      vector=self.getListAsNumpyArray(vector)
      self.INPUT_W+=( vector* self.INPUT_ERROR.T*self.etta)
      # Выходной слой
      self.OUTPUT_W+=(self.OUTPUT_ERROR*self.etta)
 
      return self.calculate_global_error()
 
  def Learn(self,Epocha:int,etta:float,trainSet:list):
    
     Error=0.0
 
     Iteration:int=0
  
     while(Iteration< Epocha):
      
       for vector,target in trainSet:
            """
              Переберет все случаи train set-а, затем начнется новая эпоха
            """
            assert (isinstance((vector,target),tuple))
            assert (isinstance(vector,list))
            assert (isinstance(target,list))
 
 
            Error=self.BackPropaganation(vector,target)
       if Iteration % 1000==0:
 
          print(Error)
           
 
       Iteration+=1 
 
def createNN()->NN:
 
  return NN()     
def test():
 
   NN=createNN()
   trainSet=[([0,0],[0]),([1,1],[1]),([0,1],[1]),([1,0],[1])]
 
   NN.Learn(25000,0.07,trainSet)  
 
if __name__=='__main__':
   test()
Средняя квадратичная ошибка:
Bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
0.16529706514
0.141518413373
0.142477005017
0.152662134786
0.161604121732
0.166063921167
0.16717547965
0.166562015689
0.165237059797
0.163698880813
0.162167272241
0.160733434136
0.159432645221
0.158275573465
0.157261171164
0.156382217843
0.155628090626
0.154986441803
0.154444340811
0.153989063667
0.153608610242
0.153292008116
0.153029456484
0.152812357569
0.152633274646
Другой вариант:
Bash
1
2
3
4
5
rem train_set_to_learn_or_op.csv
0,0,1
1,1,1
0,1,1
1,0,1
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import numpy as np
from keras.models import Sequential
from keras.layers import Dense
 
data_common=None
 
def prepare_data_common(_file:str,delimiter:str)->np.ndarray:
 
  return np.genfromtxt(_file,delimiter=delimiter)
 
 
data_common=prepare_data_common('train_set_to_learn_or_op.csv',',')
 
 
def getVector()->np.ndarray:
   
   return data_common[:,0:2]
 
print(getVector())
 
def getTarget()->np.ndarray:
  
   return data_common[:,-1]
 
 
def create_and_learn_model()->Sequential:
 
  model=Sequential()
  
  """
     Трехслойный перпецетрон
     1слой-2 нейрона.
     2слой-4 нейрона.
     3слой-1 нейрон.
 
 
             o
 
      ->  o  o
                 o->
      ->  o  o
 
             o
  """
  model.add(Dense(4,input_dim=2,activation='sigmoid'))
 
  model.add(Dense(1,activation='sigmoid'))
 
  model.compile(optimizer='adam',loss='mse',metrics=['mae'])
  """
     Обучение
  """
  model.fit(getVector(),getTarget(),batch_size=200,epochs=25,validation_split=0.2,verbose=2)
 
  get_model_summary(model) 
 
  return model
 
def get_model_summary(model:Sequential):
 
  return  model.summary()
 
 
 
def save_model(_file:str):
 
  model=create_and_learn_model()
 
  model_json=model.to_json()
 
  with open(_file,'w') as f:
    f.write(model_json)
 
create_and_learn_model()
Средняя квадратичная ошибка:
Bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
Train on 3 samples, validate on 1 samples
Epoch 1/25
 - 0s - loss: 0.3115 - mean_absolute_error: 0.5579 - val_loss: 0.2687 - val_mean
_absolute_error: 0.5184
Epoch 2/25
 - 0s - loss: 0.3105 - mean_absolute_error: 0.5570 - val_loss: 0.2679 - val_mean
_absolute_error: 0.5176
Epoch 3/25
 - 0s - loss: 0.3094 - mean_absolute_error: 0.5560 - val_loss: 0.2670 - val_mean
_absolute_error: 0.5167
Epoch 4/25
 - 0s - loss: 0.3084 - mean_absolute_error: 0.5551 - val_loss: 0.2661 - val_mean
_absolute_error: 0.5158
Epoch 5/25
 - 0s - loss: 0.3074 - mean_absolute_error: 0.5542 - val_loss: 0.2652 - val_mean
_absolute_error: 0.5150
Epoch 6/25
 - 0s - loss: 0.3063 - mean_absolute_error: 0.5532 - val_loss: 0.2643 - val_mean
_absolute_error: 0.5141
Epoch 7/25
 - 0s - loss: 0.3053 - mean_absolute_error: 0.5523 - val_loss: 0.2635 - val_mean
_absolute_error: 0.5133
Epoch 8/25
 - 0s - loss: 0.3043 - mean_absolute_error: 0.5514 - val_loss: 0.2626 - val_mean
_absolute_error: 0.5124
Epoch 9/25
 - 0s - loss: 0.3033 - mean_absolute_error: 0.5505 - val_loss: 0.2617 - val_mean
_absolute_error: 0.5116
Epoch 10/25
 - 0s - loss: 0.3022 - mean_absolute_error: 0.5495 - val_loss: 0.2608 - val_mean
_absolute_error: 0.5107
Epoch 11/25
 - 0s - loss: 0.3012 - mean_absolute_error: 0.5486 - val_loss: 0.2600 - val_mean
_absolute_error: 0.5099
Epoch 12/25
 - 0s - loss: 0.3002 - mean_absolute_error: 0.5477 - val_loss: 0.2591 - val_mean
_absolute_error: 0.5090
Epoch 13/25
 - 0s - loss: 0.2992 - mean_absolute_error: 0.5467 - val_loss: 0.2582 - val_mean
_absolute_error: 0.5082
Epoch 14/25
 - 0s - loss: 0.2982 - mean_absolute_error: 0.5458 - val_loss: 0.2574 - val_mean
_absolute_error: 0.5073
Epoch 15/25
 - 0s - loss: 0.2972 - mean_absolute_error: 0.5449 - val_loss: 0.2565 - val_mean
_absolute_error: 0.5065
Epoch 16/25
 - 0s - loss: 0.2961 - mean_absolute_error: 0.5439 - val_loss: 0.2556 - val_mean
_absolute_error: 0.5056
Epoch 17/25
 - 0s - loss: 0.2951 - mean_absolute_error: 0.5430 - val_loss: 0.2548 - val_mean
_absolute_error: 0.5047
Epoch 18/25
 - 0s - loss: 0.2941 - mean_absolute_error: 0.5421 - val_loss: 0.2539 - val_mean
_absolute_error: 0.5039
Epoch 19/25
 - 0s - loss: 0.2931 - mean_absolute_error: 0.5412 - val_loss: 0.2531 - val_mean
_absolute_error: 0.5030
Epoch 20/25
 - 0s - loss: 0.2921 - mean_absolute_error: 0.5402 - val_loss: 0.2522 - val_mean
_absolute_error: 0.5022
Epoch 21/25
 - 0s - loss: 0.2911 - mean_absolute_error: 0.5393 - val_loss: 0.2513 - val_mean
_absolute_error: 0.5013
Epoch 22/25
 - 0s - loss: 0.2901 - mean_absolute_error: 0.5384 - val_loss: 0.2505 - val_mean
_absolute_error: 0.5005
Epoch 23/25
 - 0s - loss: 0.2891 - mean_absolute_error: 0.5374 - val_loss: 0.2496 - val_mean
_absolute_error: 0.4996
Epoch 24/25
 - 0s - loss: 0.2881 - mean_absolute_error: 0.5365 - val_loss: 0.2488 - val_mean
_absolute_error: 0.4988
Epoch 25/25
 - 0s - loss: 0.2871 - mean_absolute_error: 0.5356 - val_loss: 0.2479 - val_mean
_absolute_error: 0.4979
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
dense_1 (Dense)              (None, 4)                 12
_________________________________________________________________
dense_2 (Dense)              (None, 1)                 5
=================================================================
Total params: 17
Trainable params: 17
Non-trainable params: 0
_________________________________________________________________
Размещено в Без категории
Просмотров 138 Комментарии 0
Всего комментариев 0
Комментарии
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.
Рейтинг@Mail.ru