tf86 http://www.tf86.com TensorFlow入门教程 Mon, 06 Aug 2018 12:06:39 +0000 zh-CN hourly 1 https://wordpress.org/?v=4.8.7 在树莓派上安装 TensorFlow http://www.tf86.com/2018/08/06/install_raspbian/ http://www.tf86.com/2018/08/06/install_raspbian/#respond Mon, 06 Aug 2018 12:04:44 +0000 http://www.tf86.com/?p=2217 [...]]]> 这个教程介绍如何在运行 Raspbian 的 Raspberry Pi 上安装 TensorFlow。 虽然这些说明也适用于其他 P i变体,但我们仅在满足以下要求的机器上测试(并且我们仅支持)这些说明:

要求:Raspberry Pi devices running Raspbian 9.0 or higher

Atlas是一个基于 numpy 的线性代数库,因此需要在 TensorFlow 之前安装。 要将其添加到系统,请运行以下命令:

前置依赖:sudo apt install libatlas-base-dev

安装 TensorFlow

pip3 install tensorflow # Python 3.n
pip install tensorflow # Python 2.7

验证安装,可以尝试运行一下 Python 代码。

Python

import tensorflow as tf
hello = tf.constant(‘Hello, TensorFlow!’)
sess = tf.Session()
print(sess.run(hello))

正确的输出:

Hello, TensorFlow!

原文:https://www.tensorflow.org/install/install_raspbian
翻译:http://www.tf86.com/2018/08/06/install_raspbian/

]]>
http://www.tf86.com/2018/08/06/install_raspbian/feed/ 0
Auto-Keras 自动搜索深度学习模型的网络架构和超参数 http://www.tf86.com/2018/08/03/auto-keras/ http://www.tf86.com/2018/08/03/auto-keras/#respond Fri, 03 Aug 2018 04:24:20 +0000 http://www.tf86.com/?p=2202 [...]]]> Auto-Keras 是一个开源的自动机器学习库。Auto-Keras 的终极目标是允许所有领域的只需要很少的数据科学或者机器学习背景的专家都可以很容易的使用深度学习。Auto-Keras 提供了一系列函数来自动搜索深度学习模型的网络和超参数。

安装:

pip install autokeras

样例:

import autokeras as ak
clf = ak.ImageClassifier()
clf.fit(x_train, y_train)
results = clf.predict(x_test)

官方网站:http://autokeras.com/
开源项目:https://github.com/jhfjhfj1/autokeras

Auto-Keras is an open source software library for automated machine learning (AutoML). The ultimate goal of AutoML is to allow domain experts with limited data science or machine learning background easily accessible to deep learning models. Auto-Keras provides functions to automatically search for architecture and hyperparameters of deep learning models.

]]>
http://www.tf86.com/2018/08/03/auto-keras/feed/ 0
TF86:DrQA基于维基百科数据的开放域问答机器人实战教程 http://www.tf86.com/2018/07/20/reading-wikipedia-to-answer-open-domain-questions/ http://www.tf86.com/2018/07/20/reading-wikipedia-to-answer-open-domain-questions/#respond Fri, 20 Jul 2018 11:49:20 +0000 http://tf86.com/?p=2188 [...]]]> DrQA基于维基百科数据的开放域问答机器人实战教程

DrQA 是一个基于维基百科数据的开放域问答系统,它由检索器和阅读器组成。其中检索器用于从海量的文本(例如维基百科)中获得相关的文章;阅读器用于从文章中获得相应的答案。

官方介绍:
DrQA是一个应用于开放域问答的阅读理解系统。特别是,DrQA的目标是“大规模机读”(MRS)。在这个设定中,我们在可能非常大的非结构化文档集中搜索问题的答案。因此,系统必须将文档检索(查找相关文档)的挑战与机器对文本的理解(从这些文档中识别答案)的挑战相结合。

