[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

【源码解读】AI实现跳一跳

源码来源:https://github.com/Prinsphield/Wechat_AutoJump

【OpenCV】

OpenCV帮助文档:https://docs.opencv.org/

cv2.imread():
功能:图像读入
参数:总共2个。第一个指定图片路径。
第二个参数是要告诉函数应该如何读取这幅图片:
cv2.IMREAD_COLOR:读入一副彩色图像。图像的透明度会被忽略, 这是默认参数。
cv2.IMREAD_GRAYSCALE:以灰度模式读入图像
调用opencv,就算图像的路径是错的,OpenCV 也不会提醒你的,但是当你使用命
令print img时得到的结果是None。

示例代码(Lena图片可网上下载):

#/usr/bin/env python
# -*- coding: utf-8 -*-
# 这段代码的作用是在Lena.jpg中匹配对应的模版图片的坐标,并用矩形框画出

import cv2
import numpy as np
from matplotlib import pyplot as plt

# 以灰度模式读入图片,这样img.shape就只有二维。否则还会多一维表示彩色
img=cv2.imread('Lena.jpg',cv2.IMREAD_GRAYSCALE)
img2 = img.copy()
# 指定第二个参数0会导致mathTemplate执行报错:template = cv2.imread('Lena_eyes.png',0)
template = cv2.imread('Lena_eyes.png',cv2.IMREAD_GRAYSCALE)

w, h = template.shape[::-1]

# Apply template Matching
res = cv2.matchTemplate(img2,template,cv2.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)

cv2.rectangle(img2,top_left,bottom_right,255,2)

# 绘制1行2列的grid,图片显示在第二个位置
plt.subplot(122), plt.imshow(img2,cmap = 'gray')
# 使用plt.xticks([])关闭坐标轴刻度
plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
plt.suptitle("TM_CCOEFF_NORMED")
plt.show()

cv2.resize():
函数原型:cv2.resize(src, dsize[, dst[, fx[, fy[, interpolation]]]]) -> dst
功能:图像缩放
注意:是缩放,不是裁剪

interpolation 选项及对应的插值方法:
INTER_NEAREST: 最近邻插值
INTER_LINEAR: 双线性插值(默认设置)
INTER_AREA: 使用像素区域关系进行重采样。 它可能是图像抽取的首选方法,因为它会产生无云纹理的结果。 但是当图像缩放时,它类似于INTER_NEAREST方法
INTER_CUBIC: 4×4像素邻域的双三次插值
INTER_LANCZOS4:8×8像素邻域的Lanczos插值

示例代码:
import cv2
pic = cv2.imread('./Elegent_Girl.jpg')
# 缩放成宽:400,高:200
pic = cv2.resize(pic, (400, 200), interpolation=cv2.INTER_CUBIC)
cv2.imshow('', pic)
cv2.waitKey(0)
cv2.destroyAllWindows()

需要特别注意的是,cv2.resize指定的顺序是(宽,高),而pic.shape数组中,pic.shape[0]是高,pic.shape[1]是宽。即:resize里的参数与shape数组的值顺序是相反的。

cv2.cvtColor():
原型:cv2.cvtColor(src, code[, dst[, dstCn]]) -> dst
功能:Converts an image from one color space to another,即颜色空间转换
背景:生活中大多数看到的彩色图片都是RGB类型,但是在进行图像处理时,需要用到灰度图、二值图、HSV、HSI等颜色制式,opencv提供了cvtColor()函数来实现这些功能。
原理:在opencv中,其默认的颜色制式排列是BGR而非RGB。对于24位颜色图像来说,前8-bit是蓝色,中间8-bit是绿色,最后8-bit是红色。根据图片格式及目标格式的不同,转换可能会出现信息损失,此处先不深入该话题。

# 例子:将图像转换为灰度图 
state=cv2.imread('./player.png') 
state = cv2.cvtColor(state, cv2.COLOR_BGR2GRAY)

图像匹配:
http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/imgproc/histograms/template_matching/template_matching.html
cv2.matchTemplate(): 在模板块和输入图像之间寻找匹配,获得匹配结果图像
cv2.minMaxLoc(): 在给定的矩阵中寻找最大和最小值(包括它们的位置),仅支持单一通道

函数返回值:
cv2.matchTemplate()返回的是一个矩阵数组表示的灰度图片,该矩阵的每个元素都用来衡量这个点附近的像素与模板图片的匹配程度。
所以在执行了cv2.matchTemplate后,我们根据匹配方法的不同,可以调用cv2.minMaxLoc()函数,找出与模板图片最匹配的那个点,进而画出识别出来的矩形框。

实现原理:
为了确定匹配区域, 我们不得不滑动模板图像和原图像进行 比较。
通过 滑动, 我们的意思是图像块一次移动一个像素 (从左往右,从上往下). 在每一个位置, 都进行一次度量计算来表明它是 “好” 或 “坏” 地与那个位置匹配 (或者说块图像和原图像的特定区域有多么相似).
对于 Template 覆盖在 Image 上的每个位置,你把度量值 保存 到 结果图像矩阵 (R) 中. 在 R 中的每个位置 (x,y) 都包含匹配度量值。
实际上, 我们使用函数 minMaxLoc 来定位在矩阵 R 中的最大值点 (或者最小值, 根据函数输入的匹配参数) 。

模板匹配算法. 可用的方法有6个:
1.平方差匹配 method=CV_TM_SQDIFF 
2.标准平方差匹配 method=CV_TM_SQDIFF_NORMED
(这两类方法利用平方差来进行匹配,最好匹配为0,匹配值越大,匹配结果越差)

3.相关匹配 method=CV_TM_CCORR
4.标准相关匹配 method=CV_TM_CCORR_NORMED
5.相关匹配 method=CV_TM_CCOEFF
6.标准相关匹配 method=CV_TM_CCOEFF_NORMED
(这类方法采用模板和图像间的乘法操作,所以较大的数表示匹配程度较高,0标识最坏的匹配效果)

性能:
通常,随着从简单的测量(平方差)到更复杂的测量(相关系数),我们可获得越来越准确的匹配(同时也意味着越来越大的计算代价)

# 例子:
# Apply template Matching
res = cv2.matchTemplate(img,template,method)
# 这里调用cv2.minMaxLoc()返回的4个值,每个值都是一个二维坐标
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
if method in [cv2.TM_SQDIFF,cv2.TM_SQDIFF_NORMED]:
   top_left = min_loc
else:
   top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)

