踏破万里无云

【神经网络与深度学习-TensorFlow实践】-中国大学MOOC课程（十一）（分类问题））

11 分类问题
- 11.1 逻辑回归
- - 11.1.1 广义线性回归
  - 11.1.2 逻辑回归
  - - 11.1.2.1 分类问题
    - 11.1.2.2 实现分类器
  - 11.1.3 交叉熵损失函数
  - 11.1.4 准确率（accuracy）
  - 11.1.5 手推三分类问题-交叉熵损失函数，权值更新公式
- 11.2 实例：实现一元逻辑回归
- - 11.2.1 sigmoid()函数-代码实现
  - 11.2.2 交叉熵损失函数-代码实现
  - 11.2.3 准确率-代码实现
  - - 11.2.3.1 判断阈值是0.5-tf.round()函数
    - 11.2.3.2 判断阈值不是0.5--where(condition,a,b)函数
  - 11.2.4 一元逻辑回归-房屋销售记录实例
  - - 11.2.4.1 加载数据
    - 11.2.4.2 数据处理
    - 11.2.4.3 设置超参数
    - 11.2.4.4 设置模型变量初始值
    - 11.2.4.5 训练模型
    - 11.2.4.6 增加sigmoid曲线可视化输出
    - 11.2.4.7 验证模型
    - 11.2.4.8 预测值的sigmoid曲线和散点图
- 11.3 线性分类器（Linear Classifier）
- - 11.3.1 决策边界-线性可分
  - 11.3.2 线性不可分
  - 11.3.3 逻辑运算
  - - 11.3.3.1 线性可分-与、或、非
    - 11.3.3.2 线性不可分-异或
- 11.4 实例：实现多元逻辑回归
- - 11.4.1 实现多元逻辑回归
  - - 11.4.1.1 鸢尾花数据集（iris）再次介绍
    - 11.4.1.2 实现多元逻辑回归
    - - 11.4.1.2.1 加载数据
      - 11.4.1.2.2 处理数据
      - 11.4.1.2.2.1 自己定义色彩方案mpl.colors.ListedColormap()
        
        11.4.1.2.2.2 无须归一化，只需中心化
      - 11.4.1.2.3 设置超参数
      - 11.4.1.2.4 设置模型参数初始值
      - 11.4.1.2.5 训练模型
      - 11.4.1.2.6 代码汇总（包含前五个步骤）
      - 11.4.1.2.6 可视化
      - 11.4.1.2.6.1 绘制损失和准确率变化曲线
        
        11.4.1.2.6.2 绘制决策边界
        
        11.4.1.2.6.3 在训练过程中绘制决策边界*
      - 11.4.1.2.7 使用测试集
  - 11.4.2 绘制分类图
  - - 11.4.2.1 生成网格坐标矩阵np.meshgrid()
    - 11.4.2.2 填充网格 plt.pcolomesh()
    - - 11.4.2.2.1 rainbow色彩方案
      - 11.4.2.2.2 自己定义的色彩方案
    - 11.4.2.3 绘制轮廓线plt.contour()
    - - 11.4.2.3.1 给轮廓线之间填充颜色plt.contourf(X,Y,Z,a,cmap)
    - 11.4.2.4 绘制分类图例子
    - 11.4.2.5 根据鸢尾花分类模型，绘制训练集和测试集分类图
    - 11.4.2.5 使用定义函数借鉴上一节代码
    - 11.4.2.6 使用四种属性区分变色鸢尾和维吉尼亚鸢尾
- 11.5 多分类问题
- - 11.5.1 类别编码问题
  - 11.5.2 实例，多分类问题
- 11.6 实例：多分类问题
- - 11.6.1 独热编码的实现
  - 11.6.2 准确率的计算
  - 11.6.3 交叉熵损失函数的实现
  - 11.6.4 使用花瓣长度、花瓣宽度将三种鸢尾花区分开
  - - 11.6.4.0 修改动态分配显存
    - 11.6.4.1 加载数据
    - 11.6.4.2 处理数据
    - 11.6.4.3 设置超参数、设置模型参数初始值
    - 11.6.4.4 训练模型
    - 11.6.4.5 查看训练结果
    - 11.6.4.6 绘制分类图
    - 11.6.4.7 本例代码汇总
- 11.7 参考文献

11 分类问题

11.1 逻辑回归

11.1.1 广义线性回归

课程回顾

线性回归：将自变量和因变量之间的关系，用线性模型来表示；根据已知的样本数据，对未来的、或者未知的数据进行估计

对数线性回归（log-linear regression）
lny = wx+b 即：y=e^wx+b
Y= wx+b
g(y) = wx+b 也即：y=h(wx+b)
y = g^-1(wx+b)
广义线性模型（generalized linear model）

g(·)：联系函数（link function），任何单调可微函数

高维模型 Y = g^-1(W^TX)
W = (w₀,w₁,…,w_m)^T
X = (x₀,x₁,…,x_m)^T
x⁰=1

11.1.2 逻辑回归

11.1.2.1 分类问题

分类问题：垃圾邮件识别，图片分类，疾病判断
分类器：能偶自动对输入的数据进行分类
输入：特征；输出：离散值

11.1.2.2 实现分类器

准备训练样本
训练分类器
对新样本分类
单位阶跃函数（unit-step function）
不光滑
不连续
二分类问题 1/0–正例和反例
对数几率函数（logistic function）:y=1/(1+e^-z)
单调上升，连续，光滑
任意阶可导
对数几率回归/逻辑回归（logistic regression）：y=1/（1+e^-(wx+b)）
Sigmoid函数：形状s的函数，能够将取值范围无穷大的函数转化为一个0到1范围的值；
y=g^-1(z)=σ(z)=σ(wx+b)=1/(1+e^-z)=1/(1+e^-(wx+b))
多元模型
y = 1/(1+e^{-(W^TX)})
W = (w₀,w₁,…,w_m)^T
X = (x₀,x₁,…,x_m)^T
x⁰=1

11.1.3 交叉熵损失函数

交叉熵损失函数

每一项误差都是非负的
函数值和误差的变化趋势一致
凸函数
对模型参数求偏导数，无σ’()项

平均交叉熵损失函数

偏导数的值只受到标签值和预测值偏差的影响
交叉熵损失函数是凸函数，因此使用梯度下降法得到的极小值就是全局最小值

11.1.4 准确率（accuracy）

可以使用准确率来评价一个分类器性能
准确率=正确分类的样本数/总样本数
仅仅通过准确率是无法细分出模型分类器的优劣的

11.1.5 手推三分类问题-交叉熵损失函数，权值更新公式

11.2 实例：实现一元逻辑回归

11.2.1 sigmoid()函数-代码实现

y = 1 / ( 1 + e^-(wx+b))

>>> import tensorflow as tf
>>> import numpy as np
>>> x = np.array([1.,2.,3.,4.])
>>> w = tf.Variable(1.)
>>> b = tf.Variable(1.)
>>> y = 1/(1+tf.exp(-(w*x+b)))
>>> y
<tf.Tensor: id=46, shape=(4,), dtype=float32, numpy=array([0.880797  , 0.95257413, 0.98201376, 0.9933072 ], dtype=float32)>

注意tf.exp()函数的参数要求是浮点数，否则会报错

11.2.2 交叉熵损失函数-代码实现

>>> import tensorflow as tf
>>> import numpy as np

>>> y = np.array([0,0,1,1])
>>> pred=np.array([0.1,0.2,0.8,0.49])

>>> # 交叉熵损失函数
>>> -tf.reduce_sum(y*tf.math.log(pred)+(1-y)*tf.math.log(1-pred))
<tf.Tensor: id=58, shape=(), dtype=float64, numpy=1.2649975061637104>

>>> # 平均交叉熵巡损失函数
>>> -tf.reduce_mean(y*tf.math.log(pred)+(1-y)*tf.math.log(1-pred)) 
<tf.Tensor: id=70, shape=(), dtype=float64, numpy=0.3162493765409276>

11.2.3 准确率-代码实现

11.2.3.1 判断阈值是0.5-tf.round()函数

准确率=正确分类的样本数/总样本数

>>> import tensorflow as tf
>>> import numpy as np

>>> y = np.array([0,0,1,1])
>>> pred=np.array([0.1,0.2,0.8,0.49])

>>> # 如果将阈值设为0.5，可以使用四舍五入函数round()将其转换为0或1 
>>> tf.round(pred)
<tf.Tensor: id=83, shape=(4,), dtype=float64, numpy=array([0., 0., 
1., 0.])>

>>> # 然后使用equal()函数逐元素比较预测值和标签值，得到的结果是一个
和y形状相同的一维张量
>>> tf.equal(tf.round(pred),y)
<tf.Tensor: id=87, shape=(4,), dtype=bool, numpy=array([ True,  True,  True, False])>

>>> # 下面使用cast()函数把这个结果转化为整数
>>> tf.cast(tf.equal(tf.round(pred),y),tf.int8)
<tf.Tensor: id=92, shape=(4,), dtype=int8, numpy=array([1, 1, 1, 0], dtype=int8)>

>>> # 然后对所有的元素求平均值，就是得到正确样本在所有样本中的比例 
>>> tf.reduce_mean(tf.cast(tf.equal(tf.round(pred),y),tf.int8))    
<tf.Tensor: id=99, shape=(), dtype=int8, numpy=0>

>>> # 记得，如果round()函数，参数是0.5，返回的值是0
>>> tf.round(0.5)
<tf.Tensor: id=101, shape=(), dtype=float32, numpy=0.0>

11.2.3.2 判断阈值不是0.5–where(condition,a,b)函数

where(condition,a,b)

根据条件condition返回a或者b的值
如果condition中的某个元素为真，对应位置返回a，否则返回b

>>> import tensorflow as tf
>>> import numpy as np

>>> y = np.array([0,0,1,1])
>>> pred=np.array([0.1,0.2,0.8,0.49])

>>> tf.where(pred<0.5,0,1)
<tf.Tensor: id=105, shape=(4,), dtype=int32, numpy=array([0, 0, 1, 
0])>

>>> pred<0.5
array([ True,  True, False,  True])

>>> tf.where(pred<0.4,0,1)

参数a和b还可以是数组或者张量，这时，a和b必须有相同的形状，并且他们的第一维必须和condition形状一致

>>> import tensorflow as tf
>>> import numpy as np

>>> pred=np.array([0.1,0.2,0.8,0.49])

>>> a = np.array([1,2,3,4])
>>> b = np.array([10,20,30,40])

