2019-02-11 00:03:28 qq_36771850 阅读数 571
  • 深度学习图像处理之垃圾分类

    图像分类是图像处理领域的基本任务,同时也是深度学习领域的“Hello Word”,掌握好相关的基础知识,才能更好地开展识别、分割、去噪等更加复杂的任务。本课程将以当下最火热的垃圾分类作为主题,手把手地带领大家实现图像分类任务的完整过程。课程可以分为三个板块: (1)深度学习在图像处理领域的发展过程; (2)解析经典的卷积神经网络; (3)垃圾分类实战。本课程将使用Pytorch深度学习框架进行实战,并在ubuntu系统上进行演示,包括:不同标注文件下的数据集读取、编写卷积神经网络、训练垃圾分类数据集、测试训练网络模型、网络可视化、性能评估等。

    833 人正在学习 去看看 郭冰洋

使用Python的Keras库来学习深度学习中的多分类问题 ------ 路透社新闻主题分类。
路透社数据集是一个简单的、广泛的使用的文本分类数据集,它包括46个不同的主题。
新闻分类

将评论解码为英文单词

用下面的代码解析第一条train_data[0]中的新闻

word_index = reuters.get_word_index()
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
decoded_newswire = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])

print(decoded_newswire)

新闻分类

训练网络

from keras.datasets import reuters
import numpy as np
from keras import models
from keras import layers
import matplotlib.pyplot as plt

#加载路透社数据集
(train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000)

#编码数据
def vectorize_sequences(sequences, dimension=10000):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results

#将数据向量化
x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)

#one_hot编码
def to_one_hot(labels, dimension=46):
    results = np.zeros((len(labels), dimension))
    for i, label in enumerate(labels):
        results[i, label] = 1.
    return results

#将标签向量化
one_hot_train_labels = to_one_hot(train_labels)
one_hot_test_labels = to_one_hot(test_labels)

#模型定义
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(46, activation='softmax'))

#编译模型
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])

#留出验证集
x_val = x_train[:1000]
partial_x_train = x_train[1000:]
y_val = one_hot_train_labels[:1000]
partial_y_train = one_hot_train_labels[1000:]

#训练模型
history = model.fit(partial_x_train,
partial_y_train,
epochs=20,
batch_size=512,
validation_data=(x_val, y_val))

#绘制训练损失和验证损失
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()

#绘制训练精度和验证精度
plt.clf()
acc = history.history['acc']
val_acc = history.history['val_acc']
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()

新闻分类1
新闻分类2

2018-03-02 21:56:51 xueyepiaoling 阅读数 265
  • 深度学习图像处理之垃圾分类

    图像分类是图像处理领域的基本任务,同时也是深度学习领域的“Hello Word”,掌握好相关的基础知识,才能更好地开展识别、分割、去噪等更加复杂的任务。本课程将以当下最火热的垃圾分类作为主题,手把手地带领大家实现图像分类任务的完整过程。课程可以分为三个板块: (1)深度学习在图像处理领域的发展过程; (2)解析经典的卷积神经网络; (3)垃圾分类实战。本课程将使用Pytorch深度学习框架进行实战,并在ubuntu系统上进行演示,包括:不同标注文件下的数据集读取、编写卷积神经网络、训练垃圾分类数据集、测试训练网络模型、网络可视化、性能评估等。

    833 人正在学习 去看看 郭冰洋

深度学习需要掌握的基本知识

主题内容

机器学习概要

a) 什么是机器学习 & 与传统软件开发的异同
b) 机器学习的分类和特点
c) 机器学习可以解决的问题和应用现状

广义线性模型

a) 感知器模型 Perceptron
b) 线性神经元 Linear Neuron / Adaline
c) 逻辑回归 Logistic Regression
d) 误差曲面和三种梯度下降算法 Gradient Descendent 

经典概率模型

a) 朴素贝叶斯 Naïve Bayes

决策树及其组合模型 Ensemble Models

a) 决策树 Decision Tree: ID3 & CART
b) 随机森林 Random Forest
c) 自适应增强算法 Adaptive Boosting (AdaBoost)

