pycuda安装

pip install numba -i https://pypi.tuna.tsinghua.edu.cn/simple

先决条件:
1.要先安装 NVIDIA 官网中,cuda 的程序包:cuda_10.2.89_441.22_win10.exe
1.1 下载网址:https://developer.nvidia.com/cuda-downloads?target_os=Windows&amp%253Btarget_arch=x86_64&amp%253Btarget_version=10%255C&target_arch=x86_64
1.2 安装cuda的时候,不能选中 cuda下的vs,否则会报安装失败

2.要安装 cuda 程序包,前提是要安装 visual studio, 这次安装的是2017 社区版

上面2条先决条件弄好之后,下面这条命令就能成功安装:
pip install pycuda -i https://pypi.tuna.tsinghua.edu.cn/simple

参考文档:
https://blog.csdn.net/qq_32751937/article/details/83084804
结合 N卡官网:https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=7

https://blog.csdn.net/chantor7/article/details/79182848

 

[cygwin] 简单的文件移动归整shell脚本

# "df -h" to get the correct path

PATH=/cygdrive/e/download/20180322

DESTDIR=/cygdrive/e/download/collect

/usr/bin/mkdir.exe -p $DESTDIR

#cnt=0
for dirname in `/usr/bin/ls.exe $PATH`
do
  echo "---Dir:" ${dirname}

  for filename in `/usr/bin/ls.exe $PATH/$dirname`
  do
    echo "---------Filename:"${filename}
    NEWFILENAME=${dirname}_${filename}
    echo "---------NewFilename:"${NEWFILENAME}
    /usr/bin/mv.exe ${PATH}/${dirname}/${filename} ${DESTDIR}/${NEWFILENAME}
  done
  
  # Not space when cal the new value to variable cnt
  #cnt=`/usr/bin/expr.exe ${cnt} + 1`
  #if [ ${cnt} -eq 10 ];
  #then
  #  break
  #fi
done

 

[tensorflow] initializer 参数初始化方法整理

使用tensorflow训练最重要的就是要得到参数,包括W, b,使损失函数达到最小值。
在训练开始前,往往要离不开参数初始化。

详细文档可参考:http://www.tensorfly.cn/tfdoc/api_docs/python/state_ops.html

以下对各种参数初始化方法做一个简要整理。Every function returns an Op that can be run, it means that you must use sess.run(op) to print the value except the property of the op.

1、tf.constant_initializer()

2、tf.truncated_normal_initializer()

初始化截断的正态分布

示例代码:

import tensorflow as tf 

# kernel shape
ks=[2,3]
#初始化卷积核
w=tf.get_variable('weight',shape=ks,initializer=tf.truncated_normal_initializer())
#初始化偏移量
b=tf.get_variable('bias',shape=[ks[-1]],initializer=tf.constant_initializer())

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print (w)
    print(sess.run(w))
    print(sess.run(b))

执行结果:

<tf.Variable 'weight:0' shape=(2, 3) dtype=float32_ref>
[[-0.01235651  1.8127841  -0.18910326]
 [-0.18857875  0.48627552  0.66549534]]
[0. 0. 0.]

3、tf.random_normal_initializer()
生成标准正态分布的随机数,参数和truncated_normal_initializer一样。

4、random_uniform_initializer = RandomUniform()
生成均匀分布的随机数,参数有四个(minval=0, maxval=None, seed=None, dtype=dtypes.float32),分别用于指定最小值,最大值,随机数种子和类型。

5、tf.uniform_unit_scaling_initializer()
和均匀分布差不多,只是这个初始化方法不需要指定最小最大值,是通过计算出来的。
参数为(factor=1.0, seed=None, dtype=dtypes.float32)

6、tf.variance_scaling_initializer()
参数为(scale=1.0,mode=”fan_in”,distribution=”normal”,seed=None,dtype=dtypes.float32)

7、tf.orthogonal_initializer()
生成正交矩阵的随机数
当需要生成的参数是2维时,这个正交矩阵是由均匀分布的随机数矩阵经过SVD分解而来

8、tf.glorot_uniform_initializer()
也称之为Xavier uniform initializer,由一个均匀分布(uniform distribution)来初始化数据
假设均匀分布的区间是[-limit, limit],则
limit=sqrt(6 / (fan_in + fan_out))
其中的fan_in和fan_out分别表示输入单元的结点数和输出单元的结点数。