>>> # 当pred中的元素小于0.5时，就返回a中对应位置的元素，否则，返回b中对应位置的元素
>>> tf.where(pred<0.5,a,b)
<tf.Tensor: id=117, shape=(4,), dtype=int32, numpy=array([ 1,  2, 30,  4])>
>>> # 可以看到数组pred中1、2、4个元素都小于0.5，因此取数组a中的元素
，而第3个元素大于0.5，取b中的元素

参数a和b也可以省略，这时的返回值数组pred中大于等于0.5的元素的索引，返回值以一个二维张量的形式给出

>>> tf.where(pred>=0.5)
<tf.Tensor: id=119, shape=(1, 1), dtype=int64, numpy=array([[2]], dtype=int64)>

*下面使用where计算准确率

>>> import tensorflow as tf
>>> import numpy as np
>>> y = np.array([0,0,1,1]) 
>>> pred=np.array([0.1,0.2,0.8,0.49])  

>>> tf.reduce_mean(tf.cast(tf.equal(tf.where(pred<0.5,0,1),y),tf.float32))
<tf.Tensor: id=136, shape=(), dtype=float32, numpy=0.75>

11.2.4 一元逻辑回归-房屋销售记录实例

0：普通住宅；1：高档住宅

11.2.4.1 加载数据

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# 面积
x = np.array([137.97,104.50,100.00,124.32,79.20,99.00,124.00,114.00,106.69,138.05,53.75,46.91,68.00,63.02,81.26,86.21])
# 类型
y = np.array([1,1,0,1,0,1,1,0,0,1,0,0,0,0,0,0])

plt.scatter(x,y)
plt.show()

输出结果为：

类别只有0和1两种

11.2.4.2 数据处理

# 2 数据处理
# sigmoid函数是以0点为中心的，所以对数据中心化
x_train = x - np.mean(x)
y_train = y

plt.scatter(x_train,y_train)
plt.show()

输出结果为：

可以看到，这些点整体平移，这些点相对位置不变

11.2.4.3 设置超参数

# 3 设置超参数
learn_rate = 0.005
iter = 5
display_step = 1

11.2.4.4 设置模型变量初始值

# 4 设置模型变量初始值
np.random.seed(612)
w = tf.Variable(np.random.randn())
b = tf.Variable(np.random.randn())

11.2.4.5 训练模型

# 5 训练模型
cross_train = []
acc_train = []

for i in range(0,iter+1):

    with tf.GradientTape() as tape:
        pred_train = 1/(1+tf.exp(-w*x_train+b))
        Loss_train = -tf.reduce_mean(y_train*tf.math.log(pred_train)+(1-y_train)*tf.math.log(1-pred_train))
        Accuracy_train = tf.reduce_mean(tf.cast(tf.equal(tf.where(pred_train<0.5,0,1),y_train),tf.float32))

    cross_train.append(Loss_train)
    acc_train.append(Accuracy_train)

    dL_dw,dL_db = tape.gradient(Loss_train,[w,b])

    w.assign_sub(learn_rate*dL_dw)
    b.assign_sub(learn_rate*dL_db)

    if i % display_step == 0:
        print("i: %i, Train Loss: %f, Accuracy: %f" % (i,Loss_train,Accuracy_train))

输出结果为：

i: 0, Train Loss: 1.140986, Accuracy: 0.375000
i: 1, Train Loss: 0.703207, Accuracy: 0.625000
i: 2, Train Loss: 0.648479, Accuracy: 0.625000
i: 3, Train Loss: 0.631729, Accuracy: 0.687500
i: 4, Train Loss: 0.624276, Accuracy: 0.687500
i: 5, Train Loss: 0.620331, Accuracy: 0.750000

11.2.4.6 增加sigmoid曲线可视化输出

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# 面积
x = np.array([137.97,104.50,100.00,124.32,79.20,99.00,124.00,114.00,106.69,138.05,53.75,46.91,68.00,63.02,81.26,86.21])
# 类型
y = np.array([1,1,0,1,0,1,1,0,0,1,0,0,0,0,0,0])

# 2 数据处理
# sigmoid函数是以0点为中心的，所以对数据中心化
x_train = x - np.mean(x)
y_train = y

# 3 设置超参数
learn_rate = 0.005
iter = 5
display_step = 1

# 4 设置模型变量初始值
np.random.seed(612)
w = tf.Variable(np.random.randn())
b = tf.Variable(np.random.randn())

x_ = range(-80,80)
y_ = 1/(1+tf.exp(-(w*x_+b)))

# 迭代之前，输出数据的散点图
plt.scatter(x_train,y_train)
# 使用初始化参数时的sigmoid曲线
plt.plot(x_,y_,c='r',linewidth=3)

# 5 训练模型
cross_train = []
acc_train = []

for i in range(0,iter+1):

    with tf.GradientTape() as tape:
        pred_train = 1/(1+tf.exp(-w*x_train+b))
        Loss_train = -tf.reduce_mean(y_train*tf.math.log(pred_train)+(1-y_train)*tf.math.log(1-pred_train))
        Accuracy_train = tf.reduce_mean(tf.cast(tf.equal(tf.where(pred_train<0.5,0,1),y_train),tf.float32))

    cross_train.append(Loss_train)
    acc_train.append(Accuracy_train)

    dL_dw,dL_db = tape.gradient(Loss_train,[w,b])

    w.assign_sub(learn_rate*dL_dw)
    b.assign_sub(learn_rate*dL_db)

    if i % display_step == 0:
        print("i: %i, Train Loss: %f, Accuracy: %f" % (i,Loss_train,Accuracy_train))
        y_ = 1/(1+tf.exp(-(w*x_+b)))
        plt.plot(x_,y_)
        # 输出当前权值时的sigmoid曲线
plt.show()

输出结果为：

红色是使用初始参数时的sigmoid曲线，虽然看起来很离谱，但是恰好属于普通住宅的这10个样本的概率都在0.5以下，所以分类正确率为10/16
蓝色是第一次迭代结果
紫色是最后一次迭代的结果
在0-20之间，出现一段的重合，有一定的交集，所以这个区域中的点可能会出现分类错误，导致准确率无法达到100
第一次分类的结果，虽然正确率更大，但是从整体来看，还是经过更多次迭代之后更加合理

11.2.4.7 验证模型

x_test = [128.15,45.00,141.43,106.27,99.00,53.84,85.36,70.00,162.00,114.60]
pred_test = 1/(1+tf.exp(-(w*(x_test-np.mean(x))+b)))
y_test = tf.where(pred_test<0.5,0,1)
for i in range(len(x_test)):
    print(x_test[i],"\t",pred_test[i].numpy(),"\t",y_test[i].numpy(),"\t")

输出结果为：

128.15   0.84752923      1 
45.0     0.003775026     0
141.43   0.94683856      1
106.27   0.4493811       0
99.0     0.30140132      0
53.84    0.008159011     0
85.36    0.11540905      0
70.0     0.032816157     0
162.0    0.99083763      1
114.6    0.62883806      1

11.2.4.8 预测值的sigmoid曲线和散点图

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# 面积
x = np.array([137.97,104.50,100.00,124.32,79.20,99.00,124.00,114.00,106.69,138.05,53.75,46.91,68.00,63.02,81.26,86.21])
# 类型
y = np.array([1,1,0,1,0,1,1,0,0,1,0,0,0,0,0,0])

# 2 数据处理
# sigmoid函数是以0点为中心的，所以对数据中心化
x_train = x - np.mean(x)
y_train = y

# 3 设置超参数
learn_rate = 0.005
iter = 5
display_step = 1

# 4 设置模型变量初始值
np.random.seed(612)
w = tf.Variable(np.random.randn())
b = tf.Variable(np.random.randn())

#x_ = range(-80,80)
#y_ = 1/(1+tf.exp(-(w*x_+b)))

# 迭代之前，输出数据的散点图
#plt.scatter(x_train,y_train)
# 使用输出参数时的sigmoid曲线
#plt.plot(x_,y_,c='r',linewidth=3)

# 5 训练模型
cross_train = []
acc_train = []

for i in range(0,iter+1):

    with tf.GradientTape() as tape:
        pred_train = 1/(1+tf.exp(-w*x_train+b))
        Loss_train = -tf.reduce_mean(y_train*tf.math.log(pred_train)+(1-y_train)*tf.math.log(1-pred_train))
        Accuracy_train = tf.reduce_mean(tf.cast(tf.equal(tf.where(pred_train<0.5,0,1),y_train),tf.float32))

    cross_train.append(Loss_train)
    acc_train.append(Accuracy_train)

    dL_dw,dL_db = tape.gradient(Loss_train,[w,b])

    w.assign_sub(learn_rate*dL_dw)
    b.assign_sub(learn_rate*dL_db)

    if i % display_step == 0:
        print("i: %i, Train Loss: %f, Accuracy: %f" % (i,Loss_train,Accuracy_train))
        #y_ = 1/(1+tf.exp(-(w*x_+b)))
        #plt.plot(x_,y_)
# 虽然使用x_test表示，但是它们不是测试集，测试集是有标签的数据
x_test = [128.15,45.00,141.43,106.27,99.00,53.84,85.36,70.00,162.00,114.60]
pred_test = 1/(1+tf.exp(-(w*(x_test-np.mean(x))+b)))
y_test = tf.where(pred_test<0.5,0,1)
for i in range(len(x_test)):
    print(x_test[i],"\t",pred_test[i].numpy(),"\t",y_test[i].numpy(),"\t")

plt.scatter(x_test,y_test)

x_ = range(-80,80)
y_ = 1/(1+tf.exp(-(w*x_+b)))
plt.plot(x_+np.mean(x),y_)

plt.show()

输出结果为:

11.3 线性分类器（Linear Classifier）

11.3.1 决策边界-线性可分

二维空间中的数据集，如果可以被一条直线分为两类，我们称之为线性可分数据集，这条直线就是一个线性分类器
在三维空间中，如果数据集线性可分，是指被一个平面分为两类
在一维空间中，所有的点都在一条直线上，线性可分可以理解为可以被一个点分开
这里的，分类直线、平面、点被称为决策边界
一个m维数据集，
如果可以被一个超平面一分为二，那么这个数据集就是线性可分的，这个超平面就是决策边界

11.3.2 线性不可分

线性不可分：样本得两条直线分开，或者一条曲线分开

11.3.3 逻辑运算

11.3.3.1 线性可分-与、或、非

在逻辑运算中，与&、或|、非！都是线性可分的
显然可以通过训练得到对应的分类器，并且一定收敛
与运算
或运算
非运算

11.3.3.2 线性不可分-异或

异或运算，也可以看作是按类加运算
显然，要分开它，最少得两条直线

