'Create the layers of the model from self.layers.
:param n_classes: number of classes
:return: self'

def _create_layers(self, n_classes):

    next_layer_feed = tf.reshape(self.input_data, [(-1), self.original_shape[0], self.original_shape[1], self.original_shape[2]])
    prev_output_dim = self.original_shape[2]
    first_full = True
    self.W_vars = []
    self.B_vars = []
    for (i, l) in enumerate(self.layers.split(',')):
        node = l.split('-')
        node_type = node[0]
        if (node_type == 'conv2d'):
            (fx, fy, feature_maps, stride) = (int(node[1]), int(node[2]), int(node[3]), int(node[4]))
            print(('Building    Convolutional    layer    with    %d    input    channels                                                                                        and    %d    %dx%d    filters    with    stride    %d' % (prev_output_dim, feature_maps, fx, fy, stride)))
            W_conv = self.weight_variable([fx, fy, prev_output_dim, feature_maps])
            b_conv = self.bias_variable([feature_maps])
            self.W_vars.append(W_conv)
            self.B_vars.append(b_conv)
            h_conv = tf.nn.relu((self.conv2d(next_layer_feed, W_conv, stride) + b_conv))
            prev_output_dim = feature_maps
            next_layer_feed = h_conv
        elif (node_type == 'maxpool'):
            ksize = int(node[1])
            print(('Building    Max    Pooling    layer    with    size    %d' % ksize))
            next_layer_feed = self.max_pool(next_layer_feed, ksize)
        elif (node_type == 'full'):
            if first_full:
                dim = int(node[1])
                shp = next_layer_feed.get_shape()
                tmpx = shp[1].value
                tmpy = shp[2].value
                fanin = ((tmpx * tmpy) * prev_output_dim)
                print(('Building    fully    connected    layer    with    %d    in    units                                                                                                        and    %d    out    units' % (fanin, dim)))
                W_fc = self.weight_variable([fanin, dim])
                b_fc = self.bias_variable([dim])
                self.W_vars.append(W_fc)
                self.B_vars.append(b_fc)
                h_pool_flat = tf.reshape(next_layer_feed, [(-1), fanin])
                h_fc = tf.nn.relu(tf.add(tf.matmul(h_pool_flat, W_fc), b_fc))
                h_fc_drop = tf.nn.dropout(h_fc, self.keep_prob)
                prev_output_dim = dim
                next_layer_feed = h_fc_drop
                first_full = False
            else:
                dim = int(node[1])
                W_fc = self.weight_variable([prev_output_dim, dim])
                b_fc = self.bias_variable([dim])
                self.W_vars.append(W_fc)
                self.B_vars.append(b_fc)
                h_fc = tf.nn.relu(tf.add(tf.matmul(next_layer_feed, W_fc), b_fc))
                h_fc_drop = tf.nn.dropout(h_fc, self.keep_prob)
                prev_output_dim = dim
                next_layer_feed = h_fc_drop
        elif (node_type == 'softmax'):
            print(('Building    softmax    layer    with    %d    in    units    and                                                                                        %d    out    units' % (prev_output_dim, n_classes)))
            W_sm = self.weight_variable([prev_output_dim, n_classes])
            b_sm = self.bias_variable([n_classes])
            self.W_vars.append(W_sm)
            self.B_vars.append(b_sm)
            self.mod_y = tf.add(tf.matmul(next_layer_feed, W_sm), b_sm)