9、glorot_normal_initializer()
也称之为 Xavier normal initializer. 由一个 truncated normal distribution来初始化数据.
stddev = sqrt(2 / (fan_in + fan_out))
其中的fan_in和fan_out分别表示输入单元的结点数和输出单元的结点数。

参考网页:http://www.bubuko.com/infodetail-2099623.html

该网页里写的API的简写, 在 tf.__version__==’1.5.0’的版本里,是不支持的。

 

[tensorflow] 常用函数整理

1.tf.random_normal()
原型:random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
功能:产生一组符合正态分布的随机数据
参数:
shape: 一维的张量,也是输出的张量
mean: 正态分布的平均值
stddev: 正态分布的标准差
dtype: 输出的类型
seed: 随机数种子,一个整数,设置之后,每次生成的随机数都一样。让生成的随机数可控
name: 操作的名字

2.tf.truncated_normal()
原型:truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
功能:从截断的正态分布中输出随机值。生成的值服从具有指定平均值和标准偏差的正态分布,如果生成的值大于平均值2个标准偏差的值则丢弃重新选择。
参数:含义同tf.random_normal()

示例代码:

import tensorflow as tf

#  返回普通的正态分布随机值
a = tf.Variable(tf.random_normal([2,2]))

# 指定返回的正态分布随机数只能是在[-1,1]的范围内取值
b = tf.Variable(tf.truncated_normal([1,5],stddev=0.5))

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    print(sess.run(a))

print ('\n')
num=0
with tf.Session() as sess:
  while (num<5):
    # init如果放在while语句前面,循环中每次生成的随机数都一样
    sess.run(init)
    result_arr=sess.run(b)
    print(result_arr)
    num+=1

输出结果:

[[ 0.96797645 -0.22378281]
 [ 0.48484442 -1.3870438 ]]


[[ 0.4379561   0.3316845   0.13594626  0.17255506 -0.16520476]]
[[-0.03571    -0.07148687 -0.33317718  0.39912027  0.5691518 ]]
[[ 0.81705946 -0.28892836 -0.27838987 -0.07629658  0.97369707]]
[[ 0.5421042  -0.45518216  0.2038535  -0.3036928   0.0122734 ]]
[[-0.07813777  0.01990178  0.8251432   0.59219587  0.7987216 ]]

3.tf.nn.bias_add()
原型:bias_add(value, bias, data_format=None, name=None)
功能:将bias表示的偏移量加到value上,返回一个与value相同的张量。该函数大致与tf.add()功能相同,只是tf.add()支持bias的维度与value的最后一维不同。
参数:
value: 一个张量,数据类型必需属于这个范围:`float`, `double`, `int64`, `int32`, `uint8`,`int16`, `int8`, `complex64`, or `complex128`
bias: 一个一维张量,其数据维度必须与value的最后一个维度相同,数据类型必须与value相同

示例代码:

import tensorflow as tf

a=tf.constant([[1,1],[2,2],[3,3]],dtype=tf.float32)
b=tf.constant([1,-1],dtype=tf.float32)
c=tf.constant([1],dtype=tf.float32)

with tf.Session() as sess:
    print('tf.nn.bias_add:')
    print(sess.run(tf.nn.bias_add(a, b)))
    # 执行下面语句错误
    # print(sess.run(tf.nn.bias_add(a, c)))

    print('\ntf.add:')
    print(sess.run(tf.add(a, c)))

输出结果:

tf.nn.bias_add:
[[2. 0.]
 [3. 1.]
 [4. 2.]]

tf.add:
[[2. 2.]
 [3. 3.]
 [4. 4.]]

 

 

 

 

[tensorflow] 设计思想简要理解

使用TensorFlow的时候,你需要理解的一些tensorflow问题:
怎么用图表示计算;
在Session里面计算图;
用tensor表示数据;
用变量保持状态;
用feeds(联系placeholder)和fetches来从任意的操作(Operation)中“放入”或者“拿出”数据。
再回忆一下tensorflow的思想:首先是构造过程来“组装”一个图,然后是执行过程用session来执行图中的操作(ops)。那么下面就用一个综合的例子联系之前对于各个类的分析来加强一些对于tensorflow基础的理解。