11.4 实例：实现多元逻辑回归

11.4.1 实现多元逻辑回归

11.4.1.1 鸢尾花数据集（iris）再次介绍

在这里，使用逻辑回归实现对鸢尾花（iris）的分类
Iris数据集

150个样本
4个属性：花萼长度（Sepal Length）、花萼宽度（Sepal Width）、花瓣长度（Petal Length）、花瓣宽度（Petal Width）
1个标签：山鸢尾（Setosa）、变色鸢尾（Versicolour）、维吉尼亚鸢尾（Virginica）
属性两两可视化后的结果为：

山鸢尾（蓝色）、变色鸢尾（红色）、维吉尼亚鸢尾（绿色）

蓝色的与其他两个差别大，选择任何两个都可以区分开；所以选择蓝色（山鸢尾）的和红色（变色鸢尾）两种鸢尾花，花萼长度和花萼宽度两种属性，通过逻辑回归实现对他们的分类
了解鸢尾花数据集的具体使用方法可以参考【神经网络与深度学习-TensorFlow实践】-中国大学MOOC课程（六）（Matplotlib数据可视化））中的6.5节

11.4.1.2 实现多元逻辑回归

11.4.1.2.1 加载数据

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)

df_iris = pd.read_csv(train_path,header=0) # 是一个pandas二维数据表

11.4.1.2.2 处理数据

11.4.1.2.2.1 自己定义色彩方案mpl.colors.ListedColormap()

11.4.1.2.2.2 无须归一化，只需中心化

# 2 处理数据
# 首先将二维数据表转化为numpy数组
iris= np.array(df_iris)  # shape(120,5)

# 提取属性和标签
train_x = iris[:,0:2]  # （120，2）
train_y = iris[:,4] # （120，）

# 提取山鸢尾和变色鸢尾，提取出标签纸为0和1的值
x_train = train_x[train_y < 2] # (78,2)
y_train = train_y[train_y < 2] # (78,)

# 记录现在的样本数
num = len(x_train)
# 中心化处理
x_train = x_train - np.mean(x_train,axis= 0)

# 生成多元模型的属性矩阵和标签列向量
x0_train = np.ones(num).reshape(-1,1)
X = tf.cast(tf.concat((x0_train,x_train),axis=1),tf.float32) # shape(78,3)
Y = tf.cast(y_train.reshape(-1,1),tf.float32) # shape(78,1)
# 可视化样本
#cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案
#plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
#plt.show()

处理结果为：

可以看到中心化之后，样本点被平移，样本点的横坐标和纵坐标都是0

11.4.1.2.3 设置超参数

# 3 设置超参数
learn_rate = 0.2 
iter = 120
display_step = 30

11.4.1.2.4 设置模型参数初始值

# 4 设置模型参数初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(3,1),dtype=tf.float32)

11.4.1.2.5 训练模型

# 5 训练模型
ce = []
acc = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        PRED = 1/(1+tf.exp(-tf.matmul(X,W))) # 每个样本的预测概率
        Loss = -tf.reduce_mean(Y*tf.math.log(PRED)+(1-Y)*tf.math.log(1-PRED))

    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED.numpy()<0.5,0.,1.),Y),tf.float32))
    ce.append(Loss)
    acc.append(accuracy)

    dL_dW = tape.gradient(Loss,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step ==0:
        print("i: %i, Acc: %f, Loss: %f" % (i,accuracy,Loss))

输出结果为：

i: 0, Acc: 0.230769, Loss: 0.994269
i: 30, Acc: 0.961538, Loss: 0.481892
i: 60, Acc: 0.987179, Loss: 0.319128
i: 90, Acc: 0.987179, Loss: 0.246626
i: 120, Acc: 1.000000, Loss: 0.204982

11.4.1.2.6 代码汇总（包含前五个步骤）

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)

df_iris = pd.read_csv(train_path,header=0) # 是一个pandas二维数据表

# 2 处理数据
# 首先将二维数据表转化为numpy数组
iris= np.array(df_iris)  # shape(120,5)

# 提取属性和标签
train_x = iris[:,0:2]  # （120，2）
train_y = iris[:,4] # （120，）

# 提取山鸢尾和变色鸢尾，提取出标签纸为0和1的值
x_train = train_x[train_y < 2] # (78,2)
y_train = train_y[train_y < 2] # (78,)

# 记录现在的样本数
num = len(x_train)
# 中心化处理
x_train = x_train - np.mean(x_train,axis= 0)

# 生成多元模型的属性矩阵和标签列向量
x0_train = np.ones(num).reshape(-1,1)
X = tf.cast(tf.concat((x0_train,x_train),axis=1),tf.float32) # shape(78,3)
Y = tf.cast(y_train.reshape(-1,1),tf.float32) # shape(78,1)
# 可视化样本
#cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案
#plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
#plt.show()

# 3 设置超参数
learn_rate = 0.2 
iter = 120
display_step = 30

# 4 设置模型参数初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(3,1),dtype=tf.float32)

# 5 训练模型
ce = []
acc = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        PRED = 1/(1+tf.exp(-tf.matmul(X,W))) # 每个样本的预测概率
        Loss = -tf.reduce_mean(Y*tf.math.log(PRED)+(1-Y)*tf.math.log(1-PRED))

    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED.numpy()<0.5,0.,1.),Y),tf.float32))
    ce.append(Loss)
    acc.append(accuracy)

    dL_dW = tape.gradient(Loss,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step ==0:
        print("i: %i, Acc: %f, Loss: %f" % (i,accuracy,Loss))

11.4.1.2.6 可视化

11.4.1.2.6.1 绘制损失和准确率变化曲线

# 损失和准确率变化曲线
plt.figure(figsize=(5,3))
plt.plot(ce,c='b',label="Loss")
plt.plot(acc,c='r',label="acc")
plt.legend()
plt.show()

输出结果为：

损失一直单调下降，所以损失下降曲线很光滑
而准确率上升到一定的数值之后，有时候会停留在某个时间一段时间，因此呈现出台阶上升的趋势

11.4.1.2.6.2 绘制决策边界

# 绘制决策边界
cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案
plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
x_ = [-1.5,1.5]
y_ = -(W[1]*x_+W[0])/W[2]
plt.plot(x_,y_,c='g')
plt.show()

输出结果为：

11.4.1.2.6.3 在训练过程中绘制决策边界*

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)

df_iris = pd.read_csv(train_path,header=0) # 是一个pandas二维数据表

# 2 处理数据
# 首先将二维数据表转化为numpy数组
iris= np.array(df_iris)  # shape(120,5)

# 提取属性和标签
train_x = iris[:,0:2]  # （120，2）
train_y = iris[:,4] # （120，）

# 提取山鸢尾和变色鸢尾，提取出标签纸为0和1的值
x_train = train_x[train_y < 2] # (78,2)
y_train = train_y[train_y < 2] # (78,)

# 记录现在的样本数
num = len(x_train)
# 中心化处理
x_train = x_train - np.mean(x_train,axis= 0)

# 生成多元模型的属性矩阵和标签列向量
x0_train = np.ones(num).reshape(-1,1)
X = tf.cast(tf.concat((x0_train,x_train),axis=1),tf.float32) # shape(78,3)
Y = tf.cast(y_train.reshape(-1,1),tf.float32) # shape(78,1)
# 可视化样本
#cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案
#plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
#plt.show()

# 3 设置超参数
learn_rate = 0.2 
iter = 120
display_step = 30

# 4 设置模型参数初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(3,1),dtype=tf.float32)

cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案

x_ = [-1.5,1.5]
y_ = -(W[0]+W[1]*x_)/W[2]

plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
plt.plot(x_,y_,c='r',linewidth=3)
plt.xlim([-1.5,1.5])
plt.ylim([-1.5,1.5])

# 5 训练模型
ce = []
acc = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        PRED = 1/(1+tf.exp(-tf.matmul(X,W))) # 每个样本的预测概率
        Loss = -tf.reduce_mean(Y*tf.math.log(PRED)+(1-Y)*tf.math.log(1-PRED))

    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED.numpy()<0.5,0.,1.),Y),tf.float32))
    ce.append(Loss)
    acc.append(accuracy)

    dL_dW = tape.gradient(Loss,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step ==0:
        print("i: %i, Acc: %f, Loss: %f" % (i,accuracy,Loss))
        y_ = -(W[0]+W[1]*x_)/W[2]
        plt.plot(x_,y_)

plt.show()

红色的是初始的，之后慢慢调增

11.4.1.2.7 使用测试集

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"
train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)
test_path = tf.keras.utils.get_file(TEST_URL.split('/')[-1],TEST_URL)

df_iris_train = pd.read_csv(train_path,header=0) # 是一个pandas二维数据表
df_iris_test =  pd.read_csv(test_path,header=0)

# 2 处理数据
# 首先将二维数据表转化为numpy数组
iris_train= np.array(df_iris_train)  # shape(120,5)
iris_test= np.array(df_iris_test)  # shape(30,5)

# 提取属性和标签
train_x = iris_train[:,0:2]  # （120，2）
train_y = iris_train[:,4] # （120，）

test_x = iris_test[:,0:2]  # （30，2）
test_y = iris_test[:,4] # （30，）
# 提取山鸢尾和变色鸢尾，提取出标签纸为0和1的值
x_train = train_x[train_y < 2] # (78,2)
y_train = train_y[train_y < 2] # (78,)

x_test = test_x[test_y < 2] # (22,2)
y_test = test_y[test_y < 2] # (22,)
# 记录现在的样本数
num_train = len(x_train)
num_test = len(x_test)
# 分别进行按列中心化处理，要求训练集和测试集独立同分布的，具有相同的均值和方差，数量有限的情况下，只要尽量接近即可
# 使用划分好的不用太考虑，但是自己划分数据集，要考虑这点
x_train = x_train - np.mean(x_train,axis= 0)
x_test = x_test - np.mean(x_test,axis=0)

# 生成多元模型的属性矩阵和标签列向量
x0_train = np.ones(num_train).reshape(-1,1)
X_train = tf.cast(tf.concat((x0_train,x_train),axis=1),tf.float32) # shape(78,3)
Y_train = tf.cast(y_train.reshape(-1,1),tf.float32) # shape(78,1)

x0_test = np.ones(num_test).reshape(-1,1)
X_test = tf.cast(tf.concat((x0_test,x_test),axis=1),dtype=tf.float32) # (22,3)
Y_test = tf.cast(y_test.reshape(-1,1),dtype=tf.float32) # (22,1)

# 可视化样本
#cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案
#plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
#plt.show()