d) 梯度增强决策树 Gradient Boost Decision Tree (GBDT)

非监督学习模型 Unsupervised Learning

a) 聚类 Clustering: K-­‐Means, Hierarchy
b) 降维 Dimension Reduction
i. 主成分分析 Principle Component Analysis
ii. 奇异值分解 Singularity Decomposition c) 关联规则
i. Apriori 关联分析
ii. FP-­‐growth 频率项集

人工神经元网络 Artificial Neural Networks

a) 神经元网络架构
b) 向后传播训练算法 Backpropagation
c) 多层感知器网络 Multiple-­‐Layer Perceptron (MLP) d) 深度学习神经网络介绍
i. 卷积神经网络 CNN
ii. 循环神经网络 RNN 及其应用 1. 长短记忆神经网络 LSTM
2. 受限玻尔兹曼机 Restricted Boltzmann Machine
3. 深度置信网络 Deep Belief Net
4. Deep Autoencoder


2017-06-27 09:28:00 weixin_30591551 阅读数 10
  • 深度学习图像处理之垃圾分类

    图像分类是图像处理领域的基本任务,同时也是深度学习领域的“Hello Word”,掌握好相关的基础知识,才能更好地开展识别、分割、去噪等更加复杂的任务。本课程将以当下最火热的垃圾分类作为主题,手把手地带领大家实现图像分类任务的完整过程。课程可以分为三个板块: (1)深度学习在图像处理领域的发展过程; (2)解析经典的卷积神经网络; (3)垃圾分类实战。本课程将使用Pytorch深度学习框架进行实战,并在ubuntu系统上进行演示,包括:不同标注文件下的数据集读取、编写卷积神经网络、训练垃圾分类数据集、测试训练网络模型、网络可视化、性能评估等。

    833 人正在学习 去看看 郭冰洋

-          深度学习和人工智能的历史和发展历程

-          深度学习基础及其在视觉中的应用

-          人脸识别的发展现状

-          人工智能芯片和算法平台

-          深度强化学习理论和实践

-          图像分类、目标检测、语义分割、行为姿态分析前沿算法

-          基于GPU的深度学习训练平台和CNN加速优化

-          基于深度学习的视频结构化

-          基于深度学习的目标检测实践

-          基于深度学习的人体属性应用实践

-          基于深度学习的智能检索

-          基于深度学习的行业应用

-          基于深度学习的语音识别

-          基于深度学习的文字识别

-          基于深度学习的辅助驾驶

-          基于深度学习的交通行业应用

转载于:https://www.cnblogs.com/man-li/p/7083453.html

2018-12-21 14:07:12 u011240016 阅读数 1070
  • 深度学习图像处理之垃圾分类

    图像分类是图像处理领域的基本任务,同时也是深度学习领域的“Hello Word”,掌握好相关的基础知识,才能更好地开展识别、分割、去噪等更加复杂的任务。本课程将以当下最火热的垃圾分类作为主题,手把手地带领大家实现图像分类任务的完整过程。课程可以分为三个板块: (1)深度学习在图像处理领域的发展过程; (2)解析经典的卷积神经网络; (3)垃圾分类实战。本课程将使用Pytorch深度学习框架进行实战,并在ubuntu系统上进行演示,包括:不同标注文件下的数据集读取、编写卷积神经网络、训练垃圾分类数据集、测试训练网络模型、网络可视化、性能评估等。

    833 人正在学习 去看看 郭冰洋
# -*- coding: utf-8 -*-
"""单标签多分类问题之新闻主题分类.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/18TqrbGYm2J-jmR89KZHOa7vxbAr4eOz2

### 问题解释

每个数据点只能划分到一个类别,但是类别总数大于2个,这类问题称之为单标签,多分类。如果每个数据点可以划分到多个类别,则就是另一个问题:多标签,多分类。

### 数据集

使用路透社数据集,其中包含很多短新闻和对应的主题,文本分类数据集。总共有46个不同的主题,每个主题至少有10个样本,有些主题样本会更多。

数据集是Keras内置的一部分,直接用即可。
"""

# 加载数据
from keras.datasets import reuters
(train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000) # num_words=10000,将数据限定为前10000个最长出现的单词