我们使用DrQA的实验侧重于回答factoid问题,同时使用Wikipedia作为文档的独特知识源。维基百科是一个非常适合大规模,丰富,详细信息的来源。为了回答任何问题,必须首先在超过500万个文章中检索可能相关的文章,然后仔细扫描它们以确定答案。

请注意,DrQA将Wikipedia视为一个通用的文章集合,并不依赖于其内部知识结构。因此,DrQA可以直接应用于任何文档集合。

数据集:维基百科
框架:PyTorch
版本:PyTorch torch-0.3.0
论文:Reading Wikipedia to Answer Open-Domain Questions
项目:https://github.com/facebookresearch/DrQA
系统架构:

实战:
交互模式下提问:

where is stanford university

可以看到检索到的文档是 Stanford University,问题的答案是:浅绿色标注的部分,答案非常的精准。

交互模式下提问:

where is Barack Hussein Obama from

交互模式下提问:
回答不是很精准,我其实想问的是奥巴马来自哪里。答案返回的是奥巴马在哪里,奥巴马在华盛顿,不过也还是相当不错。

who is Donald Trump
这个问题并没有找到准确的答案,虽然文档是相关的。

PyTorch,Torch,机器学习交流群:518428276

]]>
http://www.tf86.com/2018/07/20/reading-wikipedia-to-answer-open-domain-questions/feed/ 0
十分钟快速入门 TensorFlow:无需配置环境,在线学习 TensorFlow http://www.tf86.com/2018/07/20/get-started-with-tensorflow/ http://www.tf86.com/2018/07/20/get-started-with-tensorflow/#respond Fri, 20 Jul 2018 10:21:33 +0000 http://tf86.com/?p=2181 [...]]]>

本文是全系列中第1 / 5篇:TensorFlow 从入门到精通

TensorFlow是一个用于研究和生产的开源机器学习库。 TensorFlow为初学者和专家提供API,以便为桌面,移动,Web和云开发。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 引入 TensorFlow 库
import tensorflow as tf
# 引入 mnist 数据集
mnist = tf.keras.datasets.mnist
# 载入训练集和测试集
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# 建立 Keras 序列模型
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
# 编译模型,optimizer 优化函数,loss 损失函数,metrics 评价标准
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
# 训练模型
model.fit(x_train, y_train, epochs=5)
# 评估模型
model.evaluate(x_test, y_test)

Google 提供了在线的 Jupyter 运行环境可以直接运行以上入门实例,不需要配置环境。

内容翻译自:https://www.tensorflow.org/tutorials/

]]>
http://www.tf86.com/2018/07/20/get-started-with-tensorflow/feed/ 0
中文自然语言处理工具集:分词,相似度匹配 http://www.tf86.com/2018/03/31/nlp-segment-similar/ http://www.tf86.com/2018/03/31/nlp-segment-similar/#respond Sat, 31 Mar 2018 02:37:13 +0000 http://tf86.com/?p=1716 [...]]]> 分词工具
  • 结巴分词

https://github.com/fxsjy/jieba

  • pullword

http://www.pullword.com/

  • FudanNLP

https://github.com/FudanNLP/fnlp

相似度匹配工具

  • gensim

gensim – Topic Modelling in Python

https://github.com/RaRe-Technologies/gensim

  • starspace

https://github.com/facebookresearch/StarSpace

项目

  • bosonnlp

https://bosonnlp.com/

]]>
http://www.tf86.com/2018/03/31/nlp-segment-similar/feed/ 0
使用vgg16模型进行图片预测 http://www.tf86.com/2018/03/29/vgg16-model-prediction-image/ http://www.tf86.com/2018/03/29/vgg16-model-prediction-image/#respond Thu, 29 Mar 2018 14:00:27 +0000 http://tf86.com/?p=1668 [...]]]>

本文是全系列中第2 / 2篇:Keras 从入门到精通

使用vgg16模型进行图片预测