# 3 设置超参数
learn_rate = 0.2 
iter = 120
display_step = 30

# 4 设置模型参数初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(3,1),dtype=tf.float32)

cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案

x_ = [-1.5,1.5]
y_ = -(W[0]+W[1]*x_)/W[2]



# 5 训练模型
ce_train = []
acc_train = []
ce_test = []
acc_test = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        PRED_train = 1/(1+tf.exp(-tf.matmul(X_train,W))) # 每个样本的预测概率
        Loss_train = -tf.reduce_mean(Y_train*tf.math.log(PRED_train)+(1-Y_train)*tf.math.log(1-PRED_train))
        PRED_test = 1/(1+tf.exp(-tf.matmul(X_test,W))) # 每个样本的预测概率
        Loss_test = -tf.reduce_mean(Y_test*tf.math.log(PRED_test)+(1-Y_test)*tf.math.log(1-PRED_test))

    accuracy_train = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED_train.numpy()<0.5,0.,1.),Y_train),tf.float32))
    accuracy_test = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED_test.numpy()<0.5,0.,1.),Y_test),tf.float32))

    ce_train.append(Loss_train)
    acc_train.append(accuracy_train)
    ce_test.append(Loss_test)
    acc_test.append(accuracy_test)

    dL_dW = tape.gradient(Loss_train,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step ==0:
        print("i: %i, TrainAcc: %f, TrainLoss: %f, TestAcc: %f, TestLoss: %f" % (i,accuracy_train,Loss_train,accuracy_test,Loss_test))

# 6 可视化
plt.figure(figsize=(10,3))

plt.subplot(121)
plt.plot(ce_train,c='b',label="train")
plt.plot(ce_test,c='r',label="test")
plt.ylabel("Loss")
plt.legend()

plt.subplot(122)
plt.plot(acc_train,c='b',label="train")
plt.plot(acc_test,c='r',label="test")
plt.ylabel("Accuracy")

plt.legend()
plt.show()

输出结果为：

i: 0, TrainAcc: 0.230769, TrainLoss: 0.994269, TestAcc: 0.272727, TestLoss: 0.939684
i: 30, TrainAcc: 0.961538, TrainLoss: 0.481892, TestAcc: 0.863636, TestLoss: 0.505456
i: 60, TrainAcc: 0.987179, TrainLoss: 0.319128, TestAcc: 0.863636, TestLoss: 0.362112
i: 90, TrainAcc: 0.987179, TrainLoss: 0.246626, TestAcc: 0.863636, TestLoss: 0.295611
i: 120, TrainAcc: 1.000000, TrainLoss: 0.204982, TestAcc: 0.863636, TestLoss: 0.256212

11.4.2 绘制分类图

11.4.2.1 生成网格坐标矩阵np.meshgrid()

X,Y = np.meshgrid(x,y)

11.4.2.2 填充网格 plt.pcolomesh()

11.4.2.2.1 rainbow色彩方案

plt.pcolomesh(X,Y,Z,cmap)

前两个参数：X和Y确定网格位置
第三个参数：Z决定网格的颜色
第四个参数：cmap指定所使用的颜色方案
可以使用plt.contourf()函数代替plt.pcolomesh()函数

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

n = 10
x = np.linspace(-10,10,n)
y = np.linspace(-10,10,n)
X,Y = np.meshgrid(x,y)
Z = X+Y
plt.pcolormesh(X,Y,Z,cmap="rainbow")

plt.show()

输出结果为：

11.4.2.2.2 自己定义的色彩方案

如果定义了两种颜色，就平均按照颜色值划分两类，如果是三种颜色，就划分为三个区域

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

n = 200
x = np.linspace(-10,10,n)
y = np.linspace(-10,10,n)
X,Y = np.meshgrid(x,y)
Z = X+Y
cm_bg = mpl.colors.ListedColormap(["#FFA0A0","#A0FFA0"])
plt.pcolormesh(X,Y,Z,cmap=cm_bg)

plt.show()

输出结果为：

11.4.2.3 绘制轮廓线plt.contour()

plt.contour()：根据类的取值绘制出相同取值的边界
可以理解为三维模型的等高线

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

n = 200
x = np.linspace(-10,10,n)
y = np.linspace(-10,10,n)
X,Y = np.meshgrid(x,y)
Z = X+Y

plt.contour(X,Y,Z,cmap="rainbow")

plt.show()

输出结果为：

修改为

Z = X**2+Y**2

11.4.2.3.1 给轮廓线之间填充颜色plt.contourf(X,Y,Z,a,cmap)

填充分区

plt.contourf(X,Y,Z,a,cmap)

前两个参数：X和Y确定网格位置
第三个参数：Z决定网格的颜色
第四个参数：a，指定颜色细分的数量
第五个参数：cmap指定所使用的颜色方案
可以使用plt.contourf()函数代替plt.pcolomesh()函数

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

n = 200
x = np.linspace(-10,10,n)
y = np.linspace(-10,10,n)
X,Y = np.meshgrid(x,y)
Z = X**2+Y**2

plt.contourf(X,Y,Z,cmap="rainbow")

plt.show()

输出结果为：

11.4.2.4 绘制分类图例子

# 1 加载数据
import tensorflow as tf
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

n = 200
x = np.linspace(-10,10,n)
y = np.linspace(-10,10,n)
X,Y = np.meshgrid(x,y)
Z = X+Y

cm_bg = mpl.colors.ListedColormap(["#FFA0A0","#A0FFA0"])
Z = tf.where(Z<5,0,1)
plt.contourf(X,Y,Z,cmap=cm_bg)

plt.show()

输出结果为：

11.4.2.5 根据鸢尾花分类模型，绘制训练集和测试集分类图

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"
train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)
test_path = tf.keras.utils.get_file(TEST_URL.split('/')[-1],TEST_URL)

df_iris_train = pd.read_csv(train_path,header=0) # 是一个pandas二维数据表
df_iris_test =  pd.read_csv(test_path,header=0)

# 2 处理数据
# 首先将二维数据表转化为numpy数组
iris_train= np.array(df_iris_train)  # shape(120,5)
iris_test= np.array(df_iris_test)  # shape(30,5)

# 提取属性和标签
train_x = iris_train[:,0:2]  # （120，2）
train_y = iris_train[:,4] # （120，）

test_x = iris_test[:,0:2]  # （30，2）
test_y = iris_test[:,4] # （30，）
# 提取山鸢尾和变色鸢尾，提取出标签纸为0和1的值
x_train = train_x[train_y < 2] # (78,2)
y_train = train_y[train_y < 2] # (78,)

x_test = test_x[test_y < 2] # (22,2)
y_test = test_y[test_y < 2] # (22,)
# 记录现在的样本数
num_train = len(x_train)
num_test = len(x_test)
# 分别进行按列中心化处理，要求训练集和测试集独立同分布的，具有相同的均值和方差，数量有限的情况下，只要尽量接近即可
# 使用划分好的不用太考虑，但是自己划分数据集，要考虑这点
x_train = x_train - np.mean(x_train,axis= 0)
x_test = x_test - np.mean(x_test,axis=0)

# 生成多元模型的属性矩阵和标签列向量
x0_train = np.ones(num_train).reshape(-1,1)
X_train = tf.cast(tf.concat((x0_train,x_train),axis=1),tf.float32) # shape(78,3)
Y_train = tf.cast(y_train.reshape(-1,1),tf.float32) # shape(78,1)

x0_test = np.ones(num_test).reshape(-1,1)
X_test = tf.cast(tf.concat((x0_test,x_test),axis=1),dtype=tf.float32) # (22,3)
Y_test = tf.cast(y_test.reshape(-1,1),dtype=tf.float32) # (22,1)

# 可视化样本
#cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案
#plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
#plt.show()

# 3 设置超参数
learn_rate = 0.2 
iter = 120
display_step = 30

# 4 设置模型参数初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(3,1),dtype=tf.float32)

cm_pt = mpl.colors.ListedColormap(["blue","red"]) # 设置色彩方案

x_ = [-1.5,1.5]
y_ = -(W[0]+W[1]*x_)/W[2]



# 5 训练模型
ce_train = []
acc_train = []
ce_test = []
acc_test = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        PRED_train = 1/(1+tf.exp(-tf.matmul(X_train,W))) # 每个样本的预测概率
        Loss_train = -tf.reduce_mean(Y_train*tf.math.log(PRED_train)+(1-Y_train)*tf.math.log(1-PRED_train))
        PRED_test = 1/(1+tf.exp(-tf.matmul(X_test,W))) # 每个样本的预测概率
        Loss_test = -tf.reduce_mean(Y_test*tf.math.log(PRED_test)+(1-Y_test)*tf.math.log(1-PRED_test))

    accuracy_train = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED_train.numpy()<0.5,0.,1.),Y_train),tf.float32))
    accuracy_test = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED_test.numpy()<0.5,0.,1.),Y_test),tf.float32))

    ce_train.append(Loss_train)
    acc_train.append(accuracy_train)
    ce_test.append(Loss_test)
    acc_test.append(accuracy_test)

    dL_dW = tape.gradient(Loss_train,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step ==0:
        print("i: %i, TrainAcc: %f, TrainLoss: %f, TestAcc: %f, TestLoss: %f" % (i,accuracy_train,Loss_train,accuracy_test,Loss_test))

# 6 可视化
# 根据鸢尾花分类模型，绘制分类图
# 定义绘制散点的颜色方案
cm_pt = mpl.colors.ListedColormap(["blue","red"])
# 定义背景颜色方案
cm_bg = mpl.colors.ListedColormap(["#FFA0A0","#A0FFA0"])
plt.rcParams['font.sans-serif']="SimHei"


plt.figure(figsize=(15,5))

# 绘制训练集
plt.subplot(121)
M = 300
x1_min,x2_min = x_train.min(axis=0)
x1_max,x2_max = x_train.max(axis=0)
t1 = np.linspace(x1_min,x1_max,M) # 使用花萼长度的取值范围作为横坐标取值范围
t2 = np.linspace(x2_min,x2_max,M) # 使用花萼宽度的取值范围作为纵坐标取值范围
m1,m2 = np.meshgrid(t1,t2) # 生成网格点坐标矩阵

m0 = np.ones(M*M)
# 生成多元线性模型需要的属性矩阵
X_mesh = tf.cast(np.stack((m0,m1.reshape(-1),m2.reshape(-1)),axis=1),dtype=tf.float32)
# 使用训练得到的W，根据sigmoid公式计算所有网格点对应的函数值
Y_mesh = tf.cast(1/(1+tf.exp(-tf.matmul(X_mesh,W))),dtype=tf.float32)
# 把分类结果转化为0，1，作为填充粉色，还是绿色的依据
Y_mesh = tf.where(Y_mesh<0.5,0,1)

# 并对其进行唯独变换，使其和m1，m2有相同的形状
n = tf.reshape(Y_mesh,m1.shape)

# 注意，TensorFlow中的绘图是有层次的，首先绘制分区图作为背景，然后在上面绘制散点图
# 绘制分区图
plt.pcolormesh(m1,m2,n,cmap=cm_bg)
# 绘制散点图
plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)
plt.title("训练集分类图",fontsize = 14)
plt.legend()