train_data.shape

test_data.shape

train_data # 每个样本是一个list,表示单词索引

# 索引解码
word_index = reuters.get_word_index()

reverse_word_index = dict([(value, key) for (key, value) in word_index.items()]) # 键值翻转
decode_review = ' '.join([reverse_word_index.get(i-3, '?') for i in train_data[0]]) # 评论解码,索引去掉3,0为填充,1为序列开始,2位unknown

decode_review

train_labels[0]

# 数据准备
import numpy as np
def vectorize_sequences(sequences, dimension=10000):
  results = np.zeros((len(sequences), dimension))
  for i, sequence in enumerate(sequences):
    results[i, sequence] = 1
  return results

x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)

x_train.shape

"""### 向量化数据的解释

因为原始数据最外层是个一维数组,组成元素是list,我们需要的是二维数组形式的数据,所以需要把list拆出来,但是每个list长度不同,我们总共用10000个单词,基于one-hot编码,使得数据规整,列为10000即可。只有标签对应的元素存在才把对应的元素设定为1.

### 标签数据的向量化

和上面的原理相同。
"""

def to_one_hot(labels, dimension=46):
  results = np.zeros((len(labels), dimension))
  for i, label in enumerate(labels):
    results[i, label] = 1.
  return results

one_hot_train_labels = to_one_hot(train_labels)
one_hot_test_labels = to_one_hot(test_labels)

one_hot_train_labels[0].shape

# 上面是手工实现,其实也可以哟经Keras内置方法来做

# from keras.utils.np_utils import to_categorical
# one_hot_train_labels = to_categorical(train_labels)
# one_hot_test_labels = to_categorical(test_labels)

# 模型定义
from keras import models
from keras import layers

model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(64,activation='relu'))
model.add(layers.Dense(46, activation='softmax'))

"""### 模型解释

最后一层大小是46的Dense层,每个输入样本,网络都会输出一个46维的向量,每个元素代表不同的输出类别。而在最后一层使用的是softmax激活层,给出不同输出类别的概率值。

多分类问题最好的损失函数是categorical_crossentropy,即分类交叉熵函数。分类交叉熵函数可以用来衡量两个概率分布之间的距离,通过将两个分布的距离最小化,训练网络就能够将输出结果尽可能接近真实标签。
"""

# 编译模型,
# 配置损失函数和优化器

model.compile(optimizer='rmsprop',
             loss='categorical_crossentropy',
             metrics=['accuracy'])

# 留出验证集,从训练集中拿出来一部分做验证集,不是测试集
x_val = x_train[:1000]
partial_x_train = x_train[1000:]

y_val = one_hot_train_labels[:1000]
partial_y_train = one_hot_train_labels[1000:]

# 训练模型
history = model.fit(partial_x_train,partial_y_train, epochs=20, batch_size=512, validation_data=(x_val, y_val))

history.history.keys()

# 绘制训练损失和验证损失
# 监控模型是否过拟合了

import matplotlib.pyplot as plt

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(loss) + 1)

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')

plt.title('Training and Validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

"""### 分析

我们从训练集中抽出一部分来验证模型训练效果,算是训练过程里的自我监督。


从图中我们可以看到,大概在训练到10轮后,模型开始过拟合。所以我们可以选择在这个区间停止训练。
"""

# 绘制训练精度和验证精度
plt.clf()

acc = history.history['acc']
val_acc = history.history['val_acc']

epochs = range(1, len(acc) + 1)

plt.plot(epochs, acc, 'bo', label='Training loss')
plt.plot(epochs, val_acc, 'r', label='Validation loss')

plt.title('Training and Validation loss')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()

plt.show()

# 现在我们重新训练一个模型,只训练到第10轮

model2 = models.Sequential()
model2.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
model2.add(layers.Dense(64, activation='relu'))
model2.add(layers.Dense(46, activation='softmax'))

model2.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])

model2.fit(partial_x_train,
          partial_y_train,
          epochs=10, 
          batch_size=512,
          validation_data=(x_val, y_val))

results = model.evaluate(x_test, one_hot_test_labels)