例子1:常量和图

# -*- coding: utf-8 -*- 

from __future__ import print_function,division
import tensorflow as tf

#building the graph

'''
创建一个常量操作(op)产生 1x2 矩阵,这个操作(op)作为一个节点添加到默认的图中,但是这里这个矩阵并不是一个值,而是一个tensor。
创建另外一个常量操作产生一个1x2 矩阵(解释如上)
'''
mat1=tf.constant([3.,3.],name="mat1")
mat2=tf.constant([4.,4.],name="mat2")

#matrix sum.
s=tf.add(mat1,mat2)

'''
这个默认的图(grapg)现在已经有3个节点了:两个constant()操作和一个add()操作。为了真正的得到这个和的值,你需要把这个图投放到一个session里面执行。
'''

# Launch the default graph.
sess = tf.Session()

'''
为了得到和的值,我们要运行add 操作(op),因此我们在session里面调用“run()”函数,把代表add op的输出结果s传到函数里面去。表明我们想从add()操作得到输出。
'''
result=sess.run(s)
print("result:",result)

# Close the Session when we're done.
sess.close()

输出结果:

result: [7. 7.]

分析:注意注释列明的几个关键操作

另一种自动关闭session的写法:

with tf.Session() as sess:
  result = sess.run([product])
  print(result)

例子2:tensor和变量

代码示例:

# -*- coding: utf-8 -*- 

from __future__ import print_function,division
import tensorflow as tf

#building the graph

#Create a Variable, that will be initialized to the scalar value 0.
state=tf.Variable(0,name="state")
print("the name of this variable:",state.name)

# Create an Op to add 1 to `state`.
one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# Variables must be initialized by running an `init` Op after having
# launched the graph.  We first have to add the `init` Op to the graph.
init_op = tf.global_variables_initializer()

# Launch the graph and run the ops.
with tf.Session() as sess:
  # Run the 'init' op
  sess.run(init_op)
  # Print the initial value of 'state'
  print("The value of state=[%s]" %(sess.run(state)))
  # Run the op that updates 'state' and print 'state'.
  for _ in range(3):
    sess.run(update)
    print("value of state:",sess.run(state))

输出结果:

the name of this variable: state:0
The value of state=[0]
value of state: 1
value of state: 2
value of state: 3

例子3: fetches和feeds

fetches表示一种取的动作,我们有时候需要在操作里面取一些输出,其实就是在执行图的过程中在run()函数里面传入一个tensor就行,然后就会输出tesnor的结果,比如上面的session.run(state)就可以当做一个fetch的动作啦。当然不仅仅限于fetch一个,你也可以fetch多个tensor。

feed我们知道是喂养的意思,这个又怎么理解呢?feed的动作一般和placeholder()函数一起用,前面说过,placeholder()起到占位的作用(参考前面的placeholder()函数),怎么理解呢?假如我有一个(堆)数据,但是我也许只知道他的类型,不知道他的值,我就可以先传进去一个类型,先把这个位置占着。等到以后再把数据“喂”给这个变量。

代码示例:

# -*- coding: utf-8 -*- 

from __future__ import print_function,division
import tensorflow as tf

#fetch example
print("#fetch example")
a=tf.constant([1.,2.,3.],name="a")
b=tf.constant([4.,5.,6.],name="b")
c=tf.constant([0.,4.,2.],name="c")
add=a+b
mul=add*c

with tf.Session() as sess:
    result=sess.run([a,b,c,add,mul])
    print("after run:\n",result)

print("\n\n")

#feed example
print("feed example")
input1=tf.placeholder(tf.float32)
input2=tf.placeholder(tf.float32)
output=tf.multiply(input1,input2)

with tf.Session() as session:
    result_feed=session.run(output,feed_dict={input1:[2.],input2:[3.]})
    print("result:",result_feed)

运行结果:

#fetch example
after run:
 [array([1., 2., 3.], dtype=float32), array([4., 5., 6.], dtype=float32), array([0., 4., 2.], dtype=float32), array([5., 7., 9.], dtype=float32), array([ 0., 28., 18.], dtype=float32)]