# 绘制测试集
plt.subplot(122)
M = 300
x1_min,x2_min = x_test.min(axis=0)
x1_max,x2_max = x_test.max(axis=0)
t1 = np.linspace(x1_min,x1_max,M) # 使用花萼长度的取值范围作为横坐标取值范围
t2 = np.linspace(x2_min,x2_max,M) # 使用花萼宽度的取值范围作为纵坐标取值范围
m1,m2 = np.meshgrid(t1,t2) # 生成网格点坐标矩阵

m0 = np.ones(M*M)
# 生成多元线性模型需要的属性矩阵
X_mesh = tf.cast(np.stack((m0,m1.reshape(-1),m2.reshape(-1)),axis=1),dtype=tf.float32)
# 使用训练得到的W，根据sigmoid公式计算所有网格点对应的函数值
Y_mesh = tf.cast(1/(1+tf.exp(-tf.matmul(X_mesh,W))),dtype=tf.float32)
# 把分类结果转化为0，1，作为填充粉色，还是绿色的依据
Y_mesh = tf.where(Y_mesh<0.5,0,1)

# 并对其进行唯独变换，使其和m1，m2有相同的形状
n = tf.reshape(Y_mesh,m1.shape)

# 注意，TensorFlow中的绘图是有层次的，首先绘制分区图作为背景，然后在上面绘制散点图
# 绘制分区图
plt.pcolormesh(m1,m2,n,cmap=cm_bg)
# 绘制散点图
plt.scatter(x_test[:,0],x_test[:,1],c=y_test,cmap=cm_pt)
plt.title("测试集分类图",fontsize = 14)
plt.legend()

plt.show()
x1_max,x2_max = x_train.max(axis=0)
t1 = np.linspace(x1_min,x1_max,M) # 使用花萼长度的取值范围作为横坐标取值范围
t2 = np.linspace(x2_min,x2_max,M) # 使用花萼宽度的取值范围作为纵坐标取值范围
m1,m2 = np.me![请添加图片描述](https://img-blog.csdnimg.cn/d10de77e0af24661b01b7c524b707407.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LiP56C05LiH6YeM5peg5LqR,size_20,color_FFFFFF,t_70,g_se,x_16)
shgrid(t1,t2) # 生成网格点坐标矩阵

m0 = np.ones(M*M)
# 生成多元线性模型需要的属性矩阵
X_mesh = tf.cast(np.stack((m0,m1.reshape(-1),m2.reshape(-1)),axis=1),dtype=tf.float32)
# 使用训练得到的W，根据sigmoid公式计算所有网格点对应的函数值
Y_mesh = tf.cast(1/(1+tf.exp(-tf.matmul(X_mesh,W))),dtype=tf.float32)
# 把分类结果转化为0，1，作为填充粉色，还是绿色的依据
Y_mesh = tf.where(Y_mesh<0.5,0,1)

# 并对其进行唯独变换，使其和m1，m2有相同的形状
n = tf.reshape(Y_mesh,m1.shape)

# 注意，TensorFlow中的绘图是有层次的，首先绘制分区图作为背景，然后在上面绘制散点图
# 绘制分区图
plt.pcolormesh(m1,m2,n,cmap=cm_bg)
# 绘制散点图
plt.scatter(x_train[:,0],x_train[:,1],c=y_train,cmap=cm_pt)


# 绘制测试集
plt.subplot(122)
M = 300
x1_min,x2_min = x_test.min(axis=0)
x1_max,x2_max = x_test.max(axis=0)
t1 = np.linspace(x1_min,x1_max,M) # 使用花萼长度的取值范围作为横坐标取值范围
t2 = np.linspace(x2_min,x2_max,M) # 使用花萼宽度的取值范围作为纵坐标取值范围
m1,m2 = np.meshgrid(t1,t2) # 生成网格点坐标矩阵

m0 = np.ones(M*M)
# 生成多元线性模型需要的属性矩阵
X_mesh = tf.cast(np.stack((m0,m1.reshape(-1),m2.reshape(-1)),axis=1),dtype=tf.float32)
# 使用训练得到的W，根据sigmoid公式计算所有网格点对应的函数值
Y_mesh = tf.cast(1/(1+tf.exp(-tf.matmul(X_mesh,W))),dtype=tf.float32)
# 把分类结果转化为0，1，作为填充粉色，还是绿色的依据
Y_mesh = tf.where(Y_mesh<0.5,0,1)

# 并对其进行唯独变换，使其和m1，m2有相同的形状
n = tf.reshape(Y_mesh,m1.shape)

# 注意，TensorFlow中的绘图是有层次的，首先绘制分区图作为背景，然后在上面绘制散点图
# 绘制分区图
plt.pcolormesh(m1,m2,n,cmap=cm_bg)
# 绘制散点图
plt.scatter(x_test[:,0],x_test[:,1],c=y_test,cmap=cm_pt)
plt.show()

输出结果为：

测试集上看着有两个分类错误，其实是三个，因为测试集里面有两个重合点

11.4.2.5 使用定义函数借鉴上一节代码

讨论【11.4】绘制测试集分类图
课程编程实例中，有很多代码是重复的，是否可以通过函数来实现代码复用？同学们尝试一下，并在讨论区分享关键代码，大家共同学习。

#加载数据
import tensorflow as tf
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import pandas as pd
from numpy.lib.function_base import disp

#数据准备
def preparedData(URL):
    path=tf.keras.utils.get_file(URL.split('/')[-1],URL)
    df_iris=pd.read_csv(path,header=0)
    iris=np.array(df_iris)
    _x=iris[:,0:2]
    _y=iris[:,4]
    x=_x[_y<2]
    y=_y[_y<2]
    num=len(x)
    X,Y,x=dataCentralize(x,y,num)
    return X,Y,x,y

#数据中心化
def dataCentralize(x,y,num):
    x=x-np.mean(x,axis=0)
    x0=np.ones(num).reshape(-1,1)
    X=tf.cast(tf.concat((x0,x),axis=1),tf.float32)
    Y=tf.cast(y.reshape(-1,1),tf.float32)
    return X,Y,x

#获取导数
def getDerivate(X,Y,W,ce,acc,flag):
    with tf.GradientTape() as tape:
        PRED=1/(1+tf.exp(-tf.matmul(X,W)))
        Loss=-tf.reduce_mean(Y*tf.math.log(PRED)+(1-Y)*tf.math.log(1-PRED))
        accuracy=tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED.numpy()<0.5,0.,1.),Y),tf.float32))
        ce.append(Loss)

        acc.append(accuracy)
        if  flag==1:
            dL_dW=tape.gradient(Loss,W)
            W.assign_sub(learn_rate*dL_dW)
    return ce,acc,W

#绘图
def mapping(x,y):
    M=300
    x1_min,x2_min=x.min(axis=0)
    x1_max,x2_max=x.max(axis=0)
    t1=np.linspace(x1_min,x1_max,M)
    t2=np.linspace(x2_min,x2_max,M)
    m1,m2=np.meshgrid(t1,t2)
    m0=np.ones(M*M)
    X_mesh=tf.cast(np.stack((m0,m1.reshape(-1),m2.reshape(-1)),axis=1),dtype=tf.float32)
    Y_mesh=tf.cast(1/(1+tf.exp(-tf.matmul(X_mesh,W))),dtype=tf.float32)
    Y_mesh=tf.where(Y_mesh<0.5,0,1)
    n=tf.reshape(Y_mesh,m1.shape)
    cm_pt=mpl.colors.ListedColormap(["blue","red"])
    cm_bg=mpl.colors.ListedColormap(["#FFA0A0","#A0FFA0"])
    plt.pcolormesh(m1,m2,n,cmap=cm_bg)
    plt.scatter(x[:,0],x[:,1],c=y,cmap=cm_pt)
    plt.show()

#数据加载
TRAIN_URL="https://download.tensorflow.org/data/iris_training.csv"
TEST_URL="https://download.tensorflow.org/data/iris_test.csv"
X_train,Y_train,x_train,y_train=preparedData(TRAIN_URL)
X_test,Y_test,x_test,y_test=preparedData(TEST_URL)

#设置超参
learn_rate=0.2
iter=120
display_step=30

#设置模型参数初始值
np.random.seed(612)
W=tf.Variable(np.random.randn(3,1),dtype=tf.float32)

#训练模型
ce_train=[]
acc_train=[]
ce_test=[]
acc_test=[]

for i in range(0,iter+1):
    acc_train,ce_train,W=getDerivate(X_train,Y_train,W,ce_train,acc_train,1)
    acc_test,ce_test,W=getDerivate(X_train,Y_train,W,ce_train,acc_train,1)
    if i % display_step==0:
        print("i:%i\tAcc:%f\tLoss:%f\tAcc_test:%f\tLoss_test:%f"%(i,acc_train[i],ce_train[i],acc_test[i],ce_test[i]))

#绘图#x_train,y_train,
mapping(x_test,y_test)

输出结果为：

i:0     Acc:0.994269    Loss:0.230769   Acc_test:0.230769       Loss_test:0.994269
i:30    Acc:0.961538    Loss:0.481892   Acc_test:0.481892       Loss_test:0.961538
i:60    Acc:0.319128    Loss:0.987179   Acc_test:0.987179       Loss_test:0.319128
i:90    Acc:0.987179    Loss:0.246626   Acc_test:0.246626       Loss_test:0.987179
i:120   Acc:0.204982    Loss:1.000000   Acc_test:1.000000       Loss_test:0.204982

11.4.2.6 使用四种属性区分变色鸢尾和维吉尼亚鸢尾

鸢尾花数据集中，有四个属性（花瓣长度、花瓣宽度、花萼长度、花萼宽度），课程中只是给出了两种属性组合的情况，如果采用三种或者四种属性去训练模型，能否把变色鸢尾和维吉尼亚鸢尾完全区分开呢？请简要说明一下你用的哪几种属性并在讨论区晒出你的程序结果。

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"
train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)
test_path = tf.keras.utils.get_file(TEST_URL.split('/')[-1],TEST_URL)

