tensorflow 笔记

import tensorflow as tf
import numpy as np

a = tf.constant("hello")
b = tf.constant(" world")

result = tf.add(a, b)
# Tensor("Add:0", shape=(), dtype=string)
print(result)

# stddev可以不写，这是python函数传参的一种方式，加上stddev之后，忽略了参数的位置关系
w = tf.Variable(tf.random_normal([784, 200], stddev=0.35), name="weights")
b = tf.Variable(tf.zeros([200]), name="biases")

sess = tf.Session()

init_op = tf.global_variables_initializer()
sess.run(init_op)
print(sess.run(w))
print(sess.run(b))

val = sess.run(result)
print(val)

# tf.zeros 标量，其中shape用[]和()均可，尽量用[]
zero_tensor_1 = tf.zeros([])  # zero_tensor_1 = tf.zeros(())
print(zero_tensor_1)
print(sess.run(zero_tensor_1))

# tf.zeros 一维向量，且向量长度为3，其中shape用[]和()均可，尽量用[]
zero_tensor_2 = tf.zeros([3, ])     # zero_tensor_2 = tf.zeros((3,))
print(zero_tensor_2)
print(sess.run(zero_tensor_2))

# tf.ones 标量，其中shape用[]和()均可，尽量用[]
ones_tensor_1 = tf.ones([])  # ones_tensor_1 = tf.ones(())
print(ones_tensor_1)
print(sess.run(ones_tensor_1))

# tf.ones_like 一维向量
ones_like_tensor = tf.ones_like(zero_tensor_2)
print(ones_like_tensor)
print(sess.run(ones_like_tensor))

# 当我们调用tf.Variable()函数来创建一个变量并定义它将被初始化的值，然后使用tf.global_variables_initializer()方法运行会话来显式执行初始化操作


# 如果我们想要反转一个数组，可以使用tf.transcope()函数，如将一个列向量转换为行向量或者反过来

# 均方误差MSE，使用tf.reduce_mean()函数

# 使用get_shape()获取张量形状
x = tf.constant(3, dtype=tf.float32)
print(x.dtype)
print(x.shape)
print(x.get_shape())

# 从a到b生成n个均匀间隔值的序列生成器tf.linspace(a, b, n)，但是只支持浮点数
y = tf.linspace(1.0, 10.0, 3)
print(y)
print(sess.run(y))

# shape传值[]和()均可，尽量用[]
constant_tensor_a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])
print(constant_tensor_a)
print(sess.run(constant_tensor_a))

constant_tensor_b = tf.constant([1, 2, 3, 4, 5, 6], shape=(2, 3))
print(constant_tensor_b)
print(sess.run(constant_tensor_b))

# AI = A + B + C
# A：算法Algorithm，即深度学习
# B：强监督大数据Big-supervised-data，强监督即需要人工标注的数据
# C：算力Computing，即训练平台基础设施化

# 像素：pixel，组成数字图像的最小单位，一般是对空间中某个"位置/小区域"反射的光强的测量。

# GAN: 生成对抗网络，图像合成及风格转换

# 卷积层: 稀疏连接，即输出层神经元只和部分输入层神经元相连

# 反卷积：信号复原。GAN中反卷积用来生成图片；全卷积网络FCN中，反卷积实现上采样。

# 激活函数用于卷积层和全连接层之后，是网络非线性的来源，ReLU是用的最多的激活函数

# ILSVRC，图像分类识别竞赛
# 2012年AlexNet 2014年VGG， 2015年GoogLeNet，2016年ResNet残差网络，InceptionV3，InceptionV4
# VGG16， VGG19

# python中的eval("a + b")函数用于将字符串中的字符串形式的表达式计算出来。这个字符串可以是函数入参传递过来的，也可以是从文件中读取的。


def print_array_attribute(array):
    print("number of dim:", array.ndim)  # 表示该矩阵是几维矩阵
    print("shape:", array.shape)  # 表示该矩阵是2行3列
    print("size:", array.size)  # 表示该矩阵中有多少个元素
    print("data type:", array.dtype) #输出int32，表示该矩阵中元素的数据类型


list_2dim = [[1, 3, 3],   # 有逗号，注意观察两行之间有逗号，所以是列表
        [4, 5, 6]]

# 列表打印出来是这样的[[1, 3, 3], [4, 5, 6]]
print(list_2dim)

# 列表作为一个入参，转换为矩阵
array_2dim = np.array(list_2dim)

# 矩阵打印出来是这样的，行与行之间没有逗号
# [[1 3 3]
#  [4 5 6]]
print(array_2dim)

# 矩阵的一些属性
print_array_attribute(array_2dim)
# 输出2，表示该矩阵是几维矩阵
# 输出(2, 3)表示该矩阵是2行3列
# 输出6，表示该矩阵中有多少个元素