feed example
result: [6.]

 

本篇笔记主要参考自:http://blog.csdn.net/xierhacker/article/details/53103979

 

 

[tensorflow] placeholder and Variable 变量定义

tf.placeholer() 与 tf.Variable()的区别:
tf.placeholder 占位符。 主要为真实输入数据和输出标签的输入,用于在 feed_dict中的变量,不需要指定初始值,具体值在feed_dict中的变量给出。

示例代码:

images_placeholder = tf.placeholder(tf.float32, shape=(batch_size, IMAGE_PIXELS))
labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))

#This is how you feed the training examples during the training:

for step in xrange(FLAGS.max_steps):
    feed_dict = {
       images_placeholder: images_feed,
       labels_placeholder: labels_feed,
     }
    _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict)

tf.Variable 主要用于定义weights bias等可训练会改变的变量,必须指定初始值。

示例代码:

weights = tf.Variable(
    tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                    stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))), name='weights')

biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')

1. tf.placeholder函数

tf.placeholder(dtype, shape=None, name=None)
dtype:数据类型,常用的是tf.float32,tf.float64等数值类型
shape:数据形状,默认是None,就是一维值,也可以是多维,比如[2,3], [None, 3]表示列是3,行不定
name: 名称
返回:Tensor

理解: placeholder – 占位符
placeholder的作用可以理解为占个位置,我并不知道这里将会是什么值,但是知道类型和形状等等一些信息,先把这些信息填进去占个位置,然后以后用feed的方式来把这些数据“填”进去。返回的就是一个用来用来处理feeding一个值的tensor。
那么feed的时候一般就会在你之后session的run()方法中用到feed_dict这个参数了。这个参数的内容就是你要“喂”给那个placeholder的内容:

代码示例:

x = tf.placeholder(tf.float32, shape=(1024, 1024))
y = tf.matmul(x, x)

with tf.Session() as sess:
  print(sess.run(y))  # ERROR: will fail because x was not fed.
  rand_array = np.random.rand(1024, 1024)
  print(sess.run(y, feed_dict={x: rand_array}))  # Will succeed.

2.tf.Variable()

代码示例:

import tensorflow as tf

'''
函数原型:
tf.Variable.init(initilizer, trainable=True, collections=None, validate_shape=True, name=None)

1.initilizer是初始化参数,常用的可以有:
  tf.random_normal, tf.constant,也可以直接指定变量的值
2.name就是这个变量的名字

在TensorFlow的世界里,变量的定义和初始化是分开的,
所有关于图变量的赋值和计算都要通过tf.Session的run来进行。

想要将所有图变量进行集体初始化时应该使用tf.global_variables_initializer。
'''

# Variable()只有第一个参数是必填参数
# 用于设置初始化的值
x=tf.Variable(3,name='x')
y=x*5
# 直接打印出来的只是y的类型信息
#print(y)

# 如果要打印出y的值,需要使用如下方式
sess1=tf.InteractiveSession()
sess1.run(tf.global_variables_initializer())
print('y=[%s]' %(sess1.run(y)))

a1 = tf.Variable(tf.random_normal(shape=[3,3], mean=0, stddev=1), name='a1')
a2 = tf.Variable(tf.constant(1), name='a2')
a3 = tf.Variable(tf.ones(shape=[3,3]), name='a3')

with tf.Session() as sess2:
    sess2.run(tf.global_variables_initializer())
    print ("a1=[%s]" %(sess2.run(a1)))
    print ("a2=[%s]" %(sess2.run(a2)))
    print ("a3=[%s]" %(sess2.run(a3)))
    
# TensorFlow的命名空间分为两种,tf.variable_scope和tf.name_scope。
# 用这两个关键字来定义全名空间

输出结果:

y=[15]
a1=[[[ 0.79456246  1.15295    -1.7370982 ]
 [ 1.3414627  -0.55975544 -0.44456488]
 [-0.87240374  2.1628578   0.08264139]]]
a2=[1]
a3=[[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]]

3. tf.get_variable()
tf.get_variable跟tf.Variable都可以用来定义图变量,但是前者的必需参数(即第一个参数)并不是图变量的初始值,而是图变量的名称。
tf.Variable的用法要更丰富一点,当指定名称的图变量已经存在时表示获取它,当指定名称的图变量不存在时表示定义它。