前面我们学习了使用cifra10来判断图片的类别,今天我们使用更加强大的已经训练好的模型来预测图片的类别,那就是vgg16,对应的供keras使用的模型人家已经帮我们训练好,我可不想卖肾来买一个gpu。。。
对应的模型在 ‘vgg16’ 可以下载。估计被墙了,附上链接(http://pan.baidu.com/s/1qX0CJSC)

导入必要的库


1
2
3
4
5
from keras.models import Sequential
from keras.layers.core import Flatten, Dense, Dropout
from keras.layers.convolutional import Convolution2D, MaxPooling2D, ZeroPadding2D
from keras.optimizers import SGD
import cv2, numpy as np

Using Theano backend.
D:\Anaconda\lib\site-packages\theano-0.8.0.dev0-py2.7.egg\theano\tensor\signal\downsample.py:5: UserWarning: downsample module has been moved to the pool module.
warnings.warn(“downsample module has been moved to the pool module.”)

使用keras建立vgg16模型


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
def VGG_16(weights_path=None):
model = Sequential()
model.add(ZeroPadding2D((1,1),input_shape=(3,224,224)))
model.add(Convolution2D(64, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(64, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), strides=(2,2)))

model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(128, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(128, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), strides=(2,2)))

model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), strides=(2,2)))

model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), strides=(2,2)))

model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), strides=(2,2)))

model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1000, activation='softmax'))

if weights_path:
model.load_weights(weights_path)

return model

1
model = VGG_16('vgg16_weights.h5')

1
2
sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss='categorical_crossentropy')

现在我们开始来预测了

首先写一个方法来加载并处理图片


1
2
3
4
5
6
7
8
def load_image(imageurl):
im = cv2.resize(cv2.imread(imageurl),(224,224)).astype(np.float32)
im[:,:,0] -= 103.939
im[:,:,1] -= 116.779
im[:,:,2] -= 123.68
im = im.transpose((2,0,1))
im = np.expand_dims(im,axis=0)
return im

读取vgg16的类别文件


1
2
3
f = open('synset_words.txt','r')
lines = f.readlines()
f.close()

1
2
3
4
def predict(url):
im = load_image(url)
pre = np.argmax(model.predict(im))
print lines[pre]

1
%pylab inline

Populating the interactive namespace from numpy and matplotlib


1
from IPython.display import Image

1
Image('cat1.jpg')

开始预测


1
predict('cat1.jpg')

n02123045 tabby, tabby cat


1
Image('zebra.jpg')


1
predict('zebra.jpg')

n02391049 zebra


1
Image('airplane.jpg')


1
predict('airplane.jpg')

n02690373 airliner


1
Image('pig.jpg')


1
predict('pig.jpg')

n02395406 hog, pig, grunter, squealer, Sus scrofa

可见,判断率还是很高的。。。。

总结

通过这次学习,学会了使用keras来搭建模型,使用vgg16这个模型。

hadxu 授权 http://tf86.com/ 转载
原文链接:https://hadxu.github.io/

]]>
http://www.tf86.com/2018/03/29/vgg16-model-prediction-image/feed/ 0
通过机器学习让医疗数据更好用 http://www.tf86.com/2018/03/28/google-cloud-platform-healthcare/ http://www.tf86.com/2018/03/28/google-cloud-platform-healthcare/#respond Wed, 28 Mar 2018 13:28:34 +0000 http://tf86.com/?p=1643 [...]]]> 在过去 10 年间,医疗数据已经从以纸质文件为主几乎完全数字化为电子健康记录。但是,理解这些数据涉及一些关键挑战。

第一,供应商之间没有共同的数据表示形式;每个供应商都使用不同的方式来构建他们的数据。第二,即使使用相同供应商的网站也可能存在很大不同,例如,他们通常为同一种药物使用不同的代码。第三,数据可能分布在多个表格中,一些表格包含患者就医记录,一些包含实验室结果,其他的则包含生命体征数据。