results

# 现在我们重新训练一个模型,只训练到第9轮

model3 = models.Sequential()
model3.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
model3.add(layers.Dense(64, activation='relu'))
model3.add(layers.Dense(46, activation='softmax'))

model3.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])

model3.fit(partial_x_train,
          partial_y_train,
          epochs=9, 
          batch_size=512,
          validation_data=(x_val, y_val))

results = model.evaluate(x_test, one_hot_test_labels)

results

# 使用模型预测结果

predictions = model2.predict(x_test)

predictions[0].argmax()

predictions[0][3]

"""### 实验总结

中间层的维度要足够大,因为信息的传递如果在当前层丢失了,那么后面就再也看不见了。所以隐藏层要足够大,比如最后输出是46维,中间层的神经元个数不能小于46,否则成了信息瓶颈,信息被压缩到小于输出空间,导致最后无法得出正确的结论。

### 知识点总结

- 对于N类分类问题,网络的最后一层大小是N的Dense层
- 单标签多分类问题,网络的最后一层用softmax激活函数,输出N个类别的概率分布
- 多分类问题的损失函数几乎都用分类交叉熵
- 处理多分类问题标签的两种方法:
  - one-hot编码,使用categorical_crossentropy作为损失函数
  - 编码为整数张量,使用sparse_categorical_crossentropy损失函数
"""

Jupyter Notebook版本可以到:https://github.com/Bingyy/DeepLearning/blob/master/单标签多分类问题之新闻主题分类.ipynb 查看。

END.

参考:

《Deep Learning with Python》

2020-01-17 09:02:29 aass6d 阅读数 89
  • 深度学习图像处理之垃圾分类

    图像分类是图像处理领域的基本任务,同时也是深度学习领域的“Hello Word”,掌握好相关的基础知识,才能更好地开展识别、分割、去噪等更加复杂的任务。本课程将以当下最火热的垃圾分类作为主题,手把手地带领大家实现图像分类任务的完整过程。课程可以分为三个板块: (1)深度学习在图像处理领域的发展过程; (2)解析经典的卷积神经网络; (3)垃圾分类实战。本课程将使用Pytorch深度学习框架进行实战,并在ubuntu系统上进行演示,包括:不同标注文件下的数据集读取、编写卷积神经网络、训练垃圾分类数据集、测试训练网络模型、网络可视化、性能评估等。

    833 人正在学习 去看看 郭冰洋

Python 深度学习-神经网络入门

第一次写博客,也是刚刚接触神经网络的小白,所以想将自己的学习到的一点点知识分享给大家,同时也可以加深对神经网络的理解。欢迎大家提出宝贵的建议,我会努力改变做到更好,有不理解的可以随时私信,谢谢大家~

详细信息

语言:python
框架:Keras
IDE:jupyter notebook
处理问题:电影评论分类(二分类)、新闻主题分类(多分类)、预测房价(回归问题)

一、 电影评论分类(二分类):
本节使用IMDB数据集,它包含来自互联网电影数据库(IMDB)的50 000 条严重两极分化的评论。数据集被分为用于训练的25 000 条评论与用于测试的25 000 条评论,训练集和测试集都包含50% 的正面评论和50% 的负面评论。
步骤:
1. 加载IMDB数据集

import keras     #导入库
from keras.datasets import imdb
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)   #num_words 表示仅保留训练数据集中常出现的10000个词

2. 将评论编码,并将某条评论迅速解码为英文单词

train_data[0]  
train_labels[0] 
max([max(sequence) for sequence in train_data]) #测试最大单词索引为9999

#word_index是一个将单词映射为整数索引的字典
word_index = imdb.get_word_index()
# 键值颠倒,将整数索引映射为单词
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
#将评论解码
decoded_review = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])
#测试将某条评论迅速转化为英文单词
decoded_review 

3. 准备数据集
不能将整数序列直接输入神经网络,需要将列表转化为张量

import numpy as np

def vectorize_sequences(sequences, dimension=10000):
    # 创建一个形状为 (len(sequences), dimension)的零矩阵
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.  
    return results

