Tensorflow

hello world

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

vec_1 = tf.constant([1, 2, 3, 4])
vec_2 = tf.constant([1, 2, 3, 4])
v_add = tf.add(vec_1,vec_2)

with tf.Session() as sess:
	print(sess.run(v_add))

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

vec_1 = tf.constant([1, 2, 3, 4])
vec_2 = tf.constant([1, 2, 3, 4])

sess = tf.InteractiveSession()

v_add = tf.add(vec_1,vec_2)

print(v_add.eval())

sess.close()

张量

所有的数据都通过张量的形式来表示

TensorFlow的张量和Numpy的数组不同，他计算的结果不是一个具体的数字，而是一个张量的结构。从上面结果来看，一个张量主要保存了三个属性，名字（name），维度（shape）和类型（type）

#_*_coding:utf-8_*_
import tensorflow as tf
 
# tf.constant 是一个计算，这个计算的结果为一个张量，保存在变量a中
a = tf.constant([1.0, 2.0], name='a')
b = tf.constant([2.0, 3.0], name='b')
 
result = a + b
# print(result)   # Tensor("add:0", shape=(2,), dtype=float32)

张量的第一个属性名字不仅是一个张量的唯一标识符，它同样也给出了这个张量是如何计算的，TensorFlow的计算都可以通过计算图的模型来建立，而计算图上的每一个节点代表一个计算，计算的结果就保存在张量之中。所以张量和计算图上节点所代表的计算结果是对应的。所以张量的命名就可以通过“node : src_output”的形式来给出。其中node为节点的名称，src_output 表示当前张量来自节点的第几个输出。比如上面的“add:0” 就说明了result这个张量是计算节点“add” 输出的第一个结果（编号从0 开始）。

张量的第二个属性是张量的维度。这个属性描述了一个张量的维度信息，比如上面样例中 shape = (2, ) 说明了张量 result 是一个一维数组，这个数组的长度为2。维度是张量一个很重要的属性，围绕张量的维度TensorFlow也给出了很多有用的运算。

张量的第三个属性就是类型（type），每一个张量会有一个唯一的类型。TensorFlow 会对参与运算的所有张量进行类型的检查，当发现类型不匹配的时候会报错

常量、随机数、变量

大规模常量张量对象最好定义成 t_large = tf.Varible(large_array,trainable = False)

可训练标志位为False

t_1 = tf.constant(4)
zero_t = tf.zeros([2,3],tf.int32)

tf.zeros_like(t_2)
tf.ones_like(t_2)

range_t = tf.linspace(2.0,5.0,5)
#We get:[2. 2.75 3.5 4.25 5.]

tf.range(start,limit,delta)
#start 默认0，delta 默认1
range_t = tf.range(10)
#Result:[0 1 2 3 4 5 6 7 8 9]

#随机数
t_random = tf.random_normal([2,3],mean=2.0,stddev=4,seed = 12)
#要想得到同样的随机数，seed需要设置相同，均值默认0，标准差默认1

tf.random_crop(t_random,[2,5],seed=12)
#将给定的张量随机剪裁为指定的大小

rand_t = tf.random_uniform([50,50]，0，10，seed=0)
t_a = tf.Variable(rand_t)
#随机均匀分布，min 0 max 10

weight2 = tf.Variable(weights.initialized_value(),name='w2')
#用原有变量定义

saver = tf.train.Saver()
#保存变量

占位符

定义过程，执行时再赋具体值

1	tf.placeholder(dtype,shape=None,name=None)

常用函数

(1)tf.argmax(input, axis=None, name=None, dimension=None)
此函数是对矩阵按行或列计算最大值
参数
    input：输入Tensor
    axis：0表示按列，1表示按行
    name：名称
    dimension：和axis功能一样，默认axis取值优先。新加的字段
返回：Tensor 行或列的最大值下标向量
 
(2)tf.equal(a, b)
此函数比较等维度的a, b矩阵相应位置的元素是否相等，相等返回True,否则为False
返回：同维度的矩阵，元素值为True或False
 
(3)tf.cast(x, dtype, name=None)
将x的数据格式转化成dtype.例如，原来x的数据格式是bool，
那么将其转化成float以后，就能够将其转化成0和1的序列。反之也可以
 
(4)tf.reduce_max(input_tensor, reduction_indices=None,
keep_dims=False, name=None)
 功能：求某维度的最大值
 
(5)tf.reduce_mean(input_tensor, reduction_indices=None,
 keep_dims=False, name=None)
功能：求某维度的均值
参数1--input_tensor:待求值的tensor。
参数2--reduction_indices:在哪一维上求解。0表示按列，1表示按行
参数（3）（4）可忽略
例：x = [ 1, 2
          3, 4]