快速医疗互操作性资源 (FHIR) 标准解决了其中的大多数挑战:它具有一个坚实并且可扩展的数据模型并基于成熟的网络标准构建,正在快速成为个体记录和批量数据访问的事实标准。但是,为了实现大规模机器学习,我们需要一些补充:各种编程语言的实现,将大量数据序列化到磁盘的有效方法,以及允许分析大型数据集的表示形式。

我们高兴地开源 FHIR 标准的一种 Protocol Buffers (简称 Protobuf) 实现,它可以解决这些问题。当前版本支持 Java,并且将很快支持 C++、Go 和 Python。对配置文件的支持也即将发布,还会推出一些工具,帮助用户将旧数据转换成 FHIR:

https://github.com/google/fhir

将 FHIR 用作核心数据模型

过去几年,我们一直与众多学术医疗中心合作,将机器学习应用于匿名病历,我们需要正面解决医疗数据的复杂性,这一点已经变得非常明显。确实,要让机器学习有效用于医疗数据,我们需要从整体上了解每名患者随着时间推移的情况。作为奖励,我们想要一种可以直接用于临床环境的数据表示形式。

尽管 FHIR 标准可以解决我们的大多数需求,但是为了使医疗数据比“旧”数据结构更加易于管理和确保大规模机器学习不依赖于供应商,我们认为引入 Protobuf 可以帮助应用开发者和(机器学习)研究人员使用 FHIR。

当前版本的 Protobuf

为了让我们的 Protobuf 表示适合编程访问和数据库查询,我们做了大量工作。提供的一个示例显示了如何将 FHIR 数据上传到 Google Cloud BigQuery 中并让它可以用于查询,我们将添加直接从批量数据导出上传的其他示例。我们的 Protobuf 符合 FHIR 标准(这些缓冲区实际上是从此标准自动生成的),但可以实现更高级的查询。

当前版本还不可以用于训练 TensorFlow 模型,不过,敬请关注未来更新。我们打算开源尽可能多的近期工作,以便提升我们的研究在现实世界情景中的重现性和适用性。此外,我们还在与 Google Cloud 团队的同事紧密合作,推出更多用于管理大规模医疗数据的工具:

https://github.com/GoogleCloudPlatform/healthcare

]]>
http://www.tf86.com/2018/03/28/google-cloud-platform-healthcare/feed/ 0
TensorFlow Windows 安装 http://www.tf86.com/2018/03/28/tensorflow-windows-install/ http://www.tf86.com/2018/03/28/tensorflow-windows-install/#respond Wed, 28 Mar 2018 09:42:46 +0000 http://tf86.com/?p=1612 [...]]]>

本文是全系列中第1 / 3篇:TensorFlow 安装教程

作者:AI小昕

本系列教程将手把手带您从零开始学习Tensorflow,并最终通过Tensorflow实现一些经典的项目。欢迎您关注我们的教程,关注更多机器学习、深度学习相关的优质博文。

Tensorflow是由谷歌大脑团队于2015年11月开发的第二代开源的机器学习系统。Tensorflow支持python、C++、java、GO等多种编程语言,以及CNN、RNN和GAN等深度学习算法。Tensorflow除可以在Windows、Linux、MacOS等操作系统运行外,还支持Android和iOS移动平台的运行、以及适用于多个CPU/GPU组成的分布式系统中。

Tensorflow是目前最火的深度学习框架,广泛应用于自然语言处理、语音识别、图像处理等多个领域。不仅深受全球深度学习爱好者的广泛欢迎,Google、eBay、Uber、OPenAI等众多科技公司的研发团队也都在使用它。

相较于其它的深度学习框架,如:Caffe、Torch、Keras、MXnet、Theano等,Tensorflow的主要优势有以下几点:高度的灵活性、支持python语言开发、可视化效果好、功能更加强大、运行效率高、强大的社区。

本节将从Tensorflow的安装配置、Tensorflow的核心——计算图模型开始讲起,带大家走进Tensorflow的世界。好了,随小编一起进入正文吧。

