[tf]|[张量]|[例子1]tensorflow学习笔记（1）

参考：莫烦Python: morvanzhou.github.io

文章目录

[tf]|[张量]|[例子1]tensorflow学习笔记（1）

步骤
张量（Tensor）
tf.random_uniform()
tf.Variable()
tf.zeros()
tf.square()
tf.reduce_mean()
tf.train.GradientDescentOptimizer()
tf.train.Optimizer.minimize()
tf.session.run()
设置session
结构初始化
tf.constant()
tf.multiply()与tf.matmul()
tf.placeholder()(占位符)
（例子）拟合：y = 0.1x +0.3

步骤

先设计好结构
init

张量（Tensor）

向量（Vector）：在我们的课本中，向量通常都是这样一个箭头……用来表示一个既有幅度（magnitude）又有方向（direction）的物理量，比如重力、磁力或者一个粒子的速度。这个箭头的长度表示幅度，箭头的指向表示方向。

此外，向量还可以用来表示一个平面，表示方法就是让向量代表垂直于这个平面的方向（法线方向）。（即让向量处于二维坐标中）

这么看来，向量可以表示很多东西：表示力、速度甚至平面，不过仔细想想向量也只表示了幅度（magnitude）与方向（direction）两个要素而已。
张量（Tensor）：张量是一种表示物理量的方式，这个方式就是用基向量 (Basis Vectors）与分量 (Components) 的组合表示物理量（Combinationof basis vector and component）
- 如果我们把代数手法和几何手法结合起来即采用解析几何的手法，向量也可以表示为某种坐标基向量和坐标分量的线性组合。
- 其实，标量，向量，矩阵它们三个也是张量，标量是零位的张量，向量是一维的张量，矩阵是二维的张量。
- 参考地址：https://blog.****.net/u010995990/article/details/80093252

tf.random_uniform()

生成随机均匀分布的数，如：

tf.random_uniform([1],-1.0,1.0)
#生成一维度；范围为-1.0到1.0的左闭右开区间，即[-1.0,1.0)

tf.Variable()

使用tensorflow在默认的图中创建节点，这个节点是一个变量（图变量）。如：

Weights = tf.Variable()

定义带name的Variable，如：

import tensorflow as tf

state = tf.Variable(0,name='counter')	#申请初值为0，name为couter的变量
#print(state.name)						#打印变量state的name

#变量加常量为变量
one = tf.constant(1)
new_value = tf.add(state,one)
update = tf.assign(state,new_value)
#将new_value的值加载到state上，可以解为：state = new_value

init = tf.initialize_all_variables()		
#只要在tensorflow中使用到了变量一定要**，否则不能使用

with tf.Session() as sess:
	sess.run(init)
    for _ in range(3):
        see.run(update)
        print(sess.run(state))
#直接print state是无效的，一定要将sess的指针放到state上run()才会出现state的结果
'''
 output >>> 1
			2
    		3
'''

tf.zeros()

生成全0数组

# 语法：
tf.zeros(shape, dtype, name)

# 样例：
tf.zeros([2, 3], int32)     # ==> [[0, 0, 0], [0, 0, 0]]


#参考：https://blog.****.net/yjk13703623757/article/details/77075711

变量初始值为零，如：

biases = tf.Variable(tf.zeros([1]))

tf.square()

tf.square(a)是对a里的每一个元素求平方

tf.reduce_mean()

函数用于计算张量tensor沿着指定的数轴（tensor的某一维度）上的的平均值，主要用作降维或者计算tensor（图像）的平均值。如：

loss = tf.reduce_mean(a)
#计算a内内所有元素的均值

tf.train.GradientDescentOptimizer()

创建一个optimizer（优化器）并赋予它学习率（学习率一般是个小于1的数），如：

optimizer = tf.train.GradientDescentOptimizer(0.5)

更多tf.train中的Optimizer相关的函数与功能介绍可参考此处博文：点此

tf.train.Optimizer.minimize()

使损失函数loss降到最小，如：

loss = tf.reduce_mean()
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

tf.session.run()

tf.Session.run(fetches ) 执行 fetches 中的操作，计算 fetches 中的张量值。

设置session

# method 1
sess = tf.Session()		#这里sess相当于一个指针
sess.run(init)			#sess指向了init，使得init被**（神经网络被**）（被run）
sess.close()			#可有可无

# method 2
with tf.Session() as sess:			#不用close，运行完自动会关上
    sess.run(init)

结构初始化

tf.initialize_all_variables()

tf.constant()

创建一个常数张量 （与tf.Variable()不同的是其为常量，后者为变量）,传入list或者数值来填充

# 语法：
tf.constant(value, dtype, shape, name)

# 样例：
a = tf.constant([[1, 2, 3], [4, 5, 6]], int32) 

# ==> [[1, 2, 3], [4, 5, 6]]

tf.multiply()与tf.matmul()

tf.multiply（）两个矩阵中对应元素各自相乘
- 格式: tf.multiply(x, y, name=None)
- 参数:
  - x: 一个类型为:half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128的张量。
  - y: 一个类型跟张量x相同的张量。
  - 返回值： x * y element-wise.
- pay attention:
  1. multiply这个函数实现的是元素级别的相乘，也就是两个相乘的数元素各自相乘，而不是矩阵乘法，注意和tf.matmul区别。
  2. 两个相乘的数必须有相同的数据类型，不然就会报错。
tf.matmul（）将矩阵a乘以矩阵b，生成a * b。
- 格式: tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)
- 参数:
  - a: 一个类型为 float16, float32, float64, int32, complex64, complex128 且张量秩 > 1 的张量。
  - b: 一个类型跟张量a相同的张量。
  - transpose_a: 如果为真, a则在进行乘法计算前进行转置。
  - transpose_b: 如果为真, b则在进行乘法计算前进行转置。
  - adjoint_a: 如果为真, a则在进行乘法计算前进行共轭和转置。
  - adjoint_b: 如果为真, b则在进行乘法计算前进行共轭和转置。
  - a_is_sparse: 如果为真, a会被处理为稀疏矩阵。
  - b_is_sparse: 如果为真, b会被处理为稀疏矩阵。
  - name: 操作的名字（可选参数）
  - 返回值：一个跟张量a和张量b类型一样的张量且最内部矩阵是a和b中的相应矩阵的乘积。