# 根据左上,右下两个坐标,绘制出矩形框,边框颜色灰度值255,宽度2像素
cv2.rectangle(img,top_left,bottom_right,255,2)
#完整的代码请参考:
https://docs.opencv.org/3.1.0/d4/dc6/tutorial_py_template_matching.html

【numpy】

函数原型:numpy.where(condition[, x, y])
参数:
condition : array_like, bool
x, y : array_like, optional
返回:
ndarray or tuple of ndarrays
If both x and y are specified, the output array contains elements of x where condition is True, and elements from y elsewhere.
If only condition is given, return the tuple condition.nonzero(), the indices where condition is True. 参考网址:https://docs.scipy.org/doc/numpy-dev/reference/generated/numpy.where.html#numpy.where

简单的理解:
numpy.where()函数是三元表达式x if condition else y的矢量化版本。
例子:
>>>import numpy as np 
>>>x = np.arange(9.).reshape(3, 3)
>>> x
array([[0., 1., 2.],
 [3., 4., 5.],
 [6., 7., 8.]])
>>> np.where(x>7)  (只有8符合,结果输出8所在的数组下标索引x[2][2])
(array([2]), array([2]))
>>> np.where(x>6)  (值:7,8符合,结果输出7,8所在的数组下标索引x[2][1],x[2][2])
(array([2, 2]), array([1, 2]))
>>> np.where(x<5,x,-1)  (如果数组元素小于5,打印元素本身,否则打印-1)
array([[ 0., 1., 2.],
 [ 3., 4., -1.],
 [-1., -1., -1.]])
>>>

np.linspace():
原型:linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
功能:用此来创建等差数列。

例子:
import numpy as np
x1=np.linspace(1-0.3, 1+0.3, 10)[::-1]
效果:生成0.7-1.3之间的10个等差数,-1指定倒序排列

print(x1),输出为:
[1.3 1.23333333 1.16666667 1.1 1.03333333 0.96666667
 0.9 0.83333333 0.76666667 0.7 ]

【Matplotlib】

 

 

【笔记】机器学习——参考资料

一过日本留学在校生对于人工智能行业整体情况的介绍及学习资料的整理:
http://blog.csdn.net/sileixinhua/article/details/75203725

深度学习大神都推荐入门必须读完这9篇论文:
http://blog.csdn.net/meyh0x5vDTk48P2/article/details/79072666

机器学习的定义, 分类, 应用领域, 现状问题:
http://blog.csdn.net/Tw6cy6uKyDea86Z/article/details/79016233

人工神经网格(Artificial Neural Network)概貌, 吴军, 数学之美, 倒数第二章.

“机器学习速成课程”中文版:
https://developers.google.com/machine-learning/crash-course/

Learn with Google AI:
https://ai.google/education


AI玩微信跳一跳的正确姿势 –跳一跳Auto-Jump算法详解:
https://zhuanlan.zhihu.com/p/32636329
https://github.com/Prinsphield/Wechat_AutoJump