1.Tensorflow安装与配置

目前,Windows、Linux和MacOS均已支持Tensorflow。文章将以Windows系统的安装为例。

在安装Tensorflow前,我们要先安装Anaconda,因为它集成了很多Python的第三方库及其依赖项,方便我们在编程中直接调用。

Anaconda下载地址为:https://www.anaconda.com/download/。(分为python3.6版本和python2.7版本,本书使用的是python3.6版本。)

下载好安装包后,一步步执行安装过程,直到出现如图1-1所示的界面,完成Anaconda的安装:

图1-1 Anaconda安装成功截图

安装好Anaconda后,我们便可以打开命令提示符,输入pip install Tensorflow完成Tensorflow的安装。

之后我们进入python可执行界面,输入import tensorflow as tf来检验Tensorflow是否安装成功。如果没有报任何错,可以正常执行,则说明Tensorflow已经安装成功。

Jupyter Notebook是一款非常好用的交互式开发工具,不仅支持40多种编程语言,还可以实时运行代码、共享文档、数据可视化、支持markdown等,适用于机器学习、统计建模数据处理、特征提取等多个领域。尤其在Kaggle、天池等数据科学竞赛中,快捷、实时、方便的优点深受用户欢迎。本书后边的章节中,均将以Jupyter Notebook作为开发环境,运行Tensorflow程序。

]]>
http://www.tf86.com/2018/03/28/tensorflow-windows-install/feed/ 0
TensorFlow 一步一步实现卷积神经网络 http://www.tf86.com/2018/03/27/tensorflow-step-by-step-cnn/ http://www.tf86.com/2018/03/27/tensorflow-step-by-step-cnn/#respond Tue, 27 Mar 2018 11:55:56 +0000 http://tf86.com/?p=1598 [...]]]>

本文是全系列中第5 / 5篇:TensorFlow 从入门到精通

TensorFlow 从入门到精通系列教程:

http://tf86.com/series/tensorflow-tutorial/

卷积层简单封装

1
2
3
4
5
6
# 池化操作
def conv2d(x, W, b, strides=1):
    # Conv2D wrapper, with bias and relu activation
    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
    x = tf.nn.bias_add(x, b)
    return tf.nn.relu(x)
TensorFlow max_pool 函数介绍:

tf.nn.max_pool(x, ksize, strides ,padding)

参数 x:
和 conv2d 的参数 x 相同,是一个 4 维张量,每一个维度分别代表 batch,in_height,in_height,in_channels。

参数 ksize:
池化核的大小,是一个 1 维长度为 4 的张量,对应参数 x 的 4 个维度上的池化大小。

参数 strides:
1 维长度为 4 的张量,对应参数 x 的 4 个维度上的步长。

参数 padding:
边缘填充方式,主要是 “SAME”, “VALID”,一般使用 “SAME”。

接下来将会使用 TensorFlow 实现以下结构的卷积神经网络:

卷积层简单封装

1
2
3
def maxpool2d(x, k=2):
    # MaxPool2D wrapper
    return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],padding='SAME')
卷积神经网络函数

超参数定义:


1
2
3
4
5
6
7
8
9
10
11
12
13
# 训练参数
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# 网络参数
#MNIST 数据维度
num_input = 784
#MNIST 列标数量
num_classes = 10
#神经元保留率
dropout = 0.75

卷积神经网络定义:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<br /># 卷积神经网络
def conv_net(x, weights, biases, dropout):
    x = tf.reshape(x, shape=[-1, 28, 28, 1])
    # 第一层卷积
    conv1 = conv2d(x, weights['wc1'], biases['bc1'])
    # 第二层池化
    conv1 = maxpool2d(conv1, k=2)

    # 第三层卷积
    conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
    # 第四层池化
    conv2 = maxpool2d(conv2, k=2)

    #全连接层
    fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
    fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
    fc1 = tf.nn.relu(fc1)
    #丢弃
    fc1 = tf.nn.dropout(fc1, dropout)

    #输出层,输出最后的结果
    out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
    return out