代码示例:

import tensorflow as tf

init = tf.constant_initializer([5])
x=tf.get_variable('x',shape=[1],initializer=init)
sess3=tf.InteractiveSession()
sess3.run(x.initializer)
print ("sess3 x=[%s]" %(sess3.run(x)))

基础概念的介绍可看这篇整理:

http://blog.csdn.net/xierhacker/article/details/53103979

 

[tensorflow] tf.nn.conv2d()

示例代码:

import tensorflow as tf

# tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)
# 除去name参数用以指定该操作的name,与方法有关的一共五个参数:
#
# 第一个参数input:指需要做卷积的输入图像,它要求是一个Tensor,具有[batch, in_height, in_width, in_channels]这样的shape,具体含义是[训练时一个batch的图片数量, 图片高度, 图片宽度, 图像通道数],注意这是一个4维的Tensor,要求类型为float32和float64其中之一
#
# 第二个参数filter:相当于CNN中的卷积核,它要求是一个Tensor,具有[filter_height, filter_width, in_channels, out_channels]这样的shape,具体含义是[卷积核的高度,卷积核的宽度,图像通道数,卷积核个数],要求类型与参数input相同,有一个地方需要注意,第三维in_channels,就是参数input的第四维
#
# 第三个参数strides:卷积时在图像每一维的步长,这是一个一维的向量,长度4
#
# 第四个参数padding:string类型的量,只能是"SAME","VALID"其中之一,这个值决定了不同的卷积方式(SAME: 计算得到的卷积矩阵尺寸与input相同;VALID: 计算得到的卷积矩阵尺寸为:n-k+1)
#
# 第五个参数:use_cudnn_on_gpu:bool类型,是否使用cudnn加速,默认为true
#
# 结果返回一个Tensor,这个输出,就是我们常说的feature map

oplist=[]
shape=[]
# [batch, in_height, in_width, in_channels]
input_arg  = tf.Variable(tf.ones([1, 3, 3, 5]))
# [filter_height, filter_width, in_channels, out_channels]
filter_arg = tf.Variable(tf.ones([1 ,1 , 5 ,1]))
# strides=1
# tensorShape [1,3,3,1]
op2 = tf.nn.conv2d(input_arg, filter_arg, strides=[1,1,1,1], use_cudnn_on_gpu=False, padding='VALID')
oplist.append([op2, "case 2"])
shape.append(op2.shape)

# [batch, in_height, in_width, in_channels]
input_arg  = tf.Variable(tf.ones([1, 3, 3, 5]))
# [filter_height, filter_width, in_channels, out_channels]
filter_arg = tf.Variable(tf.ones([3 ,3 , 5 ,1]))
# tensorShape [1,1,1,1]
op2 = tf.nn.conv2d(input_arg, filter_arg, strides=[1,1,1,1], use_cudnn_on_gpu=False, padding='VALID')
oplist.append([op2, "case 3"])
shape.append(op2.shape)

# [batch, in_height, in_width, in_channels]
input_arg  = tf.Variable(tf.ones([1, 5, 5, 5]))
# [filter_height, filter_width, in_channels, out_channels]
filter_arg = tf.Variable(tf.ones([3 ,3 , 5 ,1]))
# tensorShape [1,3,3,1]
op2 = tf.nn.conv2d(input_arg, filter_arg, strides=[1,1,1,1], use_cudnn_on_gpu=False, padding='VALID')
oplist.append([op2, "case 4"])
shape.append(op2.shape)

# [batch, in_height, in_width, in_channels]
input_arg  = tf.Variable(tf.ones([1, 5, 5, 5]))
# [filter_height, filter_width, in_channels, out_channels]
filter_arg = tf.Variable(tf.ones([3 ,3 , 5 ,1]))
# tensorShape [1,5,5,1]
op2 = tf.nn.conv2d(input_arg, filter_arg, strides=[1,1,1,1], use_cudnn_on_gpu=False, padding='SAME')
oplist.append([op2, "case 5"])
shape.append(op2.shape)

