python深度学习tensorflow卷积层示例教程

一、旧版本（1.0以下）的卷积函数：tf.nn.conv2d

在tf1.0中，对卷积层重新进行了封装，比原来版本的卷积层有了很大的简化。

conv2d(
   input,
   filter,
   strides,
   padding,
   use_cudnn_on_gpu=None,
   data_format=None,
   name=None
)

该函数定义在tensorflow/python/ops/gen_nn_ops.py。

参数：

input: 一个4维Tensor（N,H,W,C). 类型必须是以下几种类型之一: half, float32, float64.

filter: 卷积核. 类型和input必须相同，

4维tensor, [filter_height, filter_width, in_channels, out_channels],如[5,5,3,32]

strides:  在input上切片采样时，每个方向上的滑窗步长，必须和format指定的维度同阶,如[1, 2, 2, 1]

padding: 指定边缘填充类型: "SAME", "VALID". SAME表示卷积后图片保持不变，VALID则会缩小。

use_cudnn_on_gpu: 可选项，bool型。表示是否在GPU上用cudnn进行加速，默认为True.

data_format: 可选项，指定输入数据的格式: "NHWC"或 "NCHW"， 默认为"NHWC"。

NHWC格式指[batch, in_height, in_width, in_channels]NCHW格式指[batch, in_channels, in_height, in_width]

name: 操作名，可选.

示例

conv1=tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

二、1.0版本中的卷积函数:tf.layers.conv2d

conv2d(
   inputs,
   filters,
   kernel_size,
   strides=(1, 1),
   padding='valid',
   data_format='channels_last',
   dilation_rate=(1, 1),
   activation=None,
   use_bias=True,
   kernel_initializer=None,
   bias_initializer=tf.zeros_initializer(),
   kernel_regularizer=None,
   bias_regularizer=None,
   activity_regularizer=None,
   trainable=True,
   name=None,
   reuse=None
)

