def buildNetwork(self):
     """
     Builds the neural network with a fixed structure,
     and a variable number of outputs.
     """
     self.inputLayer = InputLayer()
     convLayer = ConvolutionalLayer(5,10)
     poolLayer = PoolingLayer(4)
     reluLayer = ReluLayer()
     convLayer2 = ConvolutionalLayer(4,20)
     pool2Layer = PoolingLayer(2)
     flattenLayer = FlattenLayer()
     reluLayer2 = ReluLayer()
     fullLayer = FullyConnectedLayer(20)
     self.outputLayer = OutputLayer(self.numOutputs)
     fullLayer.connect(self.outputLayer)
     flattenLayer.connect(fullLayer)
     reluLayer2.connect(flattenLayer)
     pool2Layer.connect(reluLayer2)
     convLayer2.connect(pool2Layer)
     reluLayer.connect(convLayer2)
     poolLayer.connect(reluLayer)
     convLayer.connect(poolLayer)
     self.inputLayer.connect(convLayer)
Beispiel #2
0
n_sample = 500  # Using for Error, Accuracy samples
alpha = 1  # how many times do you want to learn in 1 epoch. if 1, whole data learns.

input_train, input_test, correct_train, correct_test = cifar10_call(N)

n_train = input_train.shape[0]
n_test = input_test.shape[0]

img_h = 32
img_w = 32
img_ch = 3

# -- 각 층의 초기화 --
cl1 = ConvLayer(img_ch, img_h, img_w, 30, 3, 3, stride=1, pad=1)  # 앞3개:인풋 중간3개:필터
cl2 = ConvLayer(cl1.y_ch, cl1.y_h, cl1.y_w, 30, 3, 3, stride=1, pad=1)
pl1 = PoolingLayer(cl2.y_ch, cl2.y_h, cl2.y_w, pool=2, pad=0)  # pool:풀링크기(2*2), pad:패딩 너비
c_dr1 = fn.dropout(0.25)

cl3 = ConvLayer(pl1.y_ch, pl1.y_h, pl1.y_w, 60, 3, 3, stride=1, pad=1)
pl2 = PoolingLayer(cl3.y_ch, cl3.y_h, cl3.y_w, pool=2, pad=0)
c_dr2 = fn.dropout(0.25)

cl4 = ConvLayer(pl2.y_ch, pl2.y_h, pl2.y_w, 120, 3, 3, stride=1, pad=1)
pl3 = PoolingLayer(cl4.y_ch, cl4.y_h, cl4.y_w, pool=2, pad=0)

n_fc_in = pl3.y_ch * pl3.y_h * pl3.y_w
ml1 = MiddleLayer(n_fc_in, 500)
dr1 = fn.dropout(0.5)
ml2 = MiddleLayer(500, 500)
dr2 = fn.dropout(0.5)
ol1 = OutputLayer(500, 10)
Beispiel #3
0
    def __init__(self,  phase, start_from_scratch= False ):
        encoding_t = 10
        self.encoding_t = encoding_t
        self.phase = phase
        path = dirname(dirname(realpath(__file__)))
        self.path_to_img_folder = path + '/datasets/'+ phase + 'Set/'
        classifier_dataset_path = path + '/datasets/ClassifierSet/'
        self.classifier_training_dataset_path = classifier_dataset_path +'TrainingData.csv'
        self.classifier_testing_dataset_path = classifier_dataset_path +'TestingData.csv'
        self.start_from_scratch = start_from_scratch
        self.path_to_log_file = path+ '/logs/log.csv'

        self.pathWeights = path + '/weights/'

        strides_conv= [1,1,1,1]
        padding= "SAME"
        pooling_type= "MAX"

        stdp_flag = phase == 'Learning'

        ''' after 20 img the first layer converges
        the second has some weights around 1 and the others
        are in the initial value range : .68 score 
        encoding_t,.02,-.0,-.02, stdp_flag ),
        encoding_t,.006,-.0,-.002, stdp_flag),
        '''

        '''after some img both layers converges
        with scary simmetry of weights around 0
        and around 1: same number
        score 0.67
        encoding_t,.01,-.0,-.012, stdp_flag ),
        encoding_t,.01,-.0,-.02, stdp_flag),
        maybe try a slower convergence
        '''
        '''
        self.layers = [
            ConvolutionalLayer(padding, strides_conv,
                [5,5,1,4],6.5, [1,160,250,1], [1,160,250,4],
                encoding_t,5,.004,-.0,-.008, stdp_flag ),
            PoolingLayer(padding, [6,6], [7,7], pooling_type, [1,27,42,4]),
            ConvolutionalLayer(padding,strides_conv,
                [17,17,4,20], 35., [1,27,42,4], [1,27,42,20],
                encoding_t,25,.002,-.0,-.004, stdp_flag),
            PoolingLayer(padding, [5,5], [5,5], pooling_type, [1,6,9,20]),
            ConvolutionalLayer(padding, strides_conv,
                [5,5,20,20], math.inf , [1,6,9,20], [1,6,9,20],
                encoding_t,0,.0,-.0,-.0, stdp_flag)
            ]

        '''

        self.layers = [
            ConvolutionalLayer(padding, strides_conv,
                [5,5,1,4],3.7, [1,160,250,1], [1,160,250,4],
                encoding_t,18,.004,-.0,-.008, stdp_flag ),
            PoolingLayer(padding, [6,6], [7,7], pooling_type, [1,27,42,4]),
            ConvolutionalLayer(padding,strides_conv,
                [17,17,4,20], 25., [1,27,42,4], [1,27,42,20],
                encoding_t,28,.002,-.0,-.004, stdp_flag),
            PoolingLayer(padding, [5,5], [5,5], pooling_type, [1,6,9,20]),
            ConvolutionalLayer(padding, strides_conv,
                [5,5,20,20], math.inf , [1,6,9,20], [1,6,9,20],
                encoding_t,0,.0,-.0,-.0, stdp_flag)
            ]

        if start_from_scratch:
            self.writeFeatureNamesinDataset( classifier_dataset_path +'TrainingData.csv')
            self.writeFeatureNamesinDataset( classifier_dataset_path +'TestingData.csv')