# [batch, in_height, in_width, in_channels]
input_arg  = tf.Variable(tf.ones([1, 5, 5, 5]))
# [filter_height, filter_width, in_channels, out_channels]
filter_arg = tf.Variable(tf.ones([3 ,3 , 5 ,7]))
# tensorShape [1,5,5,7]
op2 = tf.nn.conv2d(input_arg, filter_arg, strides=[1,1,1,1], use_cudnn_on_gpu=False, padding='SAME')
oplist.append([op2, "case 6"])
shape.append(op2.shape)

# [batch, in_height, in_width, in_channels]
input_arg  = tf.Variable(tf.ones([1, 5, 5, 5]))
# [filter_height, filter_width, in_channels, out_channels]
filter_arg = tf.Variable(tf.ones([3 ,3 , 5 ,7]))
# strides=2,即卷积时核移动的步长为2
# tensorShape [1,3,3,7]
op2 = tf.nn.conv2d(input_arg, filter_arg, strides=[1,2,2,1], use_cudnn_on_gpu=False, padding='SAME')
oplist.append([op2, "case 7"])
shape.append(op2.shape)


# [batch, in_height, in_width, in_channels]
input_arg  = tf.Variable(tf.ones([4, 5, 5, 5]))
# [filter_height, filter_width, in_channels, out_channels]
filter_arg = tf.Variable(tf.ones([3 ,3 , 5 ,7]))
# tensorShape [4,3,3,7]
op2 = tf.nn.conv2d(input_arg, filter_arg, strides=[1,2,2,1], use_cudnn_on_gpu=False, padding='SAME')
oplist.append([op2, "case 8"])
shape.append(op2.shape)

with tf.Session() as a_sess:
    a_sess.run(tf.global_variables_initializer())
    for aop in oplist:
        print("----------{}---------".format(aop[1]))
        print(a_sess.run(aop[0]))
        print('---------------------\n\n')
print(shape[:])

输出结果:

结果是这样的:

———-case 2———
[[[[5.]
[5.]
[5.]]

[[5.]
[5.]
[5.]]

[[5.]
[5.]
[5.]]]]
———————

———-case 3———
[[[[45.]]]]
———————

———-case 4———
[[[[45.]
[45.]
[45.]]

[[45.]
[45.]
[45.]]

[[45.]
[45.]
[45.]]]]
———————

———-case 5———
[[[[20.]
[30.]
[30.]
[30.]
[20.]]

[[30.]
[45.]
[45.]
[45.]
[30.]]

[[30.]
[45.]
[45.]
[45.]
[30.]]

[[30.]
[45.]
[45.]
[45.]
[30.]]

[[20.]
[30.]
[30.]
[30.]
[20.]]]]
———————

———-case 6———
[[[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[30. 30. 30. 30. 30. 30. 30.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[45. 45. 45. 45. 45. 45. 45.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[45. 45. 45. 45. 45. 45. 45.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[45. 45. 45. 45. 45. 45. 45.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[30. 30. 30. 30. 30. 30. 30.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]]]
———————

———-case 7———
[[[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]]]
———————

———-case 8———
[[[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]]

[[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]]

[[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]]

[[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]

[[30. 30. 30. 30. 30. 30. 30.]
[45. 45. 45. 45. 45. 45. 45.]
[30. 30. 30. 30. 30. 30. 30.]]

[[20. 20. 20. 20. 20. 20. 20.]
[30. 30. 30. 30. 30. 30. 30.]
[20. 20. 20. 20. 20. 20. 20.]]]]
———————

[TensorShape([Dimension(1), Dimension(3), Dimension(3), Dimension(1)]),
TensorShape([Dimension(1), Dimension(1), Dimension(1), Dimension(1)]),
TensorShape([Dimension(1), Dimension(3), Dimension(3), Dimension(1)]),
TensorShape([Dimension(1), Dimension(5), Dimension(5), Dimension(1)]),
TensorShape([Dimension(1), Dimension(5), Dimension(5), Dimension(7)]),
TensorShape([Dimension(1), Dimension(3), Dimension(3), Dimension(7)]),
TensorShape([Dimension(4), Dimension(3), Dimension(3), Dimension(7)])]

 

以上,参考自:https://www.cnblogs.com/qggg/p/6832342.html