# 将训练数据向量化
x_train = vectorize_sequences(train_data)
# 将测试数据向量化
x_test = vectorize_sequences(test_data)
#输出转化后的样本,0 1序列
x_train[0]
#标签向量化
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')

4. 构建网络
一个三层的简单神经网络,两个隐藏层,单元数为16,激活函数为relu;一个全连接层,激活函数为sigmoid,处理二分类
模型定义

from keras import models
from keras import layers

model = models.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

编译模型

model.compile(optimizer='rmsprop', 
              loss='binary_crossentropy',
              metrics=['accuracy'])

配置优化器

from keras import optimizers

model.compile(optimizer=optimizers.RMSprop(lr=0.001),
              loss='binary_crossentropy',
              metrics=['accuracy'])

使用自定义的损失和指标

from keras import losses
from keras import metrics

model.compile(optimizer=optimizers.RMSprop(lr=0.001),
              loss=losses.binary_crossentropy,
              metrics=[metrics.binary_accuracy])

注意:
Optimizer(优化器):常用rmsprop
Loss(损失函数):视情况而定,对于二分类问题的 sigmoid标量输出,可用binary_crossentropy损失函数。对于多分类问题,可用categorical_crossentropy(分类交叉熵)
Metriucs: 测试参数 ,可选择精度

5.验证
留出验证集:

x_val = x_train[:10000]
partial_x_train = x_train[10000:]

y_val = y_train[:10000]
partial_y_train = y_train[10000:]

训练模型

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=20,  #20次迭代
                    batch_size=512,
                    validation_data=(x_val, y_val))
history_dict = history.history
history_dict.keys()

绘制训练损失和验证损失:

import matplotlib.pyplot as plt

acc = history.history['binary_accuracy']
val_acc = history.history['val_binary_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

# "bo" is for "blue dot"
plt.plot(epochs, loss, 'bo', label='Training loss')
# b is for "solid blue line"
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

结果图:
训练损失和验证损失
绘制训练精度和验证精度:

plt.clf()   # clear figure
acc_values = history_dict['binary_accuracy']
val_acc_values = history_dict['val_binary_accuracy']

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

结果图:
训练精度和验证精度
二、新闻主题分类(多分类):
处理多分类和二分类的方式类似,主要区别在于神经网络的全连接层,所以没有详细的介绍,程序及结果如下:

1.加载路透社数据集:

import keras

from keras.datasets import reuters
(train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000)
#分别输出测试验证样本的数目
len(train_data)  
len(test_data)
train_data[10]

将索引解码为新闻文本(共有46个类别,则解码后为0-45 这个数字):

word_index = reuters.get_word_index()
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
# Note that our indices were offset by 3
# because 0, 1 and 2 are reserved indices for "padding", "start of sequence", and "unknown".
decoded_newswire = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])
#输出测试文本的英文内容
decoded_newswire
#随机检测某一样本所属于的类别
train_labels[10]

2.编码数据:

import numpy as np

def vectorize_sequences(sequences, dimension=10000):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
    #将索引对应位置编码为1  其他位置置零
        results[i, sequence] = 1.   
    return results

 #训练和测试数据全部向量化
x_train = vectorize_sequences(train_data) 
x_test = vectorize_sequences(test_data)

向量化:

def to_one_hot(labels, dimension=46):
    results = np.zeros((len(labels), dimension))
    for i, label in enumerate(labels):
        results[i, label] = 1.
    return results

#将训练和测试lable进行onehot编码
one_hot_train_labels = to_one_hot(train_labels)
one_hot_test_labels = to_one_hot(test_labels)

3.构建网络:
模型定义:

from keras import models
from keras import layers

model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(46, activation='softmax'))

编译模型:

model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

4.验证
留出验证集:

x_val = x_train[:1000]
partial_x_train = x_train[1000:]

y_val = one_hot_train_labels[:1000]
partial_y_train = one_hot_train_labels[1000:]

训练模型:

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=20,
                    batch_size=512,
                    validation_data=(x_val, y_val))

绘制训练损失和验证损失:

import matplotlib.pyplot as plt

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(loss) + 1)

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

