学习笔记1-机器学习基本的tensorflow的函数

学习文件：动手学深度学习

数据操作

import tensorflow as tf

x=tf.range(4) #[0,1,2,3]
tf.zeros((2,3,4)) #全部赋值为0
y=tf.ones((2, 3, 4))  #全部赋值为1
	#(2, 3, 4)为：  [[[1, 1, 1, 1],
    #    			 [1, 1, 1, 1],
    #    			 [1, 1, 1, 1]],
	#				[[1, 1, 1, 1],
    #    			 [1, 1, 1, 1],
    #   			 [1, 1, 1, 1]]] 
tf.size(x)|len(x)  #张量的长度
tf.shape(x)  #x的形状为(4,),表示是个一维的，y的形状为(2,3,4)，三维的
tf.reshape(x, (3, 4))  #改变形状为（3,4）
tf.random.normal(shape=[3, 4]) #标准高斯分布(均值0、标准差1)的随机采样
tf.constant([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]]) #直接赋值，大小为(3,4)
tf.exp(x)  #对x的数求ln

#形状相同的张量x,y
x +|-|*|/ y  #每个元素对应加减乘除
#x*y叫做Hadamard积，和矩阵乘法不同
x ** y  #求幂运算,x为底数，y为指数
X == Y  #每个元素对比，相同则为true，返回的是一个矩阵

#形状不相同的张量x1(3,1)，y1(1,2)
x1 = tf.reshape(tf.range(3), (3, 1))#[[0],[1],[2]]
y1 = tf.reshape(tf.range(2), (1, 2)) #[[0,1]]
x1+y1  #广播一个(3,2)的矩阵，x1复制列，y1复制行，相加运算
	#  [[0,0],    [[0,1]]      [[0, 1],
    #   [1,1], +  [[0,1]]  =    [1, 2],
    #   [2,2]]    [[0,1]]       [2, 3]] 

tf.concat([X, Y], axis=0)  #将y贴在x的下方
tf.concat([X, Y], axis=1)  #将y贴在x的右方
tf.reduce_sum(X)  #所有元素的和

#一维
X[-1] #倒数第一个
X[1:3] #第2个和第3个元素

#多维
x[0:2,:]  #第1,2行的所有数据，':'沿轴的所有列
x[0:2,1:3]  #第1,2行 第2,3列的所有数据

#tf创建的列表都是Tensors，是不可变的，也不能被改变的
#但是Variables是支持赋值的可变容器
X_var = tf.Variable(X)
X_var[1, 2].assign(9) #位置（1,2）赋值为9

tf.zero_like(X)  #创建一个和X形状一样的张量，值全为0
id(x)  #查看x的地址

#修饰符@tf.function，删除没用到的值，减少内存开销
@tf.function
def get(x,y):
	return x+y

#转换类型
A = X.numpy() #张量(ndarray)转化为numpy
B = tf.constant(A)  #numpy转化为张量(ndarray)
float(a)|int(a)|a.item() #a=(1,)时

数据处理

import pandas as pd
data = pd.read_csv(data_file)  #data_file=csv文件位置

#划分训练集和测试集
trian, test = data.iloc[:, 0:2], data.iloc[:, 2]

#插值法，将训练集的NaN替换为这一列的均值
train = train.fillna(train.mean())

#将数据转化为张量格式
X, y = tf.constant(train.values), tf.constant(test.values)

大量文献认为列向量是向量的默认方向，所以代码x=tf.range(4)可以写为：
$$x=\left[\begin{array}{c}0\\ 1\\ 2\\ 3\end{array}\right]$$

矩阵访问$$A_{2i-1,3}、A_{ij}$$

tf.transpose(A) #矩阵转置，行列交换
#对称矩阵转置相同
A * B #矩阵相乘
m*A  #每个元素乘以m

#降维
tf.reduce_sum(A, axis=1) #计算所有列的和，保留列，压缩行，降一个维度，（5,4）变（4，）
tf.reduce_mean(A, axis=0), tf.reduce_sum(A, axis=0) / A.shape[0] #计算每行的平均值，保留行，压缩列，降一个维度，（5,4）变（5，）

#tf.reduce_sum(A, axis=[0, 1])等价于tf.reduce_sum(A)
tf.reduce_mean(A), tf.reduce_sum(A) / tf.size(A).numpy() #求平均值

#不降维求和
sum_A = tf.reduce_sum(A, axis=1, keepdims=True) #（5,4）变（5,1）
A / sum_A  #保持原来的维度(5,4)变(5,4),通过广播将A除以sum_A

#向量-点积 两种实现
tf.tensordot(x, y, axes=1)
tf.reduce_sum(x * y) #x1*y1+x2*y2+x3*y3
#点积应用：
	#1.x和权重w的点积在w为非负并且和为1的时候表示加权平均
	#2.将两个向量规范化得到单位长度后，点积表示他们夹角的余弦