定义

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
# pylint: disable=unused-import,g-bad-import-order
"""Contains the convolutional layer classes and their functional aliases.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import six
from six.moves import xrange  # pylint: disable=redefined-builtin
import numpy as np
from tensorflow.python.framework import ops
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import nn
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import init_ops
from tensorflow.python.ops import standard_ops
from tensorflow.python.ops import variable_scope as vs
from tensorflow.python.layers import base
from tensorflow.python.layers import utils
class _Conv(base._Layer):  # pylint: disable=protected-access
 """Abstract nD convolution layer (private, used as implementation base).
 This layer creates a convolution kernel that is convolved
 (actually cross-correlated) with the layer input to produce a tensor of
 outputs. If `use_bias` is True (and a `bias_initializer` is provided),
 a bias vector is created and added to the outputs. Finally, if
 `activation` is not `None`, it is applied to the outputs as well.
 Arguments:
   rank: An integer, the rank of the convolution, e.g. "2" for 2D convolution.
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: An integer or tuple/list of n integers, specifying the
     length of the convolution window.
   strides: An integer or tuple/list of n integers,
     specifying the stride length of the convolution.
     Specifying any stride value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, ..., channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, ...)`.
   dilation_rate: An integer or tuple/list of n integers, specifying
     the dilation rate to use for dilated convolution.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any `strides` value != 1.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
 """
 def __init__(self, rank,
              filters,
              kernel_size,
              strides=1,
              padding='valid',
              data_format='channels_last',
              dilation_rate=1,
              activation=None,
              use_bias=True,
              kernel_initializer=None,
              bias_initializer=init_ops.zeros_initializer(),
              kernel_regularizer=None,
              bias_regularizer=None,
              activity_regularizer=None,
              trainable=True,
              name=None,
              **kwargs):
   super(_Conv, self).__init__(trainable=trainable,
                               name=name, **kwargs)
   self.rank = rank
   self.filters = filters
   self.kernel_size = utils.normalize_tuple(kernel_size, rank, 'kernel_size')
   self.strides = utils.normalize_tuple(strides, rank, 'strides')
   self.padding = utils.normalize_padding(padding)
   self.data_format = utils.normalize_data_format(data_format)
   self.dilation_rate = utils.normalize_tuple(
       dilation_rate, rank, 'dilation_rate')
   self.activation = activation
   self.use_bias = use_bias
   self.kernel_initializer = kernel_initializer
   self.bias_initializer = bias_initializer
   self.kernel_regularizer = kernel_regularizer
   self.bias_regularizer = bias_regularizer
   self.activity_regularizer = activity_regularizer
 def build(self, input_shape):
   if len(input_shape) != self.rank + 2:
     raise ValueError('Inputs should have rank ' +
                      str(self.rank + 2) +
                      'Received input shape:', str(input_shape))
   if self.data_format == 'channels_first':
     channel_axis = 1
   else:
     channel_axis = -1
   if input_shape[channel_axis] is None:
     raise ValueError('The channel dimension of the inputs '
                      'should be defined. Found `None`.')
   input_dim = input_shape[channel_axis]
   kernel_shape = self.kernel_size + (input_dim, self.filters)
   self.kernel = vs.get_variable('kernel',
                                 shape=kernel_shape,
                                 initializer=self.kernel_initializer,
                                 regularizer=self.kernel_regularizer,
                                 trainable=True,
                                 dtype=self.dtype)
   if self.use_bias:
     self.bias = vs.get_variable('bias',
                                 shape=(self.filters,),
                                 initializer=self.bias_initializer,
                                 regularizer=self.bias_regularizer,
                                 trainable=True,
                                 dtype=self.dtype)
   else:
     self.bias = None
 def call(self, inputs):
   outputs = nn.convolution(
       input=inputs,
       filter=self.kernel,
       dilation_rate=self.dilation_rate,
       strides=self.strides,
       padding=self.padding.upper(),
       data_format=utils.convert_data_format(self.data_format, self.rank + 2))
   if self.bias is not None:
     if self.rank != 2 and self.data_format == 'channels_first':
       # bias_add does not support channels_first for non-4D inputs.
       if self.rank == 1:
         bias = array_ops.reshape(self.bias, (1, self.filters, 1))
       if self.rank == 3:
         bias = array_ops.reshape(self.bias, (1, self.filters, 1, 1))
       outputs += bias
     else:
       outputs = nn.bias_add(
           outputs,
           self.bias,
           data_format=utils.convert_data_format(self.data_format, 4))
       # Note that we passed rank=4 because bias_add will only accept
       # NHWC and NCWH even if the rank of the inputs is 3 or 5.
   if self.activation is not None:
     return self.activation(outputs)
   return outputs
class Conv1D(_Conv):
 """1D convolution layer (e.g. temporal convolution).
 This layer creates a convolution kernel that is convolved
 (actually cross-correlated) with the layer input to produce a tensor of
 outputs. If `use_bias` is True (and a `bias_initializer` is provided),
 a bias vector is created and added to the outputs. Finally, if
 `activation` is not `None`, it is applied to the outputs as well.
 Arguments:
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: An integer or tuple/list of a single integer, specifying the
     length of the 1D convolution window.
   strides: An integer or tuple/list of a single integer,
     specifying the stride length of the convolution.
     Specifying any stride value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, length, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, length)`.
   dilation_rate: An integer or tuple/list of a single integer, specifying
     the dilation rate to use for dilated convolution.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any `strides` value != 1.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
 """
 def __init__(self, filters,
              kernel_size,
              strides=1,
              padding='valid',
              data_format='channels_last',
              dilation_rate=1,
              activation=None,
              use_bias=True,
              kernel_initializer=None,
              bias_initializer=init_ops.zeros_initializer(),
              kernel_regularizer=None,
              bias_regularizer=None,
              activity_regularizer=None,
              trainable=True,
              name=None,
              **kwargs):
   super(Convolution1D, self).__init__(
       rank=1,
       filters=filters,
       kernel_size=kernel_size,
       strides=strides,
       padding=padding,
       data_format=data_format,
       dilation_rate=dilation_rate,
       activation=activation,
       use_bias=use_bias,
       kernel_initializer=kernel_initializer,
       bias_initializer=bias_initializer,
       kernel_regularizer=kernel_regularizer,
       bias_regularizer=bias_regularizer,
       activity_regularizer=activity_regularizer,
       trainable=trainable,
       name=name, **kwargs)
def conv1d(inputs,
          filters,
          kernel_size,
          strides=1,
          padding='valid',
          data_format='channels_last',
          dilation_rate=1,
          activation=None,
          use_bias=True,
          kernel_initializer=None,
          bias_initializer=init_ops.zeros_initializer(),
          kernel_regularizer=None,
          bias_regularizer=None,
          activity_regularizer=None,
          trainable=True,
          name=None,
          reuse=None):
 """Functional interface for 1D convolution layer (e.g. temporal convolution).
 This layer creates a convolution kernel that is convolved
 (actually cross-correlated) with the layer input to produce a tensor of
 outputs. If `use_bias` is True (and a `bias_initializer` is provided),
 a bias vector is created and added to the outputs. Finally, if
 `activation` is not `None`, it is applied to the outputs as well.
 Arguments:
   inputs: Tensor input.
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: An integer or tuple/list of a single integer, specifying the
     length of the 1D convolution window.
   strides: An integer or tuple/list of a single integer,
     specifying the stride length of the convolution.
     Specifying any stride value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, length, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, length)`.
   dilation_rate: An integer or tuple/list of a single integer, specifying
     the dilation rate to use for dilated convolution.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any `strides` value != 1.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
   reuse: Boolean, whether to reuse the weights of a previous layer
     by the same name.
 Returns:
   Output tensor.
 """
 layer = Conv1D(
     filters=filters,
     kernel_size=kernel_size,
     strides=strides,
     padding=padding,
     data_format=data_format,
     dilation_rate=dilation_rate,
     activation=activation,
     use_bias=use_bias,
     kernel_initializer=kernel_initializer,
     bias_initializer=bias_initializer,
     kernel_regularizer=kernel_regularizer,
     bias_regularizer=bias_regularizer,
     activity_regularizer=activity_regularizer,
     trainable=trainable,
     name=name,
     _reuse=reuse,
     _scope=name)
 return layer.apply(inputs)
class Conv2D(_Conv):
 """2D convolution layer (e.g. spatial convolution over images).
 This layer creates a convolution kernel that is convolved
 (actually cross-correlated) with the layer input to produce a tensor of
 outputs. If `use_bias` is True (and a `bias_initializer` is provided),
 a bias vector is created and added to the outputs. Finally, if
 `activation` is not `None`, it is applied to the outputs as well.
 Arguments:
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: An integer or tuple/list of 2 integers, specifying the
     width and height of the 2D convolution window.
     Can be a single integer to specify the same value for
     all spatial dimensions.
   strides: An integer or tuple/list of 2 integers,
     specifying the strides of the convolution along the height and width.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Specifying any stride value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, height, width, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, height, width)`.
   dilation_rate: An integer or tuple/list of 2 integers, specifying
     the dilation rate to use for dilated convolution.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any stride value != 1.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
 """
 def __init__(self, filters,
              kernel_size,
              strides=(1, 1),
              padding='valid',
              data_format='channels_last',
              dilation_rate=(1, 1),
              activation=None,
              use_bias=True,
              kernel_initializer=None,
              bias_initializer=init_ops.zeros_initializer(),
              kernel_regularizer=None,
              bias_regularizer=None,
              activity_regularizer=None,
              trainable=True,
              name=None,
              **kwargs):
   super(Conv2D, self).__init__(
       rank=2,
       filters=filters,
       kernel_size=kernel_size,
       strides=strides,
       padding=padding,
       data_format=data_format,
       dilation_rate=dilation_rate,
       activation=activation,
       use_bias=use_bias,
       kernel_initializer=kernel_initializer,
       bias_initializer=bias_initializer,
       kernel_regularizer=kernel_regularizer,
       bias_regularizer=bias_regularizer,
       activity_regularizer=activity_regularizer,
       trainable=trainable,
       name=name, **kwargs)
def conv2d(inputs,
          filters,
          kernel_size,
          strides=(1, 1),
          padding='valid',
          data_format='channels_last',
          dilation_rate=(1, 1),
          activation=None,
          use_bias=True,
          kernel_initializer=None,
          bias_initializer=init_ops.zeros_initializer(),
          kernel_regularizer=None,
          bias_regularizer=None,
          activity_regularizer=None,
          trainable=True,
          name=None,
          reuse=None):
 """Functional interface for the 2D convolution layer.
 This layer creates a convolution kernel that is convolved
 (actually cross-correlated) with the layer input to produce a tensor of
 outputs. If `use_bias` is True (and a `bias_initializer` is provided),
 a bias vector is created and added to the outputs. Finally, if
 `activation` is not `None`, it is applied to the outputs as well.
 Arguments:
   inputs: Tensor input.
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: An integer or tuple/list of 2 integers, specifying the
     width and height of the 2D convolution window.
     Can be a single integer to specify the same value for
     all spatial dimensions.
   strides: An integer or tuple/list of 2 integers,
     specifying the strides of the convolution along the height and width.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Specifying any stride value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, height, width, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, height, width)`.
   dilation_rate: An integer or tuple/list of 2 integers, specifying
     the dilation rate to use for dilated convolution.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any stride value != 1.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
   reuse: Boolean, whether to reuse the weights of a previous layer
     by the same name.
 Returns:
   Output tensor.
 """
 layer = Conv2D(
     filters=filters,
     kernel_size=kernel_size,
     strides=strides,
     padding=padding,
     data_format=data_format,
     dilation_rate=dilation_rate,
     activation=activation,
     use_bias=use_bias,
     kernel_initializer=kernel_initializer,
     bias_initializer=bias_initializer,
     kernel_regularizer=kernel_regularizer,
     bias_regularizer=bias_regularizer,
     activity_regularizer=activity_regularizer,
     trainable=trainable,
     name=name,
     _reuse=reuse,
     _scope=name)
 return layer.apply(inputs)
class Conv3D(_Conv):
 """3D convolution layer (e.g. spatial convolution over volumes).
 This layer creates a convolution kernel that is convolved
 (actually cross-correlated) with the layer input to produce a tensor of
 outputs. If `use_bias` is True (and a `bias_initializer` is provided),
 a bias vector is created and added to the outputs. Finally, if
 `activation` is not `None`, it is applied to the outputs as well.
 Arguments:
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: An integer or tuple/list of 3 integers, specifying the
     depth, height and width of the 3D convolution window.
     Can be a single integer to specify the same value for
     all spatial dimensions.
   strides: An integer or tuple/list of 3 integers,
     specifying the strides of the convolution along the depth,
     height and width.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Specifying any stride value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, depth, height, width, channels)` while `channels_first`
     corresponds to inputs with shape
     `(batch, channels, depth, height, width)`.
   dilation_rate: An integer or tuple/list of 3 integers, specifying
     the dilation rate to use for dilated convolution.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any stride value != 1.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
 """
 def __init__(self, filters,
              kernel_size,
              strides=(1, 1, 1),
              padding='valid',
              data_format='channels_last',
              dilation_rate=(1, 1, 1),
              activation=None,
              use_bias=True,
              kernel_initializer=None,
              bias_initializer=init_ops.zeros_initializer(),
              kernel_regularizer=None,
              bias_regularizer=None,
              activity_regularizer=None,
              trainable=True,
              name=None,
              **kwargs):
   super(Conv3D, self).__init__(
       rank=3,
       filters=filters,
       kernel_size=kernel_size,
       strides=strides,
       padding=padding,
       data_format=data_format,
       dilation_rate=dilation_rate,
       activation=activation,
       use_bias=use_bias,
       kernel_initializer=kernel_initializer,
       bias_initializer=bias_initializer,
       kernel_regularizer=kernel_regularizer,
       bias_regularizer=bias_regularizer,
       activity_regularizer=activity_regularizer,
       trainable=trainable,
       name=name, **kwargs)
def conv3d(inputs,
          filters,
          kernel_size,
          strides=(1, 1, 1),
          padding='valid',
          data_format='channels_last',
          dilation_rate=(1, 1, 1),
          activation=None,
          use_bias=True,
          kernel_initializer=None,
          bias_initializer=init_ops.zeros_initializer(),
          kernel_regularizer=None,
          bias_regularizer=None,
          activity_regularizer=None,
          trainable=True,
          name=None,
          reuse=None):
 """Functional interface for the 3D convolution layer.
 This layer creates a convolution kernel that is convolved
 (actually cross-correlated) with the layer input to produce a tensor of
 outputs. If `use_bias` is True (and a `bias_initializer` is provided),
 a bias vector is created and added to the outputs. Finally, if
 `activation` is not `None`, it is applied to the outputs as well.
 Arguments:
   inputs: Tensor input.
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: An integer or tuple/list of 3 integers, specifying the
     depth, height and width of the 3D convolution window.
     Can be a single integer to specify the same value for
     all spatial dimensions.
   strides: An integer or tuple/list of 3 integers,
     specifying the strides of the convolution along the depth,
     height and width.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Specifying any stride value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, depth, height, width, channels)` while `channels_first`
     corresponds to inputs with shape
     `(batch, channels, depth, height, width)`.
   dilation_rate: An integer or tuple/list of 3 integers, specifying
     the dilation rate to use for dilated convolution.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any stride value != 1.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
   reuse: Boolean, whether to reuse the weights of a previous layer
     by the same name.
 Returns:
   Output tensor.
 """
 layer = Conv3D(
     filters=filters,
     kernel_size=kernel_size,
     strides=strides,
     padding=padding,
     data_format=data_format,
     dilation_rate=dilation_rate,
     activation=activation,
     use_bias=use_bias,
     kernel_initializer=kernel_initializer,
     bias_initializer=bias_initializer,
     kernel_regularizer=kernel_regularizer,
     bias_regularizer=bias_regularizer,
     activity_regularizer=activity_regularizer,
     trainable=trainable,
     name=name,
     _reuse=reuse,
     _scope=name)
 return layer.apply(inputs)
class SeparableConv2D(Conv2D):
 """Depthwise separable 2D convolution.
 This layer performs a depthwise convolution that acts separately on
 channels, followed by a pointwise convolution that mixes channels.
 If `use_bias` is True and a bias initializer is provided,
 it adds a bias vector to the output.
 It then optionally applies an activation function to produce the final output.
 Arguments:
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: A tuple or list of 2 integers specifying the spatial
     dimensions of of the filters. Can be a single integer to specify the same
     value for all spatial dimensions.
   strides: A tuple or list of 2 positive integers specifying the strides
     of the convolution. Can be a single integer to specify the same value for
     all spatial dimensions.
     Specifying any `stride` value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, height, width, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, height, width)`.
   dilation_rate: An integer or tuple/list of 2 integers, specifying
     the dilation rate to use for dilated convolution.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any stride value != 1.
   depth_multiplier: The number of depthwise convolution output channels for
     each input channel. The total number of depthwise convolution output
     channels will be equal to `num_filters_in * depth_multiplier`.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   depthwise_initializer: An initializer for the depthwise convolution kernel.
   pointwise_initializer: An initializer for the pointwise convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   depthwise_regularizer: Optional regularizer for the depthwise
     convolution kernel.
   pointwise_regularizer: Optional regularizer for the pointwise
     convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
 """
 def __init__(self, filters,
              kernel_size,
              strides=(1, 1),
              padding='valid',
              data_format='channels_last',
              dilation_rate=(1, 1),
              depth_multiplier=1,
              activation=None,
              use_bias=True,
              depthwise_initializer=None,
              pointwise_initializer=None,
              bias_initializer=init_ops.zeros_initializer(),
              depthwise_regularizer=None,
              pointwise_regularizer=None,
              bias_regularizer=None,
              activity_regularizer=None,
              trainable=True,
              name=None,
              **kwargs):
   super(SeparableConv2D, self).__init__(
       filters=filters,
       kernel_size=kernel_size,
       strides=strides,
       padding=padding,
       data_format=data_format,
       dilation_rate=dilation_rate,
       activation=activation,
       use_bias=use_bias,
       bias_regularizer=bias_regularizer,
       activity_regularizer=activity_regularizer,
       trainable=trainable,
       name=name,
       **kwargs)
   self.depth_multiplier = depth_multiplier
   self.depthwise_initializer = depthwise_initializer
   self.pointwise_initializer = pointwise_initializer
   self.depthwise_regularizer = depthwise_regularizer
   self.pointwise_regularizer = pointwise_regularizer
 def build(self, input_shape):
   if len(input_shape) < 4:
     raise ValueError('Inputs to `SeparableConv2D` should have rank 4. '
                      'Received input shape:', str(input_shape))
   if self.data_format == 'channels_first':
     channel_axis = 1
   else:
     channel_axis = 3
   if input_shape[channel_axis] is None:
     raise ValueError('The channel dimension of the inputs to '
                      '`SeparableConv2D` '
                      'should be defined. Found `None`.')
   input_dim = int(input_shape[channel_axis])
   depthwise_kernel_shape = (self.kernel_size[0],
                             self.kernel_size[1],
                             input_dim,
                             self.depth_multiplier)
   pointwise_kernel_shape = (1, 1,
                             self.depth_multiplier * input_dim,
                             self.filters)
   self.depthwise_kernel = vs.get_variable(
       'depthwise_kernel',
       shape=depthwise_kernel_shape,
       initializer=self.depthwise_initializer,
       regularizer=self.depthwise_regularizer,
       trainable=True,
       dtype=self.dtype)
   self.pointwise_kernel = vs.get_variable(
       'pointwise_kernel',
       shape=pointwise_kernel_shape,
       initializer=self.pointwise_initializer,
       regularizer=self.pointwise_regularizer,
       trainable=True,
       dtype=self.dtype)
   if self.use_bias:
     self.bias = vs.get_variable('bias',
                                 shape=(self.filters,),
                                 initializer=self.bias_initializer,
                                 regularizer=self.bias_regularizer,
                                 trainable=True,
                                 dtype=self.dtype)
   else:
     self.bias = None
 def call(self, inputs):
   if self.data_format == 'channels_first':
     # Reshape to channels last
     inputs = array_ops.transpose(inputs, (0, 2, 3, 1))
   # Apply the actual ops.
   outputs = nn.separable_conv2d(
       inputs,
       self.depthwise_kernel,
       self.pointwise_kernel,
       strides=(1,) + self.strides + (1,),
       padding=self.padding.upper(),
       rate=self.dilation_rate)
   if self.data_format == 'channels_first':
     # Reshape to channels first
     outputs = array_ops.transpose(outputs, (0, 3, 1, 2))
   if self.bias is not None:
     outputs = nn.bias_add(
         outputs,
         self.bias,
         data_format=utils.convert_data_format(self.data_format, ndim=4))
   if self.activation is not None:
     return self.activation(outputs)
   return outputs
def separable_conv2d(inputs,
                    filters,
                    kernel_size,
                    strides=(1, 1),
                    padding='valid',
                    data_format='channels_last',
                    dilation_rate=(1, 1),
                    depth_multiplier=1,
                    activation=None,
                    use_bias=True,
                    depthwise_initializer=None,
                    pointwise_initializer=None,
                    bias_initializer=init_ops.zeros_initializer(),
                    depthwise_regularizer=None,
                    pointwise_regularizer=None,
                    bias_regularizer=None,
                    activity_regularizer=None,
                    trainable=True,
                    name=None,
                    reuse=None):
 """Functional interface for the depthwise separable 2D convolution layer.
 This layer performs a depthwise convolution that acts separately on
 channels, followed by a pointwise convolution that mixes channels.
 If `use_bias` is True and a bias initializer is provided,
 it adds a bias vector to the output.
 It then optionally applies an activation function to produce the final output.
 Arguments:
   inputs: Input tensor.
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: A tuple or list of 2 integers specifying the spatial
     dimensions of of the filters. Can be a single integer to specify the same
     value for all spatial dimensions.
   strides: A tuple or list of 2 positive integers specifying the strides
     of the convolution. Can be a single integer to specify the same value for
     all spatial dimensions.
     Specifying any `stride` value != 1 is incompatible with specifying
     any `dilation_rate` value != 1.
   padding: One of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, height, width, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, height, width)`.
   dilation_rate: An integer or tuple/list of 2 integers, specifying
     the dilation rate to use for dilated convolution.
     Can be a single integer to specify the same value for
     all spatial dimensions.
     Currently, specifying any `dilation_rate` value != 1 is
     incompatible with specifying any stride value != 1.
   depth_multiplier: The number of depthwise convolution output channels for
     each input channel. The total number of depthwise convolution output
     channels will be equal to `num_filters_in * depth_multiplier`.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   depthwise_initializer: An initializer for the depthwise convolution kernel.
   pointwise_initializer: An initializer for the pointwise convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   depthwise_regularizer: Optional regularizer for the depthwise
     convolution kernel.
   pointwise_regularizer: Optional regularizer for the pointwise
     convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
   reuse: Boolean, whether to reuse the weights of a previous layer
     by the same name.
 Returns:
   Output tensor.
 """
 layer = SeparableConv2D(
     filters=filters,
     kernel_size=kernel_size,
     strides=strides,
     padding=padding,
     data_format=data_format,
     dilation_rate=dilation_rate,
     depth_multiplier=depth_multiplier,
     activation=activation,
     use_bias=use_bias,
     depthwise_initializer=depthwise_initializer,
     pointwise_initializer=pointwise_initializer,
     bias_initializer=bias_initializer,
     depthwise_regularizer=depthwise_regularizer,
     pointwise_regularizer=pointwise_regularizer,
     bias_regularizer=bias_regularizer,
     activity_regularizer=activity_regularizer,
     trainable=trainable,
     name=name,
     _reuse=reuse,
     _scope=name)
 return layer.apply(inputs)
class Conv2DTranspose(Conv2D):
 """Transposed convolution layer (sometimes called Deconvolution).
 The need for transposed convolutions generally arises
 from the desire to use a transformation going in the opposite direction
 of a normal convolution, i.e., from something that has the shape of the
 output of some convolution to something that has the shape of its input
 while maintaining a connectivity pattern that is compatible with
 said convolution.
 Arguments:
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: A tuple or list of 2 positive integers specifying the spatial
     dimensions of of the filters. Can be a single integer to specify the same
     value for all spatial dimensions.
   strides: A tuple or list of 2 positive integers specifying the strides
     of the convolution. Can be a single integer to specify the same value for
     all spatial dimensions.
   padding: one of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, height, width, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, height, width)`.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
 """
 def __init__(self, filters,
              kernel_size,
              strides=(1, 1),
              padding='valid',
              data_format='channels_last',
              activation=None,
              use_bias=True,
              kernel_initializer=None,
              bias_initializer=init_ops.zeros_initializer(),
              kernel_regularizer=None,
              bias_regularizer=None,
              activity_regularizer=None,
              trainable=True,
              name=None,
              **kwargs):
   super(Conv2DTranspose, self).__init__(
       filters,
       kernel_size,
       strides=strides,
       padding=padding,
       data_format=data_format,
       activation=activation,
       use_bias=use_bias,
       kernel_initializer=kernel_initializer,
       bias_initializer=bias_initializer,
       kernel_regularizer=kernel_regularizer,
       bias_regularizer=bias_regularizer,
       activity_regularizer=activity_regularizer,
       trainable=trainable,
       name=name,
       **kwargs)
 def build(self, input_shape):
   if len(input_shape) != 4:
     raise ValueError('Inputs should have rank ' +
                      str(4) +
                      'Received input shape:', str(input_shape))
   if self.data_format == 'channels_first':
     channel_axis = 1
   else:
     channel_axis = -1
   if input_shape[channel_axis] is None:
     raise ValueError('The channel dimension of the inputs '
                      'should be defined. Found `None`.')
   input_dim = input_shape[channel_axis]
   kernel_shape = self.kernel_size + (self.filters, input_dim)
   self.kernel = vs.get_variable('kernel',
                                 shape=kernel_shape,
                                 initializer=self.kernel_initializer,
                                 regularizer=self.kernel_regularizer,
                                 trainable=True,
                                 dtype=self.dtype)
   if self.use_bias:
     self.bias = vs.get_variable('bias',
                                 shape=(self.filters,),
                                 initializer=self.bias_initializer,
                                 regularizer=self.bias_regularizer,
                                 trainable=True,
                                 dtype=self.dtype)
   else:
     self.bias = None
 def call(self, inputs):
   inputs_shape = array_ops.shape(inputs)
   batch_size = inputs_shape[0]
   if self.data_format == 'channels_first':
     c_axis, h_axis, w_axis = 1, 2, 3
   else:
     c_axis, h_axis, w_axis = 3, 1, 2
   height, width = inputs_shape[h_axis], inputs_shape[w_axis]
   kernel_h, kernel_w = self.kernel_size
   stride_h, stride_w = self.strides
   def get_deconv_dim(dim_size, stride_size, kernel_size, padding):
     if isinstance(dim_size, ops.Tensor):
       dim_size = math_ops.multiply(dim_size, stride_size)
     elif dim_size is not None:
       dim_size *= stride_size
     if padding == 'valid' and dim_size is not None:
       dim_size += max(kernel_size - stride_size, 0)
     return dim_size
   # Infer the dynamic output shape:
   out_height = get_deconv_dim(height, stride_h, kernel_h, self.padding)
   out_width = get_deconv_dim(width, stride_w, kernel_w, self.padding)
   if self.data_format == 'channels_first':
     output_shape = (batch_size, self.filters, out_height, out_width)
     strides = (1, 1, stride_h, stride_w)
   else:
     output_shape = (batch_size, out_height, out_width, self.filters)
     strides = (1, stride_h, stride_w, 1)
   output_shape_tensor = array_ops.stack(output_shape)
   outputs = nn.conv2d_transpose(
       inputs,
       self.kernel,
       output_shape_tensor,
       strides,
       padding=self.padding.upper(),
       data_format=utils.convert_data_format(self.data_format, ndim=4))
   # Infer the static output shape:
   out_shape = inputs.get_shape().as_list()
   out_shape[c_axis] = self.filters
   out_shape[h_axis] = get_deconv_dim(
       out_shape[h_axis], stride_h, kernel_h, self.padding)
   out_shape[w_axis] = get_deconv_dim(
       out_shape[w_axis], stride_w, kernel_w, self.padding)
   outputs.set_shape(out_shape)
   if self.bias:
     outputs = nn.bias_add(
         outputs,
         self.bias,
         data_format=utils.convert_data_format(self.data_format, ndim=4))
   if self.activation is not None:
     return self.activation(outputs)
   return outputs
def conv2d_transpose(inputs,
                    filters,
                    kernel_size,
                    strides=(1, 1),
                    padding='valid',
                    data_format='channels_last',
                    activation=None,
                    use_bias=True,
                    kernel_initializer=None,
                    bias_initializer=init_ops.zeros_initializer(),
                    kernel_regularizer=None,
                    bias_regularizer=None,
                    activity_regularizer=None,
                    trainable=True,
                    name=None,
                    reuse=None):
 """Transposed convolution layer (sometimes called Deconvolution).
 The need for transposed convolutions generally arises
 from the desire to use a transformation going in the opposite direction
 of a normal convolution, i.e., from something that has the shape of the
 output of some convolution to something that has the shape of its input
 while maintaining a connectivity pattern that is compatible with
 said convolution.
 Arguments:
   inputs: Input tensor.
   filters: Integer, the dimensionality of the output space (i.e. the number
     of filters in the convolution).
   kernel_size: A tuple or list of 2 positive integers specifying the spatial
     dimensions of of the filters. Can be a single integer to specify the same
     value for all spatial dimensions.
   strides: A tuple or list of 2 positive integers specifying the strides
     of the convolution. Can be a single integer to specify the same value for
     all spatial dimensions.
   padding: one of `"valid"` or `"same"` (case-insensitive).
   data_format: A string, one of `channels_last` (default) or `channels_first`.
     The ordering of the dimensions in the inputs.
     `channels_last` corresponds to inputs with shape
     `(batch, height, width, channels)` while `channels_first` corresponds to
     inputs with shape `(batch, channels, height, width)`.
   activation: Activation function. Set it to None to maintain a
     linear activation.
   use_bias: Boolean, whether the layer uses a bias.
   kernel_initializer: An initializer for the convolution kernel.
   bias_initializer: An initializer for the bias vector. If None, no bias will
     be applied.
   kernel_regularizer: Optional regularizer for the convolution kernel.
   bias_regularizer: Optional regularizer for the bias vector.
   activity_regularizer: Regularizer function for the output.
   trainable: Boolean, if `True` also add variables to the graph collection
     `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`).
   name: A string, the name of the layer.
   reuse: Boolean, whether to reuse the weights of a previous layer
     by the same name.
 Returns:
   Output tensor.
 """
 layer = Conv2DTranspose(
     filters=filters,
     kernel_size=kernel_size,
     strides=strides,
     padding=padding,
     data_format=data_format,
     activation=activation,
     use_bias=use_bias,
     kernel_initializer=kernel_initializer,
     bias_initializer=bias_initializer,
     kernel_regularizer=kernel_regularizer,
     bias_regularizer=bias_regularizer,
     activity_regularizer=activity_regularizer,
     trainable=trainable,
     name=name,
     _reuse=reuse,
     _scope=name)
 return layer.apply(inputs)
# Aliases
Convolution1D = Conv1D
Convolution2D = Conv2D
Convolution3D = Conv3D
SeparableConvolution2D = SeparableConv2D
Convolution2DTranspose = Deconvolution2D = Deconv2D = Conv2DTranspose
convolution1d = conv1d
convolution2d = conv2d
convolution3d = conv3d
separable_convolution2d = separable_conv2d
convolution2d_transpose = deconvolution2d = deconv2d = conv2d_transpose

参数：

参数多了很多，但实际用起来，却更简单。

inputs: 输入数据，4维tensor.

filters: 卷积核个数。

kernel_size:卷积核大小，如【5，5】。如果长宽相等，也可以直接设置为一个数，如kernel_size=5

strides: 卷积过程中的滑动步长，默认为[1,1]. 也可以直接设置为一个数，如strides=2

padding: 边缘填充，'same' 和'valid&lsquo;选其一。默认为valid

data_format: 输入数据格式，默认为channels_last ，

即 (batch, height, width, channels),也可以设置为channels_first 对应 (batch, channels, height, width).

dilation_rate: 微步长卷积，这个比较复杂一些，请百度.

activation: 激活函数.

use_bias: Boolean型，是否使用偏置项.

kernel_initializer: 卷积核的初始化器.

bias_initializer: 偏置项的初始化器，默认初始化为0.

kernel_regularizer: 卷积核化的正则化，可选.

bias_regularizer: 偏置项的正则化，可选.

activity_regularizer: 输出的正则化函数.

trainable: Boolean型，表明该层的参数是否参与训练。

如果为真则变量加入到图集合中 GraphKeys.TRAINABLE_VARIABLES (see tf.Variable).

name: 层的名字.

reuse: Boolean型, 是否重复使用参数.

示例

conv1=tf.layers.conv2d(
     inputs=x,
     filters=32,
     kernel_size=5,
     padding="same",
     activation=tf.nn.relu,
     kernel_initializer=tf.TruncatedNormal(stddev=0.01))

更复杂一点的

conv1 = tf.layers.conv2d(batch_images,
                        filters=64,
                        kernel_size=7,
                        strides=2,
                        activation=tf.nn.relu,
                        kernel_initializer=tf.TruncatedNormal(stddev=0.01)
                        bias_initializer=tf.Constant(0.1),
                        kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003),
                        bias_regularizer=tf.contrib.layers.l2_regularizer(0.003),
                        name='conv1')

来源：https://www.cnblogs.com/denny402/p/6932186.html