绘制训练精度和验证精度:

plt.clf()   # clear figure

acc = history.history['acc']
val_acc = history.history['val_binary_accuracy']

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

三、预测房价(回归问题):
1.加载波士顿房价:

import keras

from keras.datasets import boston_housing
(train_data, train_targets), (test_data, test_targets) =  boston_housing.load_data()
#验证集和测试集大小
train_data.shape
test_data.shape
train_targets

2.准备数据集

数据标准化(由于 回归问题 各个特征的取值范围很可能不同 所以需要归一化处理)

mean = train_data.mean(axis=0)
train_data -= mean
std = train_data.std(axis=0)
train_data /= std

test_data -= mean
test_data /= std

3.构建网络
模型定义:

from keras import models
from keras import layers

def build_model():
    #因为需要将同一个模型多次实例化,所以用同一个函数来构建模型
    model = models.Sequential()
    model.add(layers.Dense(64, activation='relu',
                           input_shape=(train_data.shape[1],)))
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(1))
    model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
    return model

K折验证:

import numpy as np

k = 4
num_val_samples = len(train_data) // k
num_epochs = 100
all_scores = []
for i in range(k):
    print('processing fold #', i)
    # 准备验证数据:第K个分区的数据
    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]
    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]

    # 准备训练数据,其他所有分区的数据
    partial_train_data = np.concatenate(
        [train_data[:i * num_val_samples],
         train_data[(i + 1) * num_val_samples:]],
        axis=0)
    partial_train_targets = np.concatenate(
        [train_targets[:i * num_val_samples],
         train_targets[(i + 1) * num_val_samples:]],
        axis=0)

    # 构建Keras模型
    model = build_model()
    # 训练模型 (in silent mode, verbose=0)
    model.fit(partial_train_data, partial_train_targets,
              epochs=num_epochs, batch_size=1, verbose=0)
    # 在验证数据上评估模型
    val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
    all_scores.append(val_mae)

保存每折的验证结果:

from keras import backend as K
K.clear_session()

num_epochs = 500
all_mae_histories = []
for i in range(k):
    print('processing fold #', i)
    # Prepare the validation data: data from partition # k
    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]
    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]

    # Prepare the training data: data from all other partitions
    partial_train_data = np.concatenate(
        [train_data[:i * num_val_samples],
         train_data[(i + 1) * num_val_samples:]],
        axis=0)
    partial_train_targets = np.concatenate(
        [train_targets[:i * num_val_samples],
         train_targets[(i + 1) * num_val_samples:]],
        axis=0)

    # Build the Keras model (already compiled)
    model = build_model()
    # Train the model (in silent mode, verbose=0)
    history = model.fit(partial_train_data, partial_train_targets,
                        validation_data=(val_data, val_targets),
                        epochs=num_epochs, batch_size=1, verbose=0)
    mae_history = history.history['val_mean_absolute_error']
    all_mae_histories.append(mae_history)

计算所有轮次中的K折验证平均值

average_mae_history = [
    np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)]

绘制验证分数:

import matplotlib.pyplot as plt

plt.plot(range(1, len(average_mae_history) + 1), average_mae_history)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

绘制验证分数(删除前十个点)

def smooth_curve(points, factor=0.9):
  smoothed_points = []
  for point in points:
    if smoothed_points:
      previous = smoothed_points[-1]
      smoothed_points.append(previous * factor + point * (1 - factor))
    else:
      smoothed_points.append(point)
  return smoothed_points

smooth_mae_history = smooth_curve(average_mae_history[10:])

plt.plot(range(1, len(smooth_mae_history) + 1), smooth_mae_history)
plt.xlabel('Epochs')
plt.ylabel('Validation MAE')
plt.show()

在这里插入图片描述
训练最终模型:

model = build_model()
# Train it on the entirety of the data.
model.fit(train_data, train_targets,
          epochs=80, batch_size=16, verbose=0)
test_mse_score, test_mae_score = model.evaluate(test_data, test_targets)

最终结果如下:

test_mae_score
2.5532484335057877

代码参考了python深度学习一书中的源代码并加有部分注释。

没有更多推荐了,返回首页