GameofLife/Brain_for_learning.py at master · DeepDeducing/GameofLife · GitHub

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
import numpy as np
from scipy.special import expit


class Brain(object):
    def __init__(self, network_size, slope, alpha, epoch_of_learning, drop_rate, momentum_rate):

        self.network_size                 = network_size
        self.number_of_layers             = self.network_size.shape[0]

        self.slope                        = slope
        self.alpha                        = alpha
        self.epoch_of_learning            = epoch_of_learning

        self.weight_list                  = self.initialize_weight_list()
        self.slope_list                   = self.initialize_slope_list()

        self.weight_list_momentum         = np.zeros_like(self.weight_list)
        self.slope_list_momentum          = np.zeros_like(self.slope_list )

        self.drop_rate                    = drop_rate

        self.momentum_rate                = momentum_rate


    def initialize_weight_list(self):
        weight_list = list()
        for i in range(self.number_of_layers - 1):
            weight                                              = (np.random.random((self.network_size[i]                                 , self.network_size[i+1]                          )) -0.5 ) * 0.1
            weight_list.append(weight)
        weight_list = np.asarray(weight_list)
        return  weight_list


    def initialize_slope_list(self):
        slope_list = list()
        for i in range(self.number_of_layers - 1):
            slope                                               = np.ones(self.network_size[i + 1]) * self.slope
            slope_list.append(slope)
        slope_list = np.asarray(slope_list)
        return slope_list


    def activator(self, x):
        return expit(x)


    def activator_output_to_derivative(self, output):
        return output * ( 1 - output)


    def generate_values_for_each_layer(self, input):

        layer_list                = list()

        layer                     = input

        layer_list.append(layer)

        binomial                  = np.atleast_2d(np.random.binomial(1, 1 - self.drop_rate, size=self.network_size[1]))

        layer                     = self.activator(np.dot(layer_list[-1]                          , self.weight_list[0]                                                          ) * self.slope_list[0] ) * binomial

        layer_list.append(layer)

        for i in range(self.number_of_layers - 2):

            layer                 = self.activator(np.dot(layer_list[-1]                          , self.weight_list[i + 1]                                                      ) * self.slope_list[i + 1] )

            layer_list.append(layer)

        return   layer_list


    def train_for_weight(self,
                       layer_list,
                       output):

        layer_delta_list       = list()
        slope_delta_list       = list()

        layer_final_error      = output - layer_list[-1]

        layer_delta            = (layer_final_error                                                                                               )    * self.activator_output_to_derivative(layer_list[-1] )          *   self.slope_list[-1]
        slope_delta            = (layer_final_error                                                                                               )    * self.activator_output_to_derivative(layer_list[-1] )          * np.dot(layer_list[-2], self.weight_list[-1])

        layer_delta_list.append(layer_delta)
        slope_delta_list.append(slope_delta)

        for i in range(self.number_of_layers - 2):

            layer_delta        = (layer_delta_list[-1].dot(self.weight_list[- 1 - i].T                                                         ) )    * self.activator_output_to_derivative(layer_list[- 1 - 1 - i] )  *   self.slope_list[-1 -1 -i]
            slope_delta        = (layer_delta_list[-1].dot(self.weight_list[- 1 - i].T                                                         ) )    * self.activator_output_to_derivative(layer_list[- 1 - 1 - i] )  * np.dot(layer_list[-1 -1 -i -1], self.weight_list[-1 -i -1])

            layer_delta_list.append(layer_delta)
            slope_delta_list.append(slope_delta)

        for i in range(self.number_of_layers - 1):

            self.weight_list[i]                             += np.array(layer_list[i]                                                             ).T.dot(np.array(layer_delta_list[- 1 - i])                                          ) * self.alpha + self.momentum_rate * self.weight_list_momentum[i]
            self.weight_list_momentum[i]                     = np.array(layer_list[i]                                                             ).T.dot(np.array(layer_delta_list[- 1 - i])                                          ) * self.alpha + self.momentum_rate * self.weight_list_momentum[i]
            self.slope_list[i]                              += np.array(slope_delta_list[- 1 - i]).sum(axis=0)                                                                                                                           * self.alpha + self.momentum_rate * self.slope_list_momentum[i]
            self.slope_list_momentum[i]                      = np.array(slope_delta_list[- 1 - i]).sum(axis=0)                                                                                                                           * self.alpha + self.momentum_rate * self.slope_list_momentum[i]


    def learn_batch(self, input_list, output_list):

        layer_list = self.generate_values_for_each_layer(input_list)

        self.train_for_weight(
                   layer_list,
                   output_list)

        return self