df_iris_train = pd.read_csv(train_path,header=0) # 是一个pandas二维数据表
df_iris_test =  pd.read_csv(test_path,header=0)

# 2 处理数据
# 首先将二维数据表转化为numpy数组
iris_train= np.array(df_iris_train)  # shape(120,5)
iris_test= np.array(df_iris_test)  # shape(30,5)

# 提取属性和标签
train_x = iris_train[:,0:4]  # （120，4）
train_y = iris_train[:,4] # （120，）

test_x = iris_test[:,0:4]  # （30，4）
test_y = iris_test[:,4] # （30，）
# 提取山鸢尾和变色鸢尾，提取出标签纸为0和1的值
x_train = train_x[train_y > 0] # (n,4)
y_train = train_y[train_y > 0]-1 # (n,)

x_test = test_x[test_y > 0] # (m,4)
y_test = test_y[test_y > 0]-1 # (m,)
# 记录现在的样本数
num_train = len(x_train)
num_test = len(x_test)
# 分别进行按列中心化处理，要求训练集和测试集独立同分布的，具有相同的均值和方差，数量有限的情况下，只要尽量接近即可
# 使用划分好的不用太考虑，但是自己划分数据集，要考虑这点

x_train = x_train - np.mean(x_train,axis= 0)
x_test = x_test - np.mean(x_test,axis=0)

# 生成多元模型的属性矩阵和标签列向量
x0_train = np.ones(num_train).reshape(-1,1)
X_train = tf.cast(tf.concat((x0_train,x_train),axis=1),tf.float32) # shape(n,5)
Y_train = tf.cast(y_train.reshape(-1,1),tf.float32) # shape(n,1)

x0_test = np.ones(num_test).reshape(-1,1)
X_test = tf.cast(tf.concat((x0_test,x_test),axis=1),dtype=tf.float32) # (m,5)
Y_test = tf.cast(y_test.reshape(-1,1),dtype=tf.float32) # (m,1)

# 3 设置超参数
learn_rate = 0.135
iter = 10000
display_step = 1000

# 4 设置模型参数初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(5,1),dtype=tf.float32)

# 5 训练模型
ce_train = []
acc_train = []
ce_test = []
acc_test = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        PRED_train = 1/(1+tf.exp(-tf.matmul(X_train,W))) # 每个样本的预测概率
        Loss_train = -tf.reduce_mean(Y_train*tf.math.log(PRED_train)+(1-Y_train)*tf.math.log(1-PRED_train))
        PRED_test = 1/(1+tf.exp(-tf.matmul(X_test,W))) # 每个样本的预测概率
        Loss_test = -tf.reduce_mean(Y_test*tf.math.log(PRED_test)+(1-Y_test)*tf.math.log(1-PRED_test))

    accuracy_train = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED_train.numpy()<0.5,0.,1.),Y_train),tf.float32))
    accuracy_test = tf.reduce_mean(tf.cast(tf.equal(tf.where(PRED_test.numpy()<0.5,0.,1.),Y_test),tf.float32))

    ce_train.append(Loss_train)
    acc_train.append(accuracy_train)
    ce_test.append(Loss_test)
    acc_test.append(accuracy_test)

    dL_dW = tape.gradient(Loss_train,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step ==0:
        print("i: %i, TrainAcc: %f, TrainLoss: %f, TestAcc: %f, TestLoss: %f" % (i,accuracy_train,Loss_train,accuracy_test,Loss_test))

#可视化：绘制损失和准确率变化曲线
plt.figure(figsize=(10,3))
plt.subplot(121)
plt.plot(ce_train,color="blue",label="train")
plt.plot(ce_test,color="red",label="test")
plt.ylabel("Loss")
plt.legend()

plt.subplot(122)
plt.plot(acc_train,color="blue",label="train")
plt.plot(acc_test,color="red",label="test")
plt.ylabel("Accuracy")
plt.legend()

plt.show()

输出结果为：

i: 0, TrainAcc: 0.871795, TrainLoss: 0.502093, TestAcc: 0.909091, TestLoss: 0.491409
i: 1000, TrainAcc: 0.974359, TrainLoss: 0.117291, TestAcc: 0.954545, TestLoss: 0.189897
i: 2000, TrainAcc: 0.974359, TrainLoss: 0.096742, TestAcc: 0.954545, TestLoss: 0.166818
i: 3000, TrainAcc: 0.974359, TrainLoss: 0.087580, TestAcc: 0.954545, TestLoss: 0.155260
i: 4000, TrainAcc: 0.974359, TrainLoss: 0.082096, TestAcc: 0.954545, TestLoss: 0.148034
i: 5000, TrainAcc: 0.974359, TrainLoss: 0.078296, TestAcc: 0.954545, TestLoss: 0.142953
i: 6000, TrainAcc: 0.974359, TrainLoss: 0.075425, TestAcc: 0.954545, TestLoss: 0.139118
i: 7000, TrainAcc: 0.974359, TrainLoss: 0.073129, TestAcc: 0.954545, TestLoss: 0.136092
i: 8000, TrainAcc: 0.974359, TrainLoss: 0.071221, TestAcc: 0.954545, TestLoss: 0.133636
i: 9000, TrainAcc: 0.987179, TrainLoss: 0.069592, TestAcc: 0.954545, TestLoss: 0.131605
i: 10000, TrainAcc: 0.987179, TrainLoss: 0.068172, TestAcc: 0.954545, TestLoss: 0.129906

11.5 多分类问题

逻辑回归：二分类问题
多分类问题：把输入样本划分为多个类别
下面以鸢尾花为例，实现多分类类别

11.5.1 类别编码问题

自然顺序码
0 —— 山鸢尾（Setosa）
1 —— 变色鸢尾（Versicolour）
2 —— 维吉尼亚鸢尾（Virginica）
欧氏距离使得类别之间不平等，但是实际上类别之间应该是平等的
独热编码（One-Hot Encoding）
使非偏序关系的数据，取值不具有偏序性
到原点等距
（1，0，0） —— 山鸢尾（Setosa）
（0，1，0） —— 变色鸢尾（Versicolour）
（0，0，1） —— 维吉尼亚鸢尾（Virginica）
需要占用更多的空间，但是能够更加合理的表示数据之间的关系，可以有效的避免学习中的偏差
独热的应用
离散的特征
多分类问题中的类别标签
独冷编码（One-Hot Encoding）
（0，1，1） —— 山鸢尾（Setosa）
（1，0，1） —— 变色鸢尾（Versicolour）
（1，1，0） —— 维吉尼亚鸢尾（Virginica）

11.5.2 实例，多分类问题

例：使用属性花瓣长度和花瓣宽度，构造分类器，能够识别3种类型的鸢尾花
互斥的多分类问题：每个样本只能够属于一个类别
鸢尾花的识别
手写数字的识别
标签：一个图片可以被打上多个标签，即一个样本可以同时属于多个类别
彩色图片
包括人物的图片
包括汽车的图片
户外图片
室内图片

11.6 实例：多分类问题

11.6.1 独热编码的实现

tf.one_hot(indices,depth)

indices：一维数组/张量
depth：编码深度，也就是分成几类

>>> import tensorflow as tf
>>> print(tf.__version__)   
2.0.0
>>> import numpy as np
>>> a = [0,2,3,5]
>>> b = tf.one_hot(a,6)
>>> b
<tf.Tensor: id=9, shape=(4, 6), dtype=float32, numpy=
array([[1., 0., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 0., 1.]], dtype=float32)>

11.6.2 准确率的计算

# 预测值
>>> pred = np.array([[0.1,0.2,0.7],[0.1,0.7,0.2],[0.3,0.4,0.3]]) 
# 标记
>>> y = np.array([2,1,0]) 
# 标记独热编码
>>> y_onehot = np.array([[0,0,1],[0,1,0],[1,0,0]]) 
# 预测值中的最大数索引
>>> tf.argmax(pred,axis=1) 
<tf.Tensor: id=12, shape=(3,), dtype=int64, numpy=array([2, 1, 1], dtype=int64)>
# 判读预测值是否与样本标记相同
>>> tf.equal(tf.argmax(pred,axis=1),y) 
<tf.Tensor: id=17, shape=(3,), dtype=bool, numpy=array([ True,  True, False])>
# 将布尔值转化为数字
>>> tf.cast(tf.equal(tf.argmax(pred,axis=1),y),tf.float32) 
<tf.Tensor: id=23, shape=(3,), dtype=float32, numpy=array([1., 1., 0.], dtype=float32)>
# 计算准确率
>>> tf.reduce_mean(tf.cast(tf.equal(tf.argmax(pred,axis=1),y),tf.float32))
<tf.Tensor: id=39, shape=(), dtype=float32, numpy=0.6666667>

11.6.3 交叉熵损失函数的实现

代码接11.6.2

>>> -y_onehot*tf.math.log(pred) 
<tf.Tensor: id=43, shape=(3, 3), dtype=float64, numpy=
array([[-0.        , -0.        ,  0.35667494],       
       [-0.        ,  0.35667494, -0.        ],       
       [ 1.2039728 , -0.        , -0.        ]])>     
# 所有样本交叉熵之和
>>> -tf.reduce_sum(y_onehot*tf.math.log(pred)) 
<tf.Tensor: id=50, shape=(), dtype=float64, numpy=1.917322692203401>
# 平均交叉熵损失
>>> -tf.reduce_sum(y_onehot*tf.math.log(pred))/len(pred) 
<tf.Tensor: id=59, shape=(), dtype=float64, numpy=0.6391075640678003>
>>> len(pred) 
3

11.6.4 使用花瓣长度、花瓣宽度将三种鸢尾花区分开

11.6.4.0 修改动态分配显存

https://blog.csdn.net/qq_45954434/article/details/121236512
这里不修改显存分配我的就会报错，所以这里会默认修改动态显存分配

11.6.4.1 加载数据

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
# 修改配置-动态分配显存
gpus = tf.config.experimental.list_physical_devices(device_type='GPU')
tf.config.experimental.set_memory_growth(gpus[0], True)

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"

train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)
test_path = tf.keras.utils.get_file(TEST_URL.split('/')[-1],TEST_URL)

df_iris_train = pd.read_csv(train_path, header=0)

11.6.4.2 处理数据

# 2 处理数据
iris_train = np.array(df_iris_train)
# (120,5)

#提取花瓣长度、花瓣宽度属性 
x_train = iris_train[:,2:4]
# (120,2)
y_train = iris_train[:,4]
# (120,)

num_train = len(x_train)

