问理解CNN超参数

EN

class layers(ABC): 
    def __init__(self, filter_size, number_of_neurons, fully_conn_neurons):
        self.filter_size = filter_size #placeholder for filter 
        self.number_of_neurons = number_of_neurons #The number of neurons
        self.fully_conn_neurons = fully_conn_neurons #Amount of neurons in the last layer

        return

class new_conv_layer(ABC):
    def __init__(self, filters, number_of_filters, initial_input, namew, nameb, defrel):
        self.filters = filters
        self.number_of_filters = number_of_filters #16 is amount of filters
        self.color_chan = 1
        self.shape = [filters, filters, self.color_chan, number_of_filters]
        self.defrel = False

        self.weight = tf.get_variable(name=namew, shape =self.shape, initializer = tf.initializers.glorot_normal)
        self.bias = tf.Variable(tf.constant(0.05, shape = [number_of_filters], name=nameb))

        self.layer = tf.nn.conv2d(input = initial_input, filter = self.weight, strides=[1,2,2,1], padding="SAME")
        self.layer += self.bias 

        self.layer = tf.nn.max_pool(value=self.layer, ksize = [1,2,2,1], strides = [1,2,2,1], padding="SAME")

        if defrel == True:
            self.layer = tf.nn.relu(self.layer)


    def flatten(self):
        flat_shape = self.layer.shape
        self.features = flat_shape[1:].num_elements()
        self.layer = tf.reshape(self.layer, [-1, self.features])

        return self.layer, self.features

x = tf.placeholder(tf.float32, shape=[None, 784], name='x')
x_image = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 5])



layer1 = new_conv_layer(filters=4,number_of_filters=16, initial_input= x_image, namew ="w", nameb="b", defrel=True)
layer2 = new_conv_layer(filters=4,number_of_filters=32, initial_input=layer1.layer, namew="fuckoff", nameb="fuck", defrel=False)


layer_flat, num_features = layer2.flatten()


class fully_connected(ABC):
    def __init__(self, previous_layer, inp, outp, namea, nameb):

        self.previous_layer = previous_layer
        self.weights = tf.get_variable(shape =[inp, outp], initializer = tf.initializers.glorot_normal, name=namea)
        self.biases = tf.Variable(tf.constant(0.05, shape = [outp], name = nameb))
        self.temp_layer = tf.matmul(self.previous_layer, self.weights) + self.biases
        self.new_layer = tf.nn.relu(self.temp_layer)






layer_fc1 = fully_connected(layer_flat, inp=num_features, outp=128, namea = "t", nameb= "u")
layer_fc2 = fully_connected(layer_fc1.new_layer, inp=128, outp=5, nameb="h", namea="z")



epochs = 300
learning_rate = 0.05
batch_size = 128


pred = tf.nn.softmax(layer_fc2.new_layer)
print(pred.shape)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))


# drop out, regularization 
# call back 

init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init) 
    train_loss = []
    test_loss = []
    train_accuracy = []
    test_accuracy = []
    summary_writer = tf.summary.FileWriter('./Output', sess.graph)
    for i in range(epochs):
        for batch in range(len(train_X)//batch_size):
            batch_x = train_X[batch*batch_size:min((batch+1)*batch_size,len(train_X))]
            batch_y = train_y[batch*batch_size:min((batch+1)*batch_size,len(train_y))]    
            opt = sess.run(optimizer, feed_dict={x: batch_x,
                                                              y: batch_y})
            loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x,
                                                              y: batch_y})
        print("Iter " + str(i) + ", Loss= " + \
                      "{:.6f}".format(loss) + ", Training Accuracy= " + \
                      "{:.5f}".format(acc))
        print("Optimization Finished!")


        test_acc,valid_loss = sess.run([accuracy,cost], feed_dict={x: test_X,y : test_y})
        train_loss.append(loss)
        test_loss.append(valid_loss)
        train_accuracy.append(acc)
        test_accuracy.append(test_acc)
        print("Testing Accuracy:","{:.5f}".format(test_acc))
    summary_writer.close()