- pay attention:
  1. 输入必须是矩阵（或者是张量秩 >２的张量，表示成批的矩阵），并且其在转置之后有相匹配的矩阵尺寸。
  2. 两个矩阵必须都是同样的类型，支持的类型如下：float16, float32, float64, int32, complex64, complex128。引发错误
- 例：
```
import tensorflow as tf

matrix1 = tf.constant([[3,3]])
matrix2 = tf.constant([[2],[2]])

product = tf.matmul(matrix1,matrix2)	#matrix multiply np.dot(m1,m2)

sess = tf.Session()
result = sess.run(product)
print(result)
sess.close()

#output	>>>	[[12]]
```
参考：https://www.cnblogs.com/AlvinSui/p/8987707.html

tf.placeholder()(占位符)

tf.placeholder(dtype, shape=None, name=None)
此函数可以理解为形参，用于定义过程，在执行的时候再赋具体的值
参数：
- dtype：数据类型。常用的是tf.float32,tf.float64等数值类型
- shape：数据形状。默认是None，就是一维值，也可以是多维，比如[2,3], [None, 3]表示列是3，行不定
- name：名称。
- 返回值：Tensor 类型

例：

import tensorflow as tf

imput1 = tf.placeholder(tf.float32)
imput2 = tf.placeholder(tf.float32)

output = tf.multiply(imput1,imput2)

with tf.Session()as sess:
    print(sess.run(output,feed_dict={imput1:[7.],imput2:[2.]}))

（例子）拟合：y = 0.1x +0.3

在tensorflow中大部分数据是以float32的形式出现

"""
Please note, this code is only for python 3+. If you are using python 2+, please modify the code accordingly.
"""
from __future__ import print_function
import tensorflow as tf
import numpy as np

# create data
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data*0.1 + 0.3

### create tensorflow structure start ###
Weights = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
biases = tf.Variable(tf.zeros([1]))

y = Weights*x_data + biases

loss = tf.reduce_mean(tf.square(y-y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)
### create tensorflow structure end ###

sess = tf.Session()
# tf.initialize_all_variables() no long valid from
# 2017-03-02 if using tensorflow >= 0.12
if int((tf.__version__).split('.')[1]) < 12 and int((tf.__version__).split('.')[0]) < 1:
    init = tf.initialize_all_variables()
else:
    init = tf.global_variables_initializer()
sess.run(init)

for step in range(201):
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(Weights), sess.run(biases))
        
#转自：莫烦Python: morvanzhou.github.io

[笔记]|[tf]|[张量]|[例子1]tensorflow学习笔记（1）