x0_train = np.ones(num_train).reshape(-1,1)
X_train = tf.cast(tf.concat([x0_train,x_train],axis=1),tf.float32)
# ([120,3])
Y_train = tf.one_hot(tf.constant(y_train,dtype=tf.int32),3)
# ([120,3])

11.6.4.3 设置超参数、设置模型参数初始值

# 3 设置超参数、设置模型参数初始值
learn_rate = 0.2
iter = 500
display_step = 100

np.random.seed(612)
W = tf.Variable(np.random.randn(3,3),dtype=tf.float32)

11.6.4.4 训练模型

# 4 训练模型
acc = []
cce = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        # (120,3) 属于每种类别的概率，每个样本三种类别概率之和为1
        PRED_train = tf.nn.softmax(tf.matmul(X_train,W))
        Loss_train = -tf.reduce_sum(Y_train*tf.math.log(PRED_train))/num_train

    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(PRED_train.numpy(),axis=1),y_train),tf.float32))

    acc.append(accuracy)
    cce.append(Loss_train)

    dL_dW = tape.gradient(Loss_train,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step == 0:
        print("i: %i, Acc: %f, Loss: %f"%(i,accuracy,Loss_train))

输出结果为：

i: 0, Acc: 0.350000, Loss: 4.510763
i: 100, Acc: 0.808333, Loss: 0.503537
i: 200, Acc: 0.883333, Loss: 0.402912
i: 300, Acc: 0.891667, Loss: 0.352650
i: 400, Acc: 0.941667, Loss: 0.319778
i: 500, Acc: 0.941667, Loss: 0.295599

11.6.4.5 查看训练结果

# 5 查看训练结果
# 输出自然顺序码
print("自然顺序码为：" )
print(tf.argmax(PRED_train.numpy(),axis=1))
``
输出结果为：

```python
自然顺序码为：
tf.Tensor(
[2 1 2 0 0 0 0 2 1 0 1 1 0 0 2 2 2 2 2 0 2 2 0 1 1 0 1 2 1 2 1 1 1 2 2 2 2
 2 0 0 2 2 2 0 0 1 0 2 0 2 0 1 1 0 1 2 2 2 2 1 1 2 2 2 1 2 0 2 2 0 0 1 0 2
 2 0 1 1 1 2 0 1 1 1 2 0 1 1 2 0 2 1 0 0 2 0 0 2 2 0 0 1 0 1 0 0 0 0 1 0 2
 1 0 2 0 1 1 0 0 1], shape=(120,), dtype=int64)

11.6.4.6 绘制分类图


# 6 绘制分类图
M = 500
x1_min,x2_min = x_train.min(axis=0)
x1_max,x2_max = x_train.max(axis=0)
t1 = np.linspace(x1_min,x1_max,M)
t2 = np.linspace(x2_min,x2_max,M)
m1,m2 = np.meshgrid(t1,t2)

m0 = np.ones(M*M)
X_ = tf.cast(np.stack((m0,m1.reshape(-1),m2.reshape(-1)),axis=1),tf.float32)
Y_ = tf.nn.softmax(tf.matmul(X_,W))

Y_ = tf.argmax(Y_.numpy(),axis=1)# 转换为自然顺序码

n = tf.reshape(Y_,m1.shape)# (500,500)

plt.figure(figsize = (8,6))
cm_bg =  mpl.colors.ListedColormap(['#A0FFA0','#FFA0A0','#A0A0FF'])

plt.pcolormesh(m1,m2,n,cmap=cm_bg)
plt.scatter(x_train[:,0],x_train[:,1],c = y_train,cmap="brg")

plt.show()

输出结果为：

11.6.4.7 本例代码汇总

# 1 加载数据
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

gpus = tf.config.experimental.list_physical_devices(device_type='GPU')
tf.config.experimental.set_memory_growth(gpus[0], True)

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"

train_path = tf.keras.utils.get_file(TRAIN_URL.split('/')[-1],TRAIN_URL)
test_path = tf.keras.utils.get_file(TEST_URL.split('/')[-1],TEST_URL)

df_iris_train = pd.read_csv(train_path, header=0)

# 2 处理数据
iris_train = np.array(df_iris_train)
# (120,5)

#提取花瓣长度、花瓣宽度属性 
x_train = iris_train[:,2:4]
# (120,2)
y_train = iris_train[:,4]
# (120,)

num_train = len(x_train)

x0_train = np.ones(num_train).reshape(-1,1)
X_train = tf.cast(tf.concat([x0_train,x_train],axis=1),tf.float32)
# ([120,3])
Y_train = tf.one_hot(tf.constant(y_train,dtype=tf.int32),3)
# ([120,3])

# 3 设置超参数、设置模型参数初始值
learn_rate = 0.2
iter = 500
display_step = 100

np.random.seed(612)
W = tf.Variable(np.random.randn(3,3),dtype=tf.float32)

# 4 训练模型
acc = []
cce = []

for i in range(0,iter+1):
    with tf.GradientTape() as tape:
        
        PRED_train = tf.nn.softmax(tf.matmul(X_train,W))
        # (120,3) 属于每种类别的概率，每个样本三种类别概率之和为1
        Loss_train = -tf.reduce_sum(Y_train*tf.math.log(PRED_train))/num_train

    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(PRED_train.numpy(),axis=1),y_train),tf.float32))

    acc.append(accuracy)
    cce.append(Loss_train)

    dL_dW = tape.gradient(Loss_train,W)
    W.assign_sub(learn_rate*dL_dW)

    if i % display_step == 0:
        print("i: %i, Acc: %f, Loss: %f"%(i,accuracy,Loss_train))

# 5 查看训练结果
# 输出自然顺序码
print("自然顺序码为：" )
print(tf.argmax(PRED_train.numpy(),axis=1))

# 6 绘制分类图
M = 500
x1_min,x2_min = x_train.min(axis=0)
x1_max,x2_max = x_train.max(axis=0)
t1 = np.linspace(x1_min,x1_max,M)
t2 = np.linspace(x2_min,x2_max,M)
m1,m2 = np.meshgrid(t1,t2)

m0 = np.ones(M*M)
X_ = tf.cast(np.stack((m0,m1.reshape(-1),m2.reshape(-1)),axis=1),tf.float32)
Y_ = tf.nn.softmax(tf.matmul(X_,W))

Y_ = tf.argmax(Y_.numpy(),axis=1)# 转换为自然顺序码

n = tf.reshape(Y_,m1.shape)# (500,500)

plt.figure(figsize = (8,6))
cm_bg =  mpl.colors.ListedColormap(['#A0FFA0','#FFA0A0','#A0A0FF'])

plt.pcolormesh(m1,m2,n,cmap=cm_bg)
plt.scatter(x_train[:,0],x_train[:,1],c = y_train,cmap="brg")

plt.show()

11.7 参考文献

[1] 神经网络与深度学习——TensorFlow实践

你可能感兴趣的:(深度学习,深度学习,tensorflow,神经网络)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！小猪包333 写论文人工智能 AI写作深度学习计算机视觉
在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
[实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估 pytorch python 机器学习
文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
[实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用 pytorch 深度学习人工智能机器学习 python 优化器
文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
吴恩达深度学习笔记(30)-正则化的解释极客Array
正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
个人学习笔记7-6：动手学深度学习pytorch版-李沐浪子L 深度学习深度学习笔记计算机视觉 python 人工智能神经网络 pytorch
#人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
深度学习-点击率预估-研究论文2024-09-14速读 sp_fyf_2024 深度学习人工智能
深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
计算机视觉中，Pooling的作用 Wils0nEdwards 计算机视觉人工智能
在计算机视觉中，Pooling（池化）是一种常见的操作，主要用于卷积神经网络（CNN）中。它通过对特征图进行下采样，减少数据的空间维度，同时保留重要的特征信息。Pooling的作用可以归纳为以下几个方面：1.降低计算复杂度与内存需求Pooling操作通过对特征图进行下采样，减少了特征图的空间分辨率（例如，高度和宽度）。这意味着网络需要处理的数据量会减少，从而降低了计算量和内存需求。这对大型神经网络
神经网络-损失函数红米煮粥神经网络人工智能深度学习
文章目录一、回归问题的损失函数1.均方误差（MeanSquaredError,MSE）2.平均绝对误差（MeanAbsoluteError,MAE）二、分类问题的损失函数1.0-1损失函数（Zero-OneLossFunction）2.交叉熵损失（Cross-EntropyLoss）3.合页损失（HingeLoss）三、总结在神经网络中，损失函数（LossFunction）扮演着至关重要的角色，它
损失函数与反向传播 Star_. PyTorch pytorch 深度学习 python
损失函数定义与作用损失函数(lossfunction)在深度学习领域是用来计算搭建模型预测的输出值和真实值之间的误差。1.损失函数越小越好2.计算实际输出与目标之间的差距3.为更新输出提供依据（反向传播)常见的损失函数回归常见的损失函数有：均方差（MeanSquaredError，MSE）、平均绝对误差（MeanAbsoluteErrorLoss，MAE）、HuberLoss是一种将MSE与MAE
BP神经网络的传递函数大胜归来19 MATLAB
BP网络一般都是用三层的，四层及以上的都比较少用；传输函数的选择，这个怎么说，假设你想预测的结果是几个固定值，如1,0等，满足某个条件输出1，不满足则0的话，首先想到的是hardlim函数，阈值型的，当然也可以考虑其他的；然后，假如网络是用来表达某种线性关系时，用purelin---线性传输函数；若是非线性关系的话，用别的非线性传递函数，多层网络时，每层不一定要用相同的传递函数，可以是三种配合，可
神经网络传递函数sigmoid,神经网络传递函数作用快乐的小荣荣神经网络机器学习深度学习人工智能
神经网络传递函数选取不同会有特别大差别嘛？只是最后一层，但前面层是非线性，那么可能存在区别不大的情况。线性函数f(a*input)=af(input),一般来说，input为向量，最简化情况下，可以假设input的各个维度，a1=a2=a3。。。意味着你线性层只是简单的对输入做了scale~而神经网络能起作用的原因，在于通过足够复杂的非线性函数，来模拟任何的分布。所以，神经网络必须要用非线性函数。
Python和R均方根误差平均绝对误差算法模型亚图跨际 Python 交叉知识 R 回归模型误差指标归一化均方根误差生态状态指标神经网络成本误差气体排放气候模型多项式拟合
要点回归模型误差评估指标归一化均方根误差生态状态指标神经网络成本误差计算气体排放气候算法模型Python误差指标均方根误差和平均绝对误差均方根偏差或均方根误差是两个密切相关且经常使用的度量值之一，用于衡量真实值或预测值与观测值或估计值之间的差异。估计器θ^\hat{\theta}θ^相对于估计参数θ\thetaθ的RMSD定义为均方误差的平方根：RMSD⁡(θ^)=MSE⁡(θ^)=E((θ^−θ
【深度学习】训练过程中一个OOM的问题，太难查了 weixin_40293999 深度学习深度学习人工智能
现象：各位大佬又遇到过ubuntu的这个问题么？现象是在训练过程中，ssh上不去了，能ping通，没死机，但是ubunutu的pc侧的显示器，鼠标啥都不好用了。只能重启。问题原因：OOM了95G，尼玛！！！！pytorch爆内存了，然后journald假死了，在journald被watchdog干掉之后，系统就崩溃了。这种规模的爆内存一般，即使被oomkill了，也要卡半天的，确实会这样，能不能配
云服务业界动态简报-20180128 Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
机器学习VS深度学习 nfgo 机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
大数据毕业设计hadoop+spark+hive知识图谱租房数据分析可视化大屏租房推荐系统 58同城租房爬虫房源推荐系统房价预测系统计算机毕业设计机器学习深度学习人工智能 2401_84572577 程序员大数据 hadoop 人工智能
做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。我先来介绍一下这些东西怎么用，文末抱走。（1）Python所有方向的学习路线（
深度学习-13-小语言模型之SmolLM的使用皮皮冰燃深度学习深度学习
文章附录1SmolLM概述1.1SmolLM简介1.2下载模型2运行2.1在CPU/GPU/多GPU上运行模型2.2使用torch.bfloat162.3通过位和字节的量化版本3应用示例4问题及解决4.1attention_mask和pad_token_id报错4.2max_new_tokens=205参考附录1SmolLM概述1.1SmolLM简介SmolLM是一系列尖端小型语言模型，提供三种规
【NLP5-RNN模型、LSTM模型和GRU模型】一蓑烟雨紫洛 nlp rnn lstm gru nlp
RNN模型、LSTM模型和GRU模型1、什么是RNN模型RNN（RecurrentNeuralNetwork)中文称为循环神经网络，它一般以序列数据为输入，通过网络内部的结构设计有效捕捉序列之间的关系特征，一般也是以序列形式进行输出RNN的循环机制使模型隐层上一时间步产生的结果，能够作为当下时间步输入的一部分（当下时间步的输入除了正常的输入外还包括上一步的隐层输出）对当下时间步的输出产生影响2、R
基于深度学习的农作物病害检测 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的农作物病害检测利用卷积神经网络（CNN）、生成对抗网络（GAN）、Transformer等深度学习技术，自动识别和分类农作物的病害，帮助农业工作者提高作物管理效率、减少损失。1.农作物病害检测的挑战病害种类繁多：农作物病害的类型多样，不同病害在同一作物上的表现差异很大，同时同一种病害在不同生长阶段的症状也可能不同。环境影响：天气、光照、湿度等外部环境因素会影响农作物的表现，使得病害检
基于深度学习的文本引导的图像编辑 SEU-WYL 深度学习dnn 深度学习人工智能
基于深度学习的文本引导的图像编辑（Text-GuidedImageEditing）是一种通过自然语言文本指令对图像进行编辑或修改的技术。它结合了图像生成和自然语言处理（NLP）的最新进展，使用户能够通过描述性文本对图像内容进行精确的调整和操控。1.文本引导的图像编辑的挑战文本和图像之间的对齐：如何将文本中的语义信息准确地映射到图像中的特定区域或元素是一个关键挑战。这涉及到多模态数据的对齐和理解。编
深度学习--对抗生成网络（GAN, Generative Adversarial Network） Ambition_LAO 深度学习生成对抗网络
对抗生成网络（GAN,GenerativeAdversarialNetwork）是一种深度学习模型，由IanGoodfellow等人在2014年提出。GAN主要用于生成数据，通过两个神经网络相互对抗，来生成以假乱真的新数据。以下是对GAN的详细阐述，包括其概念、作用、核心要点、实现过程、代码实现和适用场景。1.概念GAN由两个神经网络组成：生成器（Generator）和判别器（Discrimina
深度学习：怎么看pth文件的参数奥利给少年深度学习人工智能
.pth文件是PyTorch模型的权重文件，它通常包含了训练好的模型的参数。要查看或使用这个文件，你可以按照以下步骤操作：1.确保你有模型的定义你需要有创建这个.pth文件时所用的模型的代码。这意味着你需要有模型的类定义和架构。2.加载模型权重使用PyTorch的load_state_dict方法来加载权重。这里是如何操作的：importtorchimporttorch.nnasnn#定义模型结构
chatgpt赋能python：如何在Python中安装Keras库？ turensu ChatGpt python chatgpt keras 计算机
如何在Python中安装Keras库？Keras是一个简单易用的神经网络库，由FrançoisChollet编写。它在Python编程语言中实现了深度学习的功能，可以使您更轻松地构建和试验不同类型的神经网络。如果您是一名Python开发人员，肯定会想知道如何在您的Python项目中安装Keras库。在本文中，我们将向您展示如何安装和配置Keras库。步骤1：安装Python要使用Keras库，您需
如何理解深度学习的训练过程奋斗的草莓熊深度学习人工智能 python scikit-learn virtualenv numpy pandas
文章目录1.训练是干什么？2.预训练模型进行训练，主要更改的是预训练模型的什么东西？1.训练是干什么？以yolov5为例子，训练的目的是把一组输入猫狗图像放到神经网络中，得到一个输出模型，这个模型下次可以直接用来识别哪个是猫，哪个是狗2.预训练模型进行训练，主要更改的是预训练模型的什么东西？超参数（Hyperparameters）：这是模型结构中定义的参数，比如：卷积核大小（kernel_size
mysql主从数据同步林鹤霄 mysql主从数据同步
配置mysql5.5主从服务器(转) 教程开始：一、安装MySQL 说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22 二、配置MySQL主服务器（192.168.21.169）mysql -uroot -p &nb
oracle学习笔记 caoyong oracle
1、ORACLE的安装 a>、ORACLE的版本 8i,9i : i是internet 10g,11g : grid (网格) 12c : cloud (云计算) b>、10g不支持win7 &
数据库，SQL零基础入门天子之骄 sql 数据库入门基本术语
数据库，SQL零基础入门做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
pom.xml 一炮送你回车库 pom.xml
1、一级元素dependencies是可以被子项目继承的 2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 3、父项目里的一级元素<modules> <module>lcas-admin-war</module> <
sql查地区省市县 3213213333332132 sql mysql
-- db_yhm_city SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35 SELECT * FROM db_yhm_city WHERE class_parent_id =169 SELECT d1.cla
关于监听器那些让人头疼的事宝剑锋梅花香画图板监听器鼠标监听器
本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。
JAVA的遍历MAP darkranger map
Java Map遍历方式的选择 1. 阐述　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？　　为了解遍历性能的真实差距，包括在遍历ke
POJ 2312 Battle City 优先多列+bfs aijuans 搜索
来源：http://poj.org/problem?id=2312 题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
Hibernate与Jpa的关系，终于弄懂 avords java Hibernate 数据库 jpa
我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
酸爽的console.log bee1314 console
在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 /** * log.js hufeng * The safe wrapper for `console.xxx` functions *
哈佛教授：穷人和过于忙碌的人有一个共同思维特质 bijian1013 时间管理励志人生穷人过于忙碌
一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
other operate 征客丶 OS osx
一、Mac Finder 设置排序方式，预览栏在显示－》查看显示选项中二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出，我好及时改正，同时也让我们一
【Scala五】分析Spark源代码总结的Scala语法三 bit1129 scala
1. If语句作为表达式 val properties = if (jobIdToActiveJob.contains(jobId)) { jobIdToActiveJob(stage.jobId).properties } else { // this stage will be assigned to "default" po
ZooKeeper 入门 BlueSkator 中间件 zk
ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
MySQL取得当前时间的函数是什么格式化日期的函数是什么 BreakingBad mysql Date
取得当前时间用 now() 就行。在数据库中格式化时间用DATE_FORMA T(date, format) . 根据格式串format 格式化日期或日期和时间值date，返回结果串。可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值: %S, %s 两位数字形式的秒（ 00,01,
读《研磨设计模式》-代码笔记-组合模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
4_JAVA+Oracle面试题(有答案) chenke oracle
基础测试题卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。选择题 1、 What will happen when you attempt to compile and run the following code? （3） public class Static { static { int x = 5; // 在static内有效 } st
新一代工作流系统设计目标 comsci 工作算法脚本
用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。在这个设计中，最难的地方是系统根据什么来生成流
oracle 行链接与行迁移 daizj oracle 行迁移
表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 第一种情况: INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
[JShop]开源电子商务系统jshop的系统缓存实现 dinguangx jshop 电子商务
前言 jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
初三全学年难记忆单词 dcj3sjt126com english word
several 儿子；若干 shelf 架子 knowledge 知识；学问 librarian 图书管理员 abroad 到国外，在国外 surf 冲浪 wave 浪；波浪 twice 两次；两倍 describe 描写；叙述 especially 特别；尤其 attract 吸引 prize 奖品；奖赏 competition 比赛；竞争 event 大事；事件 O
sphinx实践 dcj3sjt126com sphinx
安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server yum install sphinx 如果失败的话使用下面的方式安装 wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm yum loca
JPA之JPQL（三） frank1234 orm jpa JPQL
1 什么是JPQL JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 2 检索单个对象 @Test public void querySingleObject1() { Query query = em.createQuery("sele
Remove Duplicates from Sorted Array II hcx2013 remove
Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? For example,Given sorted array nums = [1,1,1,2,2,3], Your function should return length
Spring4新特性——Groovy Bean定义DSL jinnianshilongnian spring 4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
CentOS安装Mysql5.5 liuxingguome centos
CentOS下以RPM方式安装MySQL5.5 首先卸载系统自带Mysql： yum remove mysql mysql-server mysql-libs compat-mysql51 rm -rf /var/lib/mysql rm /etc/my.cnf 查看是否还有mysql软件： rpm -qa|grep mysql 去http://dev.mysql.c
第14章工具函数（下） onestopweb 函数
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
POJ 1050 SaraWon 二维数组子矩阵最大和
POJ ACM第1050题的详细描述，请参照 http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 题目意思：给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。如二维数组 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 中和最大的子矩阵是 9 2 -4 1 -1 8 且最大和是15
Java8全新打造，英语学习supertool yangshangchuan java superword 闭包 java8 函数式编程
superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要