《深度学习应用开发》学习笔记汇总（二）

说道：矩阵运算，是机器学习的基本手段，必须要掌握。
所以后面有线性代数、矩阵运算的基本介绍。
标量是一个特殊的向量（行向量、列向量），向量是一个特殊的矩阵；这样说来，标量，也是一个特殊的矩阵，一行一列的矩阵。

import numpy as np

#标量：单一的数字
scalar_value=18
print(scalar_value)

18

print(scalar_value,scalar_value.shape)
#在tf里，shape会是 () ; python里int没有shape的概念

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-3-0eab86f663c9> in <module>
----> 1 print(scalar_value,scalar_value.shape)


AttributeError: 'int' object has no attribute 'shape'

scalar_np=np.array(scalar_value)
print(scalar_np,scalar_np.shape)

18 ()

#向量：有序的数字数组
vector_value=[1,2,3]
vector_np=np.array(vector_value)
print(vector_np,vector_np.shape)
#一维数组，不能算行向量、也不能算列向量。行向量、或列向量，要用二维数组表示哦

[1 2 3] (3,)

#矩阵：有序的二维数组
matrix_list=[[1,2,3],[4,5,6]]
matrix_np=np.array(matrix_list)
print('matrix_list=',matrix_list)
print('matrix_np=\n',matrix_np)
print('matrix_np.shape=',matrix_np.shape)

matrix_list= [[1, 2, 3], [4, 5, 6]]
matrix_np=
 [[1 2 3]
 [4 5 6]]
matrix_np.shape= (2, 3)

#行向量、列向量的矩阵表示
vector_row=np.array([[1,2,3]])
print(vector_row,'shape=',vector_row.shape)
vector_column=np.array([[4],[5],[7]])
print(vector_column,'shape=',vector_column.shape)

[[1 2 3]] shape= (1, 3)
[[4]
 [5]
 [7]] shape= (3, 1)

#矩阵和标量的运算
matrix_b=matrix_np*2
print(matrix_b,'shape=',matrix_b.shape)

[[ 2  4  6]
 [ 8 10 12]] shape= (2, 3)

#矩阵和矩阵的加减法，要求矩阵尺寸相同
#矩阵和矩阵的乘法：
#1点乘、点积，要求矩阵尺寸相同.在卷积神经网络里会用到。使用运算符 * 或 np.multiply()方法
#2叉乘，这个用的比较多，A矩阵的列数=B矩阵的行数，结果C矩阵是(A行数，B列数)，例：(2,3)*(3,4)=(2,4)。使用 np.matmul()方法
matrix_a=np.array([[1,2,3],
                   [4,5,6]])
matrix_b=np.array([[1,2,3,4],
                   [2,1,2,0],
                   [3,4,1,2]])
np.matmul(matrix_a,matrix_b)

array([[14, 16, 10, 10],
       [32, 37, 28, 28]])

#转置 可以用.T 用reshape()的话，看形状了，不一定是转置
print(matrix_a,'shape=',matrix_a.shape)
print(matrix_a.T,'.T shape=',matrix_a.T.shape)

[[1 2 3]
 [4 5 6]] shape= (2, 3)
[[1 4]
 [2 5]
 [3 6]] .T shape= (3, 2)

matrix_c=matrix_a.reshape(3,2)
print(matrix_c,'shape=',matrix_c.shape)

[[1 2]
 [3 4]
 [5 6]] shape= (3, 2)

---

从人的角度来看，12个特征比1个特征要复杂了很多，
但对计算机来说，无所谓。
在tf里，12元的线性回归方程的实现，比1元的线性方程的实现，代码上也只是多了一点点复杂度而已。
这就是计算机的优势。
只是最后训练的结果，为什么都是nan，像老师说的，脸都黑了哦~

%matplotlib notebook

import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle

df=pd.read_csv('data/boston.csv',header=0)
print(df)

        CRIM   ZN   INDUS   CHAS    NOX     RM   AGE     DIS  RAD  TAX  \