#矩阵-向量积
r=tf.linalg.matvec(A, x) #A=(5,4) x=(4,)  r=(5,)
#使用矩阵-向量积来描述在给定前一层的值时， 求解神经网络每一层所需的复杂计算

#矩阵-矩阵乘法
R=tf.matmul(A, B) #A=(5,4) B=(4,3) R=(5,3)

范数

范数，一个向量的范数告诉我们一个向量有多大。

欧几里得距离是一个L2范数，是向量元素平方和的平方根
L1范数是向量元素的绝对值之和
矩阵的Frobenius范数（Frobenius norm）是矩阵元素平方和的平方根
L1范数、L2范数都是Lp范数的特列：
$$L_p范数：\Vert x{\Vert }_p=(\sum _{i=1}^n|x_i{|}^p{)}^{1/p}$$

#u是向量
tf.norm(u) #计算L2的范数
tf.reduce_sum(tf.abs(u)) #L1范数

#m是矩阵
tf.norm(m) #计算矩阵的Frobenius范数
tf.linalg.norm(m) #计算矩阵的Frobenius范数

用向量表示物品（如单词、产品或新闻文章），以便最小化相似项目之间的距离，最大化不同项目之间的距离。 目标，或许是深度学习算法最重要的组成部分（除了数据），通常被表达为范数。

练习

1.考虑一个具有形状(2,3,4)的张量，在轴0、1、2上的求和输出是什么形状?

import tensorflow as tf
a=tf.reshape(tf.range(24),(2,3,4))
m=tf.reduce_sum(a,axis=0) #(3,4)
m=tf.reduce_sum(a,axis=1) #(2,4)
m=tf.reduce_sum(a,axis=2) #(2,3)

#输出tensorflow的张量
sess = tf.InteractiveSession()
print(a.eval())
print(m.eval())

a=[[[ 0  1  2  3]
  	[ 4  5  6  7]
  	[ 8  9 10 11]]
   [[12 13 14 15]
    [16 17 18 19]
    [20 21 22 23]]]
 
 #axis=0
 m=[[12 14 16 18]
    [20 22 24 26]
    [28 30 32 34]]
 
 #axis=1
 m=[[12 15 18 21]
 	[48 51 54 57]]

 #axis=2
 m=[[ 6 22 38]
    [54 70 86]]

微积分和导数

内接多边形的等长边越多，就越接近圆。 这个过程也被称为逼近法（method of exhaustion），逼近法就是积分（integral calculus）的起源，在微分学最重要的应用是优化问题，即考虑如何把事情做到最好。

但“训练”模型只能将模型与我们实际能看到的数据相拟合。 因此，我们可以将拟合模型的任务分解为两个关键问题：
1.优化（optimization）：用模型拟合观测数据的过程；
2.泛化（generalization）：数学原理和实践者的智慧，能够指导我们生成出有效性超出用于训练的数据集本身的模型。

1.导数(微分)

$$假设我们有一个函数f:{\mathbb{R}}^n\to \mathbb{R},输入和输出都是标量。如果f的导数存在$$$极限被定义为：$$f^{{}^{\prime }}(x)=\underset{h\to 0}{\lim }\frac{f(x+h)-f(x)}{h}如果$$f^{{}^{\prime }}(a)$$存在,则称f在a处可微$$如果在一个区间内的每个数上都是可微的，此函数在此区间中是可微的.$$$也可以将f^{{}^{\prime }}(x)解释为f(x)相对x的瞬间变化率（h\to 0)$

下面是一些导数运算分法则（假设函数f忽然g都是可微的，C是一个常数）：
$$常数相乘法则：f^{{}^{\prime }}(Cx)=C{f}^{{}^{\prime }}(x)$$$$加法法则：h^{{}^{\prime }}(f(x)+g(x))=f^{{}^{\prime }}(x)+g^{{}^{\prime }}(x)$$$$乘法法则：h^{{}^{\prime }}(f(x)g(x))=f^{{}^{\prime }}(x)g(x)+g^{{}^{\prime }}(x)f(x)$$$$除法法则：h^{{}^{\prime }}(\frac{f(x)}{g(x)})=\frac{f^{{}^{\prime }}(x)g(x)-g^{{}^{\prime }}(x)f(x)}{[g(x){]}^2}$$

代码中一般都是采用图形可视化，会用到Python中流行的绘图库matplotlib，要配置matplotlib生成图形的属性，我们需要定义几个函数。 在下面，use_svg_display函数指定matplotlib软件包输出svg图表以获得更清晰的图像

import numpy as np
from IPython import display
from d2l import tensorflow as d2l
def use_svg_display():  #@save
    """使用svg格式在Jupyter中显示绘图"""
    display.set_matplotlib_formats('svg')