效果评估


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#softmax 层
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

#定义损失函数
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
    logits=logits, labels=Y))
#定义优化函数
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
#确定优化目标
train_op = optimizer.minimize(loss_op)


#获得预测正确的结果
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

训练过程输出


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Step 1, Minibatch Loss= 92463.1406, Training Accuracy= 0.117
Step 10, Minibatch Loss= 28023.7285, Training Accuracy= 0.203
Step 20, Minibatch Loss= 13119.1172, Training Accuracy= 0.508
Step 30, Minibatch Loss= 5153.5215, Training Accuracy= 0.719
Step 40, Minibatch Loss= 4394.2578, Training Accuracy= 0.750
Step 50, Minibatch Loss= 4201.6006, Training Accuracy= 0.734
Step 60, Minibatch Loss= 2271.7676, Training Accuracy= 0.820
Step 70, Minibatch Loss= 2406.0142, Training Accuracy= 0.836
Step 80, Minibatch Loss= 3353.5925, Training Accuracy= 0.836
Step 90, Minibatch Loss= 1519.4861, Training Accuracy= 0.914
Step 100, Minibatch Loss= 1908.3972, Training Accuracy= 0.883
Step 110, Minibatch Loss= 2853.9766, Training Accuracy= 0.852
Step 120, Minibatch Loss= 2722.6582, Training Accuracy= 0.844
Step 130, Minibatch Loss= 1433.3765, Training Accuracy= 0.891
Step 140, Minibatch Loss= 3010.4907, Training Accuracy= 0.859
Step 150, Minibatch Loss= 1436.4202, Training Accuracy= 0.922
Step 160, Minibatch Loss= 791.8259, Training Accuracy= 0.938
Step 170, Minibatch Loss= 596.7582, Training Accuracy= 0.930
Step 180, Minibatch Loss= 2496.4136, Training Accuracy= 0.906
Step 190, Minibatch Loss= 1081.5593, Training Accuracy= 0.914
Step 200, Minibatch Loss= 783.2731, Training Accuracy= 0.930
Optimization Finished!
Testing Accuracy: 0.925781

模型优化

经典卷积神经网络

图像分类实战项目

The CIFAR-10 dataset

https://www.cs.toronto.edu/~kriz/cifar.html

目标检测实战项目

Tensorflow Object Detection API

https://github.com/tensorflow/models/tree/master/research/object_detection

主要参考对象:

1.TensorFlow 官方介绍

Image Recognition
https://tensorflow.google.cn/tutorials/image_recognition

https://www.tensorflow.org/tutorials/deep_cnn

2.最经典论文

ImageNet Classification with Deep Convolutional Neural Networks
http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks

3.最经典课程

Convolutional Neural Networks
http://cs231n.github.io/convolutional-networks/

Deep learning
http://neuralnetworksanddeeplearning.com/chap6.html

3.Wikipedia

Convolutional neural network
https://en.wikipedia.org/wiki/Convolutional_neural_network

4.Good tutorial

Comparison of Normal Neural network

https://leonardoaraujosantos.gitbooks.io/artificial-inteligence/content/convolutional_neural_networks.html

Convolutional Neural Networks (LeNet)

http://deeplearning.net/tutorial/lenet.html#sparse-connectivity

Convolutional neural networks from scratch

http://gluon.mxnet.io/chapter04_convolutional-neural-networks/cnn-scratch.html

卷积神经网络

http://prors.readthedocs.io/zh_CN/latest/2ndPart/Chapter8.SceneClassification/ConvNet.html

ImageNet Classification with Deep Convolutional
Neural Networks

https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf

]]>
http://www.tf86.com/2018/03/27/tensorflow-step-by-step-cnn/feed/ 0
TensorFlow 卷积神经网络手写数字识别数据集介绍 http://www.tf86.com/2018/03/26/tensorflow-mnist/ http://www.tf86.com/2018/03/26/tensorflow-mnist/#respond Mon, 26 Mar 2018 14:10:32 +0000 http://tf86.com/?p=1582 [...]]]>