# 举例三维：2 * 2 * 3
list_3dim = [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
print(list_3dim)

array_3dim = np.array(list_3dim)
print_array_attribute(array_3dim)
# 输出3，表示该矩阵是几维矩阵
# 输出(2, 2, 3)表示该矩阵是2 * 2 *3
# 输出12，表示该矩阵中有多少个元素

# 第一个入参是一个列表
a = np.array([2, 23, 4], dtype = np.int32)
print(a.dtype)

# 入参是一个shape，生城一个3行4列的元素为0的矩阵
a0 = np.zeros((3, 4))
print(a0)

a1 = np.linspace(1, 10, 6).reshape((2, 3))
print(a1)

# 0 ~ 11
a2 = np.arange(12)
print(a2)

a2 = a2.reshape((4, 3))
print(a2)

# 会比较矩阵中的每个元素与7的值大小，输出的是个bool矩阵
#[[ True  True  True]
# [ True  True  True]
# [ True False False]
# [False False False]]
print(a2 < 7)

# 矩阵乘法
a3 = np.array([[1, 2], [3, 4]])
a4 = np.array([[5, 6], [7, 8]])

# 这个不是矩阵的乘法，而是对应位置的元素相乘
print(a3 * a4)

# 这个才是矩阵的乘法
print(np.dot(a3, a4))

# 或者
print(a3.dot(a4))

# 随机生成[0, 1)区间的浮点数值，入参是一个shape，不传入shape的话，将会随机生成1个[0, 1）区间的浮点数
a5 = np.random.random((2, 4))
print(a5)
print(np.sum(a5), np.max(a5), np.min(a5), np.mean(a5)) # 求和，最大值，最小值，平均值

# numpy是对矩阵的运算，可以指定仅对行或仅对列的操作 axis=1表示对行进行操作，axis=0表示对列进行操作
print(np.sum(a5, axis=0))  # 求每一行的和
print(np.mean(a5, axis=1))   # 求每一列的均值

# 打印每行
for row in a5:
    print(row)

# 矩阵的转置
print(a5.T)

# 打印列
for column in a5.T:
    print(column)

print(a5.flatten())

# 打印每一个item，需要先将该矩阵转换为一个一维的序列
for item in a5.flat:
    print(item)

# ndarray简介
# ndarray即N-dimensional array N维数组，它是一种由相同类型的元素组成的多维数组，元素数量是事先指定好的，元素的数据类型由dtype,
# 对象来指定，每个ndarray只有一种dtype类型。ndarray大小固定，创建好数组时一旦指定好大小，就不会再发生改变。可以认为ndarray是一种数据类型

# 输出<class 'numpy.ndarray'>
print(type(a5))

# 损失函数用于描述预测值与实际值的差距大小，一般由两种比较常见的损失函数：均值方差MSE和交叉熵。

# 均值方差MSE也称为均方误差，在神经网络中主要用于表达预测值和真实值之间的差异。在数理统计中，主要是指参数估计在与参数真值之差平方的期望值。计算方法是对每一个真实值与误差值相减的平方取平均值。
# 均方误差的值越小，表明模型越好。

# 交叉熵也是Loss函数的一种，一般用在分类问题上，表达的意识为预测输入样本属于某一类的概率。

# 损失函数的选取：损失函数的选取取决于输入标签数据的类型：若输入的是实数、无界的值，损失函数使用平方差；若输入的标签是位矢量（分类标志），则使用交叉熵更合适。

# 在Tensorflow中没有单独的MSE函数，不过由于公示简单，开发者可以自己写，tf.reduce_mean(tf.square(logits - outputs))

# 在Tensorflow中常见的交叉熵函数有：Sigmoid交叉熵、softmax交叉熵、Sparse交叉熵、加权Sigmoid交叉熵

# 激活函数：加入了非线性因素，解决线性模型缺陷，常见的激活函数Sigmoid, tanh, relu

# 经过Sigmoid函数输出的函数值都会落在0~1的区间里，及Sigmoid函数能够把输入的值压缩到0~1之间。TensorFlow中Sigmoid函数：
# tf.nn.sigmoid(x, name=None)，从函数图像上看，随着x趋于正负无穷大，y对应的值越来越接近1或0，这种情况叫做饱和，处于饱和状态下的
# 激活函数意味着，当x=1000和x=100时的反映几乎都是一样的，这样的特性转换相当于将1000大于100十倍这个信息给丢失了。所以为了能够使用
# Sigmoid函数，其极限也只能是在x处于[-6, 6]之间，在[-3, 3]之间应该有比较好的效果。

# Tanh函数可以说是Sigmoid函数的值域升级版，由Sigmoid函数的(0, 1)之间升级为(-1, 1)，但是Tan函数也不能完全替代Sigmoid函数，在某些输出
# 需要大于0的情况下，还是要用Sigmoid函数。TensorFlow中对应的函数tf.nn.tanh(x, name=None).Tanh函数和Sigmoid函数有意义的缺陷，也是饱和
# 问题，所以在使用Tanh函数时，要注意输入值的绝对值不能过大，否则模型无法训练。

# 更为常用的激活函数ReLU