日月光华深度学习（一、二）深度学习基础和tf.keras
[2.2]–tf.keras实现线性回归
import tensorflow as tf
print('Tensorflow Version: {}'.format(tf.__version__))
import pandas as pd
data = pd.read_csv(open('C:/Users/dingy/Desktop/JLU/2数据相关学习/日月光华深度学习/日月光华-tensorflow资料1/数据集/Income1.csv'))#pd.read_csv的时候如果文章路径里有中文需要加一个open()。
import matplotlib.pyplot as plt
%matplotlib inline
plt.scatter(data.Education, data.Income)
x = data.Education
y = data.Income
model = tf.keras.Sequential()#顺序模型。
model.add(tf.keras.layers.Dense(1, input_shape=(1,)))#Dense层建立f(x)=ax+b.后面的(()是输出数据维度，input shape是输入数据形状写成元组的形式。)
此时
编译，用梯度下降算法进行计算。
model.compile(optimizer='adam',#优化方法为'adam'。
loss='mse'#损失函数是均方差。
)
history = model.fit(x, y, epochs=5000)#对所有数据的训练次数。
model.predict(x)#预测现有值。
model.predict(pd.Series([20]))
Pandas模块的数据结构主要有两：1、Series ；2、DataFrame
series是一个一维数组，是基于NumPy的ndarray结构。Pandas会默认用0到n-1来作为series的index，但也可以自己指定index(可以把index理解为dict里面的key。
[2.5]–多层感知器（神经网络）的代码实现
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
data = pd.read_csv('dataset/Advertising.csv')
data.head()
plt.scatter(data.TV, data.sales)
plt.scatter(data.radio, data.sales)
plt.scatter(data.newspaper, data.sales)
x = data.iloc[:, 1:-1]#所有行，除去第一列和最后一列。
y = data.iloc[:, -1]#只取最后一列。
model = tf.keras.Sequential([tf.keras.layers.Dense(10, input_shape=(3,), activation='relu'),#直接把层定义在里面，不用写add了。中间层有十个单元，然后用元组把输入数据的形状告诉Dense层，是一个三维数据。activation进行激活，有'relu' 'sigmoid'等。
tf.keras.layers.Dense(1)]#输出层只有一个单元。
)
变成两层的了，中间层为什么是40个参数？因为 对于每一个中间的隐藏单元，需要三个对应的权重以及一个偏置，即4*10=40.输出层为什么11个参数？因为 10+1 = 11。因此共计51个参数。
model.compile(optimizer='adam',
loss='mse'
)
model.fit(x, y, epochs=100)
test = data.iloc[:10, 1:-1]#iloc进行切片。
model.predict(test)
test = data.iloc[:10, -1]
[2.6]–逻辑回归与交叉熵
不能用均方差的方式刻画损失，比如1-0.3的平方刻画损失会非常小，因此迭代次数多，训练慢。
[2.7]–逻辑回归实现
data = pd.read_csv(open('C:/Users/dingy/Desktop/JLU/2数据相关学习/日月光华深度学习/日月光华-tensorflow资料1/数据集/credit-a.csv'), header=None)#没有表头，添加默认表头。
data.iloc[:, -1].value_counts()#看看末位为0和1的数据各有多少个。
x = data.iloc[:, :-1]
y = data.iloc[:, -1].replace(-1, 0)#正面数据为1，负面数据变成0。1/-1适合支持向量机的算法。
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(10, input_shape=(15,), activation='relu'))
model.add(tf.keras.layers.Dense(100, activation='relu'))#添加两个隐藏层，而且不需要写input shape ，因为他会自己推断。
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))#逻辑回归用'sigmod'进行激活，最后输出一个概率值。
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['acc']#衡量指标是准确率，是一个列表。
)
history = model.fit(x, y, epochs=100)
history.history.keys()
plt.plot(history.epoch, history.history.get('loss'))
plt.plot(history.epoch, history.history.get('acc'))
[2.8]–softmax多分类（一）
[2.9]–softmax多分类代码实现-fashion mnist数据分类实
[2.10]–独热编码与交叉熵损失函数
(train_image, train_label), (test_image, test_label) = tf.keras.datasets.fashion_mnist.load_data()
train_image.shape
(60000, 28, 28)
train_label.shape
(60000,)
test_image.shape, test_label.shape
test_image.shape, test_label.shape
((10000, 28, 28), (10000,))
train_image[1]
array([[ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 41, 188, 103,
54, 48, 43, 87, 168, 133, 16, 0, 0, 0, 0, 0, 0,
0, 0],
[ 0, 0, 0, 1, 0, 0, 0, 49, 136, 219, 216, 228, 236,
255, 255, 255, 255, 217, 215, 254, 231, 160, 45, 0, 0, 0,
0, 0],
[ 0, 0, 0, 0, 0, 14, 176, 222, 224, 212, 203, 198, 196,
200, 215, 204, 202, 201, 201, 201, 209, 218, 224, 164, 0, 0,
0, 0],
[ 0, 0, 0, 0, 0, 188, 219, 200, 198, 202, 198, 199, 199,
201, 196, 198, 198, 200, 200, 200, 200, 201, 200, 225, 41, 0,
0, 0],……
np.max(train_image[1])
255
train_label
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)
train_image = train_image/255
test_image = test_image/255
train_image.shape
(60000, 28, 28)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28))) # 展开成28*28
model.add(tf.keras.layers.Dense(256, activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))#多分类问题输出十个概率值，用softmax进行激活是关键。把十个输出变成概率分布，和为1.
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',#顺序编码用这种loss函数。
metrics=['acc']
)
model.fit(train_image, train_label, epochs=15)
model.evaluate(test_image, test_label)#在测试数据集上进行评价。
#顺序编码
train_label
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)
#变为独热编码
train_label_onehot = tf.keras.utils.to_categorical(train_label)#顺序编码变为独热编码的方法。
train_label_onehot[-1]
array([0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], dtype=float32)
test_label
array([9, 2, 1, ..., 8, 1, 5], dtype=uint8)
test_label_onehot = tf.keras.utils.to_categorical(test_label)
test_label_onehot
array([[0., 0., 0., ..., 0., 0., 1.],
[0., 0., 1., ..., 0., 0., 0.],
[0., 1., 0., ..., 0., 0., 0.],
...,
[0., 0., 0., ..., 0., 1., 0.],
[0., 1., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.]], dtype=float32)
#用独热编码建立的网络和顺序编码建立的网络相同。
model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28))) # 28*28
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),#规定为一个优化器实例。
loss='categorical_crossentropy',
metrics=['acc']
)
model.fit(train_image, train_label_onehot, epochs=5)
predict = model.predict(test_image)
test_image.shape
(10000, 28, 28)
predict.shape #test数据集形状10000 28 28，用10000，10的向量输出预测结果。10个概率值中最大的值所在的索引就是预测结果。
(10000, 10)
predict[0]
array([3.3149071e-16, 4.7077840e-17, 1.8650274e-17, 9.4182964e-22,
2.5816951e-21, 9.3763107e-03, 4.3186182e-19, 1.4846660e-03,
1.9172960e-12, 9.8913902e-01], dtype=float32)
np.argmax(predict[0])
9
test_label[0]
9
[2.11]–优化函数、学习速率、反向传播算法
输出层为值，不激活。
输出层为逻辑回归二分类，用'sigmoid'进行激活，判断与0.5的关系。
输出层为多分类，用'softmax'进行激活，取各个分类最大的概率值所在的索引为输出结果。
[2.12]–网络优化与超参数选择
[2.13]–Dropout抑制过拟合与网络参数选择总原则
[2.14]–Dropout与过拟合抑制
model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28))) # 28*28
model.add(tf.keras.layers.Dense(128, activation='relu'))
#model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(128, activation='relu'))
#model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(128, activation='relu'))
#model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(10, activation='softmax'))
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss='categorical_crossentropy',
metrics=['acc']
)
history = model.fit(train_image, train_label_onehot,
epochs=10,
validation_data=(test_image, test_label_onehot))#训练过程中训练集和测试集分别的loss和acc。
history.history.keys()
dict_keys(['loss', 'acc', 'val_loss', 'val_acc'])
plt.plot(history.epoch, history.history.get('acc'), label='acc')
plt.plot(history.epoch, history.history.get('val_acc'), label='val_acc')
plt.legend()
plt.plot(history.epoch, history.history.get('loss'), label='loss')
plt.plot(history.epoch, history.history.get('val_loss'), label='val_loss')
plt.legend()
plt.plot(history.epoch, history.history.get('loss'), label='loss')
plt.plot(history.epoch, history.history.get('val_loss'), label='val_loss')
plt.legend()
plt.plot(history.epoch, history.history.get('acc'), label='acc')
plt.plot(history.epoch, history.history.get('val_acc'), label='val_acc')
plt.legend()
#过拟合： 在训练数据上得分很高， 在测试数据上得分相对比较低
#欠拟合： 在训练数据上得分比较低， 在测试数据上得分相对比较低
抑制过拟合最好增加训练数据。
[2.15]–tf.keras函数式API
像函数调用一样，把每一层变成一个函数。
input1 = keras.Input(shape=(28, 28))#建立一个输入，规定好形状。
input2 = keras.Input(shape=(28, 28))
x1 = keras.layers.Flatten()(input1)#调用方法传递参数为input1.
x2 = keras.layers.Flatten()(input2)
x = keras.layers.concatenate([x1, x2])#合并成一个，因为判断两个图片是不是同一个图片。
x = keras.layers.Dense(32, activation='relu')(x)
output = keras.layers.Dense(1, activation='sigmoid')(x)
model = keras.Model(inputs=[input1, input2], outputs=output)
函数式API可以让我们构建多输入多输出模型。
x = keras.layers.Dense(32, activation='relu')(x)
x = keras.layers.Dropout(0.5)(x)
x = keras.layers.Dense(64, activation='relu')(x)
output = keras.layers.Dense(10, activation='softmax')(x)
model = keras.Model(inputs=input, outputs=output)
#层层调用，建立input和output的关系。input和output是层层关联的。
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(train_images,
train_labels,
epochs=30,
validation_data=(test_images, test_labels))
389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