本文是全系列中第4 / 5篇:TensorFlow 从入门到精通

手写数字识别

接下来将会以 MNIST 数据集为例,使用卷积层和池化层,实现一个卷积神经网络来进行手写数字识别,并输出卷积和池化效果。

数据准备

  • MNIST 数据集下载

MNIST 数据集可以从 THE MNIST DATABASE of handwritten digits 的网站直接下载。
网址:http://yann.lecun.com/exdb/mnist/

train-images-idx3-ubyte.gz: 训练集图片
train-labels-idx1-ubyte.gz: 训练集列标
t10k-images-idx3-ubyte.gz: 测试集图片
t10k-labels-idx1-ubyte.gz: 测试集列标

TensorFlow 有加载 MNIST 数据库相关的模块,可以在程序运行时直接加载。

代码如下:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.pyplot as pyplot

#引入 MNIST 数据集
mnist = input_data.read_data_sets("/tmp/data/", one_hot=False)

#选取训练集中的第 1 个图像的矩阵
mnist_one=mnist.train.images[0]

#输出图片的维度,结果是:(784,)
print(mnist_one.shape)

#因为原始的数据是长度是 784 向量,需要转换成 28*28 的矩阵。
mnist_one_image=mnist_one.reshape((28,28))

#输出矩阵的维度
print(mnist_one_image.shape)

#使用 matplotlib 输出为图片
pyplot.imshow(mnist_one_image)

pyplot.show()

代码的输出依次是:
1.单个手写数字图片的维度:
(784,)

2.转化为二维矩阵之后的打印结果:
(28, 28)

3.使用 matplotlib 输出为图片

模型实现

TensorFlow conv2d 函数介绍:

tf.nn.conv2d(x, W, strides, padding=’SAME’)
针对输入的 4 维数据 x 计算 2 维卷积。

参数 x:
4 维张量,每一个维度分别是 batch,in_height,in_height,in_channels。
[batch, in_height, in_width, in_channels]

灰度图像只有 2 维来表示每一个像素的值,彩色图像每一个像素点有 3 通道的 RGB 值,所以一个彩色图片转化成张量后是 3 维的,分别是长度,宽度,颜色通道数。又因为每一次训练都是训练都是输入很多张图片,所以,多个 3 维张量组合在一起变成了 4 维张量。

参数 w:
过滤器,因为是二维卷积,所以它的维度是:

[filter_height, filter_width, in_channels, out_channels]

与参数 x 对应,前 3 个参数分别是对应 x 的 filter_height, filter_width, in_channels,最后一个参数是过滤器的输出通道数量。

参数 strides:
1 维长度为 4 的张量,对应参数 x 的 4 个维度上的步长。

参数 padding:
边缘填充方式,主要是 “SAME”, “VALID”,一般使用 “SAME”。

卷积层简单封装

1
2
3
4
5
6
# 池化操作
def conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
return tf.nn.relu(x)
TensorFlow max_pool 函数介绍:

tf.nn.max_pool(x, ksize, strides ,padding)

参数 x:
和 conv2d 的参数 x 相同,是一个 4 维张量,每一个维度分别代表 batch,in_height,in_height,in_channels。

参数 ksize:
池化核的大小,是一个 1 维长度为 4 的张量,对应参数 x 的 4 个维度上的池化大小。

参数 strides:
1 维长度为 4 的张量,对应参数 x 的 4 个维度上的步长。

参数 padding:
边缘填充方式,主要是 “SAME”, “VALID”,一般使用 “SAME”。

接下来将会使用 TensorFlow 实现以下结构的卷积神经网络:

下一篇文章,将会用 TensorFlow 实现这个卷积神经网络。

]]>
http://www.tf86.com/2018/03/26/tensorflow-mnist/feed/ 0