x = tf.constant([[1,2],[3,4]], "float")
tf.reduce_mean(x) = 2.5
tf.reduce_mean(x, 0) = [2, 3]
tf.reduce_mean(x, 1) = [1.5, 3.5]
 
(6)tf.truncated_normal(shape, mean=0.0, stddev=1.0,
dtype=tf.float32, seed=None, name=None)
从截断的正态分布中输出随机值
    shape: 输出的张量的维度尺寸。
    mean: 正态分布的均值。
    stddev: 正态分布的标准差。
    dtype: 输出的类型。
    seed: 一个整数，当设置之后，每次生成的随机数都一样。
    name: 操作的名字。
 
(7）tf.random_normal(shape, mean=0.0, stddev=1.0,
 dtype=tf.float32, seed=None, name=None)
从标准正态分布中输出随机值
 
(8) tf.nn.conv2d(input, filter, strides, padding,
use_cudnn_on_gpu=None, data_format=None, name=None)
在给定的4D input与 filter下计算2D卷积
    1，输入shape为 [batch, height, width, in_channels]: batch为图片数量，in_channels为图片通道数
    2，第二个参数filter：相当于CNN中的卷积核，它要求是一个Tensor，
具有[filter_height, filter_width, in_channels, out_channels]这样的shape，
具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]，要求类型与
参数input相同，有一个地方需要注意，第三维in_channels，就是参数input的第四维
    3，第三个参数strides：卷积时在图像每一维的步长，这是一个一维的向量，长度4
    4，第四个参数padding：string类型的量，只能是"SAME","VALID"其中之一，
这个值决定了不同的卷积方式（后面会介绍）
    5，第五个参数：use_cudnn_on_gpu:bool类型，是否使用cudnn加速，默认为true
    结果返回一个Tensor，这个输出，就是我们常说的feature map，shape仍然是
[batch, height, width, channels]这种形式。
 
(9)tf.nn.max_pool(value, ksize, strides, padding, name=None)
参数是四个，和卷积很类似：
第一个参数value：需要池化的输入，一般池化层接在卷积层后面，所以输入
通常是feature map，依然是[batch, height, width, channels]这样的shape
第二个参数ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，
因为我们不想在batch和channels上做池化，所以这两个维度设为了1
第三个参数strides：和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]
第四个参数padding：和卷积类似，可以取'VALID' 或者'SAME' 返回一个Tensor，类型不变，
shape仍然是[batch, height, width, channels]这种形式
 
(10) tf.reshape(tensor, shape, name=None)
函数的作用是将tensor变换为参数shape的形式。
其中shape为一个列表形式，特殊的一点是列表中可以存在-1。-1代表的含义是不用我
们自己指定这一维的大小，函数会自动计算，但列表中只能存在一个-1。（当然如果存
在多个-1，就是一个存在多解的方程了）
 
(11)tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None,name=None)
为了减少过拟合，随机扔掉一些神经元，这些神经元不参与权重的更新和运算
参数：
    x            :  输入tensor
    keep_prob    :  float类型，每个元素被保留下来的概率
    noise_shape  : 一个1维的int32张量，代表了随机产生“保留/丢弃”标志的shape。
    seed         : 整形变量，随机数种子。
    name         : 名字，没啥用。

feed_dict

字符串拼接

Str1 = tf.placeholder(tf.string)
Str2 = tf.placeholder(tf.string)
Str3 = tf.placeholder(tf.string)

Str = tf.string_join([Str1, Str2, Str3], separator=" ") 

with tf.Session() as sess:
    output = sess.run(Str, feed_dict={Str1: 'I', Str2: 'like', Str3: 'TensorFlow !'})
    print(output.decode())

浮点数乘积

Num1 = tf.placeholder(tf.float32)
Num2 = tf.placeholder(tf.float32)

Result = tf.multiply(Num1, Num2)

with tf.Session() as sess:
    print(sess.run(Result, feed_dict={Num1:[5.],Num2:[6.]}))

tensorboard

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

A = tf.random_uniform([2,3] , 2 , 10 , dtype = tf.int32 ,name = "A")
B = tf.eye(3 , dtype = tf.int32 , name = "B")
C = tf.matmul(A , B , name = "ans")

with tf.Session() as sess:
  write = tf.summary.FileWriter('logs' , sess.graph)
  sess.run(C)

logs上级目录下打开shell，命令： tensorboard --logdir "logs"，新版tensorflow将 = 换成了双引号

更改命名空间：

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

with tf.name_scope("A"):
  A = tf.random_uniform([2,3] , 2 , 10 , dtype = tf.int32 ,name = "A")

with tf.name_scope("B"):
  B = tf.eye(3 , dtype = tf.int32 , name = "B")

C = tf.matmul(A , B , name = "ans")

with tf.Session() as sess:
  write = tf.summary.FileWriter('logs' , sess.graph)
  sess.run(C)