0    0.00632  18.0    2.31     0  0.538  6.575  65.2  4.0900    1  296   
1    0.02731   0.0    7.07     0  0.469  6.421  78.9  4.9671    2  242   
2    0.02729   0.0    7.07     0  0.469  7.185  61.1  4.9671    2  242   
3    0.03237   0.0    2.18     0  0.458  6.998  45.8  6.0622    3  222   
4    0.06905   0.0    2.18     0  0.458  7.147  54.2  6.0622    3  222   
..       ...   ...     ...   ...    ...    ...   ...     ...  ...  ...   
501  0.06263   0.0   11.93     0  0.573  6.593  69.1  2.4786    1  273   
502  0.04527   0.0   11.93     0  0.573  6.120  76.7  2.2875    1  273   
503  0.06076   0.0   11.93     0  0.573  6.976  91.0  2.1675    1  273   
504  0.10959   0.0   11.93     0  0.573  6.794  89.3  2.3889    1  273   
505  0.04741   0.0   11.93     0  0.573  6.030  80.8  2.5050    1  273   

     PTRATIO  LSTAT  MEDV  
0       15.3   4.98  24.0  
1       17.8   9.14  21.6  
2       17.8   4.03  34.7  
3       18.7   2.94  33.4  
4       18.7   5.33  36.2  
..       ...    ...   ...  
501     21.0   9.67  22.4  
502     21.0   9.08  20.6  
503     21.0   5.64  23.9  
504     21.0   6.48  22.0  
505     21.0   7.88  11.9  

[506 rows x 13 columns]

df=df.values
print(df)

[[6.3200e-03 1.8000e+01 2.3100e+00 ... 1.5300e+01 4.9800e+00 2.4000e+01]
 [2.7310e-02 0.0000e+00 7.0700e+00 ... 1.7800e+01 9.1400e+00 2.1600e+01]
 [2.7290e-02 0.0000e+00 7.0700e+00 ... 1.7800e+01 4.0300e+00 3.4700e+01]
 ...
 [6.0760e-02 0.0000e+00 1.1930e+01 ... 2.1000e+01 5.6400e+00 2.3900e+01]
 [1.0959e-01 0.0000e+00 1.1930e+01 ... 2.1000e+01 6.4800e+00 2.2000e+01]
 [4.7410e-02 0.0000e+00 1.1930e+01 ... 2.1000e+01 7.8800e+00 1.1900e+01]]

df=np.array(df)
print(df)

x_data=df[:,:12]
y_data=df[:,12]
print(x_data,'\n,shape=',x_data.shape)
print(y_data,'\n,shape=',y_data.shape)

数据略,shape= (506, 12)

数据略,shape= (506,)

#数据就已经读进来了

#None代表未知，因为我们可以一次带入一行样本，也可以一次带入多行样本
x=tf.placeholder(tf.float32,[None,12],name='X')
y=tf.placeholder(tf.float32,[None,1],name='Y')

#定义一个命名空间
with tf.name_scope('Model'):
    #初始化随机数shape=(12,1)
    w=tf.Variable(tf.random_normal([12,1],stddev=0.01),name='W')
    b=tf.Variable(1.0,name='b')
    def model(x,w,b):
        return tf.matmul(x,w)+b
    #前向预测
    pred=model(x,w,b)
    
#这是计算机的优势。从人的角度来看，12个变量比1个变量复杂了很多，但对计算机来说，无所谓。代码上也只是多了一点点复杂度而已。

WARNING:tensorflow:From /home/ma-user/anaconda3/envs/TensorFlow-2.1.0/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1635: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.

train_epochs=2
learning_rate=0.01

#损失函数还是用均方差
with tf.name_scope('LossFunction'):
    loss_function=tf.reduce_mean(tf.pow(y-pred,2))
    
optimizer=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#准备执行
sess=tf.Session()
init=tf.global_variables_initializer()
sess.run(init)

for epoch in range(train_epochs):
    loss_sum=0.0
    for xs,ys in zip(x_data,y_data):
        xs=xs.reshape(1,12) #变形为和占位符一样，这里一次一行样本
        ys=ys.reshape(1,1)
        _,loss=sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})
        loss_sum+=loss
    x_data,y_data=shuffle(x_data,y_data)
    b0temp=b.eval(session=sess)
    w0temp=w.eval(session=sess)
    loss_average=loss_sum/len(y_data)
    
    print('epoch=',epoch+1,'loss=',loss_average,'b=',b0temp,'w=',w0temp)

epoch= 1 loss= nan b= nan w= [[nan]

 略[nan]]

---

上一节训练不出结果，都是nan的原因找到了，
就是因为特征数据没有做归一化，那归一化是个什么概念呢？
这里有一个很好的例子，做一道菜，
准备好材料鸭、笋、…盐、酱油…水，再加上烹饪火候，可以做出一道菜。

上面做菜的每一个要素，都可以看做一个特征变量，而重量可以看做是特征变量的值，比如
鸭肉xxg,(特征变量是鸭肉，值是xxg)
笋xxg,
…
盐xxg,
水xxg，
这里特征变量的值是有量级的差异的，比如水和盐来说吧，
水可以50g位为单位去加减来调整，
但是盐不可以，如果盐以50g为单位去调整，那马上咸死，这道菜就废了，
只能以1g为单位去调整。反过来，水量如果以1g去调整，那人都烦死了。
而归一化后，水和盐就处于同一个量级，不会发生上面的事情了。

通过这个例子，大约就知道为什么要做归一化了

---

那怎么做归一化呢，方法比较简单，就是
（特征值 - 特征值最小者）/（特征值最大值 - 特征值最小者）
这样归一化后的值，范围在 [0,1]之间。
标签值是不需要做归一化的哦

放一下有修改的代码，以及训练的结果：

#做归一化,对列index是0到11的特征值做归一化
#列index是12的是标签值，不需要做归一化哦
for i in range(12):
    df[:,i]= (df[:,i] - df[:,i].min()) / (df[:,i].max() - df[:,i].min())

x_data=df[:,:12]
y_data=df[:,12]
print(x_data,'\n,shape=',x_data.shape)
print(y_data,'\n,shape=',y_data.shape)

[[0.00000000e+00 1.80000000e-01 6.78152493e-02 ... 2.08015267e-01
  2.87234043e-01 8.96799117e-02]
 数据略[4.61841693e-04 0.00000000e+00 4.20454545e-01 ... 1.64122137e-01
  8.93617021e-01 1.69701987e-01]] 
,shape= (506, 12)
[24.  21.6 34.7 33.4 36.2 28.7 22.9 27.1 16.5 18.9 15.  18.9 21.7 20.4
 数据略22.  11.9] 
,shape= (506,)

train_epochs=5
learning_rate=0.01

#损失函数还是用均方差
with tf.name_scope('LossFunction'):
    loss_function=tf.reduce_mean(tf.pow(y-pred,2))
    
optimizer=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#准备执行
sess=tf.Session()
init=tf.global_variables_initializer()
sess.run(init)

for epoch in range(train_epochs):
    loss_sum=0.0
    for xs,ys in zip(x_data,y_data):
        xs=xs.reshape(1,12) #变形为和占位符一样，这里一次一行样本
        ys=ys.reshape(1,1)
        _,loss=sess.run([optimizer,loss_function],feed_dict={x:xs,y:ys})
        loss_sum+=loss
    x_data,y_data=shuffle(x_data,y_data)
    b0temp=b.eval(session=sess)
    w0temp=w.eval(session=sess)
    loss_average=loss_sum/len(y_data)
    
    print('epoch=',epoch+1,'loss=',loss_average,'b=',b0temp,'w=',w0temp)

epoch= 1 loss= 76.95622714730456 b= 15.579174 w= [[-1.7869571 ]
 数据略[-5.5532546 ]]
epoch= 5 loss= 27.729550849818775 b= 18.857027 w= [[ -3.5491831]
 数据略[-15.602908 ]]

跑了5轮，训练结果里不会再有nan了。
损失还是在慢慢下降中，所以还是有继续跑以减少损失的空间。

---

训练模型跑出来了后，要使用，但是我们没有数据了，因为数据都拿去训练了。
所以课程中，随机挑了一条训练数据来应用到模型里来使用。
这样是不好的，因为就像学习训练时将考试题都让你做过一遍，再让你考试就不公平了，类似于作弊了。
应该是考你运用学到的知识，来做没做过的题。
那比较好的做法呢，是有一些数据，把这些数据分一分，
大部分做训练、一小部分做验证、再分一小部分做测试。

下面是模型应用，也就是预测的代码

n=np.random.randint(506)
print(n)
x_test=x_data[n]
x_test=x_test.reshape(1,12)
predict=sess.run(pred,feed_dict={x:x_test})
print('predict:%f'%predict)
target=y_data[n]
print('actual:%f'%target)

449
predict:28.840622
actual:31.500000

说一千道一万，这个只是教学展示，与房价预测的实用相差万里哦~

---

可视化还是比较重要的，因为数据能在图形上看到，会更直观，更符合人的认知思维。
这里先来展示一下loss的可视化。
用matplot将列表值画出来，调用非常简单 plt.plot(loss_list)
横坐标是列表中的索引，纵坐标是列表值，也就是loss值。
可以看到，曲线在收敛了，还有下降空间，但是空间越来越小，抠一点出来也越来越难，
所以我就适可而止，跑10轮就不跑了。
代码如下：

plt.plot(loss_list)

[<matplotlib.lines.Line2D at 0x7f6da8521c50>]

print(loss_list)

[77.82311354303044, 39.53100916880596, 32.78715717594304, 30.24906668426993, 28.538294685825065, 26.90825543845976, 26.615498589579083, 26.093776806913393, 25.747446659085497, 25.427977377308565]

---

这个房价预测的例子基本就结束了，下面是用TensorBoard来将算法，和模型训练过程的一些信息进行可视化。
可视化是一件有意见的工作，有助于信息的理解和推广。
可视化在modelarts的老版的训练作业下，

是收费的，但这个服务在新版的训练作业里已经没有了，

也行是因为这个可视化服务的使用不太活跃吧

所以在Modelarts产品里做这个可视化不太方便，不过没关系，我们可以用另一个云产品来做，就是cloudide

---

房价的tf2版本，有一些变化。

1. 是直接使用sklearn.preprocessing里的scale来做归一化，更简单便捷
2. 不是一股脑将数据全用于训练，划分了分别用于训练、验证、测试的数据
3. 损失函数，优化器方面，代码有变化，头疼~
4. 对训练数据没有做打散的操作

代码如下：
最后loss看上去比较大，都上百了，是因为是做了平方的原因吧~我猜

%matplotlib inline

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.utils import shuffle
from sklearn.preprocessing import scale

df=pd.read_csv('data/boston.csv',header=0)
#print(df.describe())
#print(df)
df.head(3)

	CRIM	ZN	INDUS	CHAS	NOX	RM	AGE	DIS	RAD	TAX	PTRATIO	LSTAT	MEDV
0	0.00632	18.0	2.31	0	0.538	6.575	65.2	4.0900	1	296	15.3	4.98	24.0
1	0.02731	0.0	7.07	0	0.469	6.421	78.9	4.9671	2	242	17.8	9.14	21.6
2	0.02729	0.0	7.07	0	0.469	7.185	61.1	4.9671	2	242	17.8	4.03	34.7

df=df.values
#print(df)
df=np.array(df)

#做归一化,对列index是0到11的特征值做归一化
#列index是12的是标签值，不需要做归一化哦

x_data=df[:,:12]
y_data=df[:,12]
#print(x_data,'\n,shape=',x_data.shape)
#print(y_data,'\n,shape=',y_data.shape)

train_num=300
valid_num=100
test_num=len(x_data)-train_num-valid_num
#训练集
x_train=x_data[:train_num]
y_train=y_data[:train_num]
#验证集
x_valid=x_data[train_num:train_num+valid_num]
y_valid=y_data[train_num:train_num+valid_num]
#测试集
x_test=x_data[train_num+valid_num:len(x_data)]
y_test=y_data[train_num+valid_num:len(x_data)]

print(x_train.shape,x_valid.shape,x_test.shape)
print(y_train.shape,y_valid.shape,y_test.shape)

(300, 12) (100, 12) (106, 12)
(300,) (100,) (106,)

#转换一下类型,sklearn.preprocessing里的scale方法可以直接做归一化
x_train=tf.cast(scale(x_train),dtype=tf.float32)
x_valid=tf.cast(scale(x_valid),dtype=tf.float32)
x_test=tf.cast(scale(x_test),dtype=tf.float32)

#None代表未知，因为我们可以一次带入一行样本，也可以一次带入多行样本
#x=tf.placeholder(tf.float32,[None,12],name='X')
#y=tf.placeholder(tf.float32,[None,1],name='Y')

#定义一个命名空间
with tf.name_scope('Model'):
    #初始化随机数shape=(12,1)
    W=tf.Variable(tf.random.normal([12,1],mean=0.0,stddev=0.01),dtype=tf.float32)
    B=tf.Variable(tf.zeros(1),dtype=tf.float32)
    def model(x,w,b):
        return tf.matmul(x,w)+b
    #前向预测
    #pred=model(x,w,b)
    
#这是计算机的优势。从人的角度来看，12个变量比1个变量复杂了很多，但对计算机来说，无所谓。代码上也只是多了一点点复杂度而已。

train_epochs=5
learning_rate=0.01
batch_size=10

#损失函数还是用均方差
with tf.name_scope('LossFunction'):
    #loss_function=tf.reduce_mean(tf.pow(y-pred,2))
    def loss(x,y,w,b):
        err=model(x,w,b)-y
        squared_err=tf.square(err)
        return tf.reduce_mean(squared_err)
    def grad(x,y,w,b): #计算样本数据[x,y]在参数[w,b]点上的梯度
        with tf.GradientTape() as tape:
            loss_=loss(x,y,w,b)
        return tape.gradient(loss_,[w,b])
    optimizer=tf.keras.optimizers.SGD(learning_rate)
    
#optimizer=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)

#准备执行
#sess=tf.Session()
#init=tf.global_variables_initializer()
#sess.run(init)

loss_list_train=[]
loss_list_valid=[]
total_step=int(train_num/batch_size)
for epoch in range(train_epochs):
    
    for step in range(total_step):
        xs=x_train[step*batch_size:(step+1)*batch_size,:]
        ys=y_train[step*batch_size:(step+1)*batch_size]
        grads=grad(xs,ys,W,B)
        optimizer.apply_gradients(zip(grads,[W,B]))
        
    loss_train=loss(x_train,y_train,W,B).numpy()
    loss_valid=loss(x_valid,y_valid,W,B).numpy()
    loss_list_train.append(loss_train)
    loss_list_valid.append(loss_valid)
    
    print('epoch={:3d},train_loss={:.4f},valid_loss={:.4f}'.format(epoch+1,loss_train,loss_valid))

epoch=  1,train_loss=297.3062,valid_loss=209.3717
epoch=  5,train_loss=104.6808,valid_loss=127.0953

plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.plot(loss_list_train,'blue',label='Train Loss')
plt.plot(loss_list_valid,'red',label='Valid Loss')
plt.legend(loc=1)

<matplotlib.legend.Legend at 0x7f59e8638f10>

print('Test_loss:{:.4f}'.format(loss(x_test,y_test,W,B).numpy()))

Test_loss:122.4169

n=np.random.randint(test_num)
y_pred=model(x_test,W,B)[n]  #x_test:shape(106,12) W:shape(12,1) 相当于全部算出来
y_predit=tf.reshape(y_pred,()).numpy()
target=y_test[n]
print('House id',n,'Actual value',target,'predict value',y_predit)

House id 78 Actual value 14.6 predict value 25.130033

---

终于进了一步，看到了MNIST手写数字识别，使用一个神经元。
MNIST数据集来自于 NIST 美国国家标准和技术研究所。
找学生和工作人员手写的。
规模：训练集55000，验证集5000，测试集10000。大小约10M。
数据集可以在网站上去下载，同时tf自己里面已经集成了这个数据集。

在notebook里试试：

%matplotlib inline
import tensorflow.compat.v1 as tf
tf.disable_eager_execution()
import matplotlib.pyplot as plt

#tf2里面没法使用tf1.x的方法来读取MNIST数据,兼容库里也没有的
import tensorflow.compat.v1.examples.tutorials.mnist.input_data as input_data

---------------------------------------------------------------------------

ModuleNotFoundError                       Traceback (most recent call last)

<ipython-input-4-d97a1109d08b> in <module>
----> 1 import tensorflow.compat.v1.examples.tutorials.mnist.input_data as input_data


ModuleNotFoundError: No module named 'tensorflow.compat.v1.examples'

#用tf2来读取数据
import tensorflow as tf
import matplotlib.pyplot as plt
mnist = tf.keras.datasets.mnist
(train_images,train_labels),(test_image,test_labels)=mnist.load_data()

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 1s 0us/step

#后续处理是否又使用tf1.x来做呢？虽然有点不伦不类，后面还是试一试吧

---

先探索一下tf2里读取出的数据。
每张图片的数据化表示是28*28=784个数值，每个数值的类型是numpy.uint8，uint8的取值范围是0-255,
这个可能就是所谓的256位图吧？
每张图片会有自己的标签，就是表示这张图片是数字0-9中的哪个。
另外用reshape重整了一下图像，比较有趣

以下为Notebook代码

print(train_images.shape,train_labels.shape,test_image.shape,test_labels.shape)
#60000条训练集里再分了55000的训练和5000的验证；28和28代表图片尺寸

(60000, 28, 28) (60000,) (10000, 28, 28) (10000,)

print('image data:',train_images[1])
print('image label:',train_labels[1])

image data: [[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0]
 数据略[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0]]
image label: 0

#看下这个图片长什么样
def plot_image(image):
    plt.imshow(image.reshape(28,28),cmap='binary')
    plt.show()
    
plot_image(train_images[1])

#插播学习一下reshape,总体顺序还是不变，但切分点变了
import numpy as np
int_array=np.array([i for i in range(64)])
print(int_array)
print(int_array.reshape(8,8))
print(int_array.reshape(4,16))

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63]
[[ 0  1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14 15]
 [16 17 18 19 20 21 22 23]
 [24 25 26 27 28 29 30 31]
 [32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47]
 [48 49 50 51 52 53 54 55]
 [56 57 58 59 60 61 62 63]]
[[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
 [16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31]
 [32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47]
 [48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63]]

#来看一个有趣的，把28*28整形为14*56.这个好像变身术，1个变2个，但变化后的每个图像信息只有原图的一半，只是图像表达的信息简单，
#所以我们还是可以认出这是2个0
plt.imshow(train_images[1].reshape(14,56),cmap='binary')
plt.show()
#对比看一下
plot_image(train_images[1])

---

这里谈到了独热编码one-hot，独热编码是用来表示标签数据的。前面已经知道了，标签数据很简单，就是表示0-9范围内的一个数字。
说实话独热编码有什么用处，真的还没有理解。还有什么欧式空间的概念啊，都很陌生。

#独热编码示例。
x=[3,4]
tf.one_hot(x,depth=10)

<tf.Tensor: shape=(2, 10), dtype=float32, numpy=
array([[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]], dtype=float32)>

#一维数组
A=tf.constant([3,9,22,60,8,9])
print(tf.argmax(A).numpy())
#二维数组 axis轴为0时，在每列中取值最大者，结果长度为列数。
B=tf.constant([[3,20,33,99,11],
               [2,99,33,12,3],
               [14,90,1,3,98]]
               )
print(tf.math.argmax(B,axis=0).numpy())
print(tf.math.argmax(B,axis=1).numpy())

3
[2 1 0 0 2]
[3 1 4]

#numpy也有argmax()方法
import numpy as np
C=np.array([[3,20,33,99,11],
            [2,99,33,12,3],
            [14,90,1,3,98]])
print(np.argmax(C,axis=1))

[3 1 4]

---

概率的表示，用零和一之间的一个数字能很好的表示。

这个函数的作用就是把任意一个数值用来转换成0~1之间的一个数。

从某一个角度来看，似乎和训练数据的归一化有相似之处。

不管那么多了，处理数字，没几个合适的函数怎么能行。

到2021年8月份，后面就丢下没继续学了。