# 十七、R 中的 TensorFlow 和 Keras
R 是一个开源平台，包括用于统计计算的环境和语言。它还有一个桌面和基于 Web 的 IDE，称为 R Studio。有关 R 的更多信息，[请访问此链接](https://www.r-project.org/)。 R 通过提供以下 R 包提供对 TensorFlow 和 Keras 的支持：
* `tensorflow`包提供对 TF 核心 API 的支持
* `tfestimators`包提供对 TF 估计器 API 的支持
* `keras`包提供对 Keras API 的支持
* `tfruns`包用于 TensorBoard 风格的模型和训练类可视化
在本章中，我们将学习如何在 R 中使用 TensorFlow，并将涵盖以下主题：
* 在 R 中安装 TensorFlow 和 Keras 包
* R 中的 TF 核心 API
* R 中的 TF 估计器 API
* R 中的 Keras API
* R 中的 TensorBoard
* R 中的`tfruns`包
# 在 R 中安装 TensorFlow 和 Keras 包
要在 R 中安装支持 TensorFlow 和 Keras 的三个 R 包，请在 R 中执行以下命令。
1. 首先，安装`devtools`：
```r
install.packages("devtools")
```
1. 安装`tensorflow`和`tfestimators`包：
```r
devtools::install_github("rstudio/tensorflow")
devtools::install_github("rstudio/tfestimators")
```
1. 加载`tensorflow`库并安装所需的功能：
```r
library(tensorflow)
install_tensorflow()
```
1. 默认情况下，安装功能会创建虚拟环境并在虚拟环境中安装`tensorflow `包。
有四种可用的安装方法，可以使用`method`参数指定：
| | |
| --- | --- |
| `auto` | 自动选择当前平台的默认值 |
| `virtualenv` | 安装到位于`~/.virtualenvs/r-tensorflow`的虚拟环境中 |
| `conda` | 安装到名为`r-tensorflow`的 Anaconda Python 环境中 |
| `system` | 安装到系统 Python 环境中 |
1. 默认情况下，安装功能会安装仅限 CPU 的 TensorFlow 版本。要安装 GPU 版本，请使用版本参数：
| | |
| --- | --- |
| `gpu` | 安装`tensorflow-gpu` |
| `nightly` | 安装每晚 CPU 的版本 |
| `nightly-gpu` | 安装每晚 GPU 构建 |
| `n.n.n` | 安装特定版本，例如 1.3.0 |
| `n.n.n-gpu` | 安装特定版本的 GPU 版本，例如 1.3.0 |
如果您希望 TensorFlow 库使用特定版本的 Python，请使用以下函数或设置`TENSORFLOW_PYTHON`环境变量：
* `use_python('/usr/bin/python2')`
* `use_virtualenv('~/venv')`
* `use_condaenv('conda-env')`
* `Sys.setenv(TENSORFLOW_PYTHON='/usr/bin/python2')`
We installed TensorFLow in R on Ubuntu 16.04 using the following command:
`install_tensorflow(version="gpu")
`Note that the installation does not support Python 3 at the time of writing this book.
1. 安装 Keras 包：
```r
devtools::install_github("rstudio/keras")
```
1. 在虚拟环境中安装 Keras：
```r
library(keras)
install_keras()
```
1. 要安装 GPU 版本，请使用：
```r
install_keras(tensorflow = "gpu")
```
1. 安装`tfruns`包：
```r
devtools::install_github("rstudio/tfruns")
```
# R 中的 TF 核心 API
我们在第 1 章中了解了 TensorFlow 核心 API。在 R 中，该 API 使用`tensorflow` R 包实现。
作为一个例子，我们提供了 MLP 模型的演练，[用于在此链接中对来自 MNIST 数据集的手写数字进行分类](https://tensorflow.rstudio.com/tensorflow/articles/examples/mnist_softmax.html)。
您可以按照 Jupyter R 笔记本中的代码`ch-17a_TFCore_in_R`。
1. 首先，加载库：
```r
library(tensorflow)
```
1. 定义超参数：
```r
batch_size <- 128
num_classes <- 10
steps <- 1000
```
1. 准备数据：
```r
datasets <- tf$contrib$learn$datasets
mnist <- datasets$mnist$read_data_sets("MNIST-data", one_hot = TRUE)
```
数据从 TensorFlow 数据集库加载，并已标准化为`[0, 1]`范围。
1. 定义模型：
```r
# Create the model
x <- tf$placeholder(tf$float32, shape(NULL, 784L))
W <- tf$Variable(tf$zeros(shape(784L, num_classes)))
b <- tf$Variable(tf$zeros(shape(num_classes)))
y <- tf$nn$softmax(tf$matmul(x, W) + b)
# Define loss and optimizer
y_ <- tf$placeholder(tf$float32, shape(NULL, num_classes))
cross_entropy <- tf$reduce_mean(-tf$reduce_sum(y_ * log(y), reduction_indices=1L))
train_step <- tf$train$GradientDescentOptimizer(0.5)$minimize(cross_entropy)
```
1. 训练模型：
```r
# Create session and initialize variables
sess <- tf$Session()
sess$run(tf$global_variables_initializer())
# Train
for (i in 1:steps) {
batches <- mnist$train$next_batch(batch_size)
batch_xs <- batches[[1]]
batch_ys <- batches[[2]]
sess$run(train_step,
feed_dict = dict(x = batch_xs, y_ = batch_ys))
}
```
1. 评估模型：
```r
correct_prediction <- tf$equal(tf$argmax(y, 1L), tf$argmax(y_, 1L))
accuracy <- tf$reduce_mean(tf$cast(correct_prediction, tf$float32))
score <-sess$run(accuracy,
feed_dict = dict(x = mnist$test$images,
y_ = mnist$test$labels))
cat('Test accuracy:', score, '\n')
```
输出如下：
```r
Test accuracy: 0.9185
```
太酷了！
[通过此链接查找 R 中 TF 核心的更多示例](https://tensorflow.rstudio.com/tensorflow/articles/examples/)。
[有关`tensorflow` R 包的更多文档可以在此链接中找到](https://tensorflow.rstudio.com/tensorflow/reference/)。
# R 中的 TF 估计器 API
我们在第 2 章中了解了 TensorFlow 估计器 API。在 R 中，此 API 使用`tfestimator` R 包实现。
例如，我们提供了 MLP 模型的演练，[用于在此链接中对来自 MNIST 数据集的手写数字进行分类](https://tensorflow.rstudio.com/tfestimators/articles/examples/mnist.html)。
您可以按照 Jupyter R 笔记本中的代码`ch-17b_TFE_Ttimator_in_R`。
1. 首先，加载库：
```r
library(tensorflow)
library(tfestimators)
```
1. 定义超参数：
```r
batch_size <- 128
n_classes <- 10
n_steps <- 100
```
1. 准备数据：
```r
# initialize data directory
data_dir <- "~/datasets/mnist"
dir.create(data_dir, recursive = TRUE, showWarnings = FALSE)
# download the MNIST data sets, and read them into R
sources <- list(
train = list(
x = "https://storage.googleapis.com/cvdf-datasets/mnist/train-images-idx3-ubyte.gz",
y = "https://storage.googleapis.com/cvdf-datasets/mnist/train-labels-idx1-ubyte.gz"
),
test = list(
x = "https://storage.googleapis.com/cvdf-datasets/mnist/t10k-images-idx3-ubyte.gz",
y = "https://storage.googleapis.com/cvdf-datasets/mnist/t10k-labels-idx1-ubyte.gz"
)
)
# read an MNIST file (encoded in IDX format)
read_idx <- function(file) {
# create binary connection to file
conn <- gzfile(file, open = "rb")
on.exit(close(conn), add = TRUE)
# read the magic number as sequence of 4 bytes
magic <- readBin(conn, what="raw", n=4, endian="big")
ndims <- as.integer(magic[[4]])
# read the dimensions (32-bit integers)
dims <- readBin(conn,what="integer",n=ndims,endian="big")
# read the rest in as a raw vector
data <- readBin(conn,what="raw",n=prod(dims),endian="big")
# convert to an integer vecto
converted <- as.integer(data)
# return plain vector for 1-dim array
if (length(dims) == 1)
return(converted)
# wrap 3D data into matrix
matrix(converted,nrow=dims[1],ncol=prod(dims[-1]),byrow=TRUE)
}
mnist <- rapply(sources,classes="character",how ="list",function(url) {
# download + extract the file at the URL
target <- file.path(data_dir, basename(url))
if (!file.exists(target))
download.file(url, target)
# read the IDX file
read_idx(target)
})
# convert training data intensities to 0-1 range
mnist$train$x <- mnist$train$x / 255
mnist$test$x <- mnist$test$x / 255
```
从下载的 gzip 文件中读取数据，然后归一化以落入`[0, 1]`范围。
1. 定义模型：
```r
# construct a linear classifier
classifier <- linear_classifier(
feature_columns = feature_columns(
column_numeric("x", shape = shape(784L))
),
n_classes = n_classes # 10 digits
)
# construct an input function generator
mnist_input_fn <- function(data, ...) {
input_fn(
data,
response = "y",
features = "x",
batch_size = batch_size,
...
)
}
```
1. 训练模型：
```r
train(classifier,input_fn=mnist_input_fn(mnist$train),steps=n_steps)
```
1. 评估模型：
```r
evaluate(classifier,input_fn=mnist_input_fn(mnist$test),steps=200)
```
输出如下：
```r
Evaluation completed after 79 steps but 200 steps was specified
```
| average_loss | 损失 | global_step | 准确率 |
| --- | --- | --- | --- |
| 0.35656 | 45.13418 | 100 | 0.9057 |
太酷!!
[通过此链接查找 R 中 TF 估计器的更多示例](https://tensorflow.rstudio.com/tfestimators/articles/examples/)。
[有关`tensorflow` R 包的更多文档可以在此链接中找到](https://tensorflow.rstudio.com/tfestimators/reference/)
# R 中的 Keras API
我们在第 3 章中了解了 Keras API。在 R 中，此 API 使用`keras` R 包实现。`keras` R 包实现了 Keras Python 接口的大部分功能，包括顺序 API 和函数式 API。
作为示例，我们提供了 MLP 模型的演练，[用于在此链接中对来自 MNIST 数据集的手写数字进行分类](https://keras.rstudio.com/articles/examples/mnist_mlp.html)。
您可以按照 Jupyter R 笔记本中的代码`ch-17c_Keras_in_R`。
1. 首先，加载库：
```r
library(keras)
```
1. 定义超参数：
```r
batch_size <- 128
num_classes <- 10
epochs <- 30
```
1. 准备数据：
```r
# The data, shuffled and split between train and test sets
c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_mnist()
x_train <- array_reshape(x_train, c(nrow(x_train), 784))
x_test <- array_reshape(x_test, c(nrow(x_test), 784))
# Transform RGB values into [0,1] range
x_train <- x_train / 255
x_test <- x_test / 255
cat(nrow(x_train), 'train samples\n')
cat(nrow(x_test), 'test samples\n')
# Convert class vectors to binary class matrices
y_train <- to_categorical(y_train, num_classes)
y_test <- to_categorical(y_test, num_classes)
```
注释是不言自明的：数据从 Keras 数据集库加载，然后转换为 2D 数组并归一化为`[0, 1]`范围。
1. 定义模型：
```r
model <- keras_model_sequential()
model %>%
layer_dense(units=256,activation='relu',input_shape=c(784)) %>%
layer_dropout(rate = 0.4) %>%
layer_dense(units = 128, activation = 'relu') %>%
layer_dropout(rate = 0.3) %>%
layer_dense(units = 10, activation = 'softmax')
summary(model)
model %>% compile(
loss = 'categorical_crossentropy',
optimizer = optimizer_rmsprop(),
metrics = c('accuracy')
)
```
1. 定义和编译顺序模型。我们得到的模型定义如下：
```r
_____________________________________________________
Layer (type) Output Shape Param #
=====================================================
dense_26 (Dense) (None, 256) 200960
_____________________________________________________
dropout_14 (Dropout) (None, 256) 0
_____________________________________________________
dense_27 (Dense) (None, 128) 32896
_____________________________________________________
dropout_15 (Dropout) (None, 128) 0
_____________________________________________________
dense_28 (Dense) (None, 10) 1290
=====================================================
Total params: 235,146
Trainable params: 235,146
Non-trainable params: 0
```
1. 训练模型：
```r
history <- model %>% fit(
x_train, y_train,
batch_size = batch_size,
epochs = epochs,
verbose = 1,
validation_split = 0.2
)
plot(history)
```
拟合函数的输出存储在历史对象中，其包含来自训练周期的损失和度量值。绘制历史对象中的数据，结果如下：
Training and Validation Accuracy (y-axis) in Epochs (x-axis)
1. 评估模型：
```r
score <- model %>% evaluate(
x_test, y_test,
verbose = 0
)
# Output metrics
cat('Test loss:', score[[1]], '\n')
cat('Test accuracy:', score[[2]], '\n')
```
输出如下：
```r
Test loss: 0.1128517
Test accuracy: 0.9816
```
太酷!!
[在此链接中查找更多关于 R 中的 Keras 的示例](https://keras.rstudio.com/articles/examples/index.html)。
[有关 Keras R 包的更多文档可在此链接中找到](https://keras.rstudio.com/reference/index.html)。
# R 中的 TensorBoard
您可以按照 Jupyter R 笔记本中的代码`ch-17d_TensorBoard_in_R`。
您可以使用`tensorboard()`函数查看 TensorBoard，如下所示：
```r
tensorboard('logs')
```
这里，`'logs'`是应该创建 TensorBoard 日志的文件夹。
数据将显示为执行周期并记录数据。在 R 中，收集 TensorBoard 的数据取决于所使用的包：
* 如果您使用的是`tensorflow`包，请将`tf$summary$scalar`操作附加到图中
* 如果您使用的是`tfestimators`包，则 TensorBoard 数据会自动写入创建估计器时指定的`model_dir`参数
* 如果您正在使用`keras`包，则必须在使用`fit()`函数训练模型时包含`callback_tensorboard()`函数
我们修改了之前提供的 Keras 示例中的训练，如下所示：
```r
# Training the model --------
tensorboard("logs")
history <- model %>% fit(
x_train, y_train,
batch_size = batch_size,
epochs = epochs,
verbose = 1,
validation_split = 0.2,
callbacks = callback_tensorboard("logs")
)
```
当我们执行笔记本时，我们获得了训练单元的以下输出：
```r
Started TensorBoard at http://127.0.0.1:4233
```
当我们点击链接时，我们会看到在 TensorBoard 中绘制的标量：
TensorBoad Visualization of Plots
单击 Graphs 选项卡，我们在 TensorBoard 中看到计算图：
TensorBoard 计算图的可视化有关 R 中 TensorBoard 的更多文档，[请访问此链接](https://tensorflow.rstudio.com/tools/tensorboard.html)。
# R 中的`tfruns`包
您可以按照 Jupyter R 笔记本中的代码`ch-17d_TensorBoard_in_R`。
`tfruns`包是 R 中提供的非常有用的工具，有助于跟踪多次运行以训练模型。对于使用`keras` `tfestimators`包在 R 中构建的模型，`tfruns`包自动捕获运行数据。使用`tfruns`非常简单易行。只需在 R 文件中创建代码，然后使用`training_run()`函数执行该文件。例如，如果你有一个`mnist_model.R `文件 ，那么在交互式 R 控制台中使用`training_run()`函数执行它，如下所示：
```r
library(tfruns)
training_run('mnist_model.R')
```
训练完成后，将自动显示显示运行摘要的窗口。我们从[`tfruns` GitHub 仓库](https://github.com/rstudio/tfruns/blob/master/inst/examples/mnist_mlp/mnist_mlp)获得的[`mnist_mlp.R`](https://github.com/rstudio/tfruns/blob/master/inst/examples/mnist_mlp/mnist_mlp.R)窗口中获得以下输出。
tfruns visualization of the model run
在“查看器”窗口中，输出选项卡包含以下图：
tfruns visualization of the accuracy and loss values
`tfruns`包将一个插件安装到 RStudio，也可以从`Addins`菜单选项访问。该包还允许您比较多个运行并将运行报告发布到 RPub 或 RStudio Connect。您还可以选择在本地保存报告。
有关 R 中`tfruns`包的更多文档，请访问以下链接：
<https://tensorflow.rstudio.com/tools/tfruns/reference/>
<https://tensorflow.rstudio.com/tools/tfruns/articles/overview.html>.
# 总结
在本章中，我们学习了如何在 R 中使用 TensorFlow 核心，TensorFlow 估计器和 Keras 包来构建和训练机器学习模型。我们提供了来自 RStudio 的 MNIST 示例的演练，并提供了有关 TensorFlow 和 Keras R 包的进一步文档的链接。我们还学习了如何使用 R 中的可视化工具 TensorBoard。我们还介绍了一个来自 R Studio 的新工具`tfruns`，它允许您为多次运行创建报告，分析和比较它们，并在本地保存或发布它们。
直接在 R 中工作的能力很有用，因为大量的生产数据科学和机器学习代码是使用 R 编写的，现在您可以将 TensorFlow 集成到相同的代码库中并在 R 环境中运行它。
在下一章中，我们将学习一些用于调试构建和训练 TensorFlow 模型的代码的技术。
- TensorFlow 1.x 深度学习秘籍
- 零、前言
- 一、TensorFlow 简介
- 二、回归
- 三、神经网络：感知器
- 四、卷积神经网络
- 五、高级卷积神经网络
- 六、循环神经网络
- 七、无监督学习
- 八、自编码器
- 九、强化学习
- 十、移动计算
- 十一、生成模型和 CapsNet
- 十二、分布式 TensorFlow 和云深度学习
- 十三、AutoML 和学习如何学习（元学习）
- 十四、TensorFlow 处理单元
- 使用 TensorFlow 构建机器学习项目中文版
- 一、探索和转换数据
- 二、聚类
- 三、线性回归
- 四、逻辑回归
- 五、简单的前馈神经网络
- 六、卷积神经网络
- 七、循环神经网络和 LSTM
- 八、深度神经网络
- 九、大规模运行模型 -- GPU 和服务
- 十、库安装和其他提示
- TensorFlow 深度学习中文第二版
- 一、人工神经网络
- 二、TensorFlow v1.6 的新功能是什么？
- 三、实现前馈神经网络
- 四、CNN 实战
- 五、使用 TensorFlow 实现自编码器
- 六、RNN 和梯度消失或爆炸问题
- 七、TensorFlow GPU 配置
- 八、TFLearn
- 九、使用协同过滤的电影推荐
- 十、OpenAI Gym
- TensorFlow 深度学习实战指南中文版
- 一、入门
- 二、深度神经网络
- 三、卷积神经网络
- 四、循环神经网络介绍
- 五、总结
- 精通 TensorFlow 1.x
- 一、TensorFlow 101
- 二、TensorFlow 的高级库
- 三、Keras 101
- 四、TensorFlow 中的经典机器学习
- 五、TensorFlow 和 Keras 中的神经网络和 MLP
- 六、TensorFlow 和 Keras 中的 RNN
- 七、TensorFlow 和 Keras 中的用于时间序列数据的 RNN
- 八、TensorFlow 和 Keras 中的用于文本数据的 RNN
- 九、TensorFlow 和 Keras 中的 CNN
- 十、TensorFlow 和 Keras 中的自编码器
- 十一、TF 服务：生产中的 TensorFlow 模型
- 十二、迁移学习和预训练模型
- 十三、深度强化学习
- 十四、生成对抗网络
- 十五、TensorFlow 集群的分布式模型
- 十六、移动和嵌入式平台上的 TensorFlow 模型
- 十七、R 中的 TensorFlow 和 Keras
- 十八、调试 TensorFlow 模型
- 十九、张量处理单元
- TensorFlow 机器学习秘籍中文第二版
- 一、TensorFlow 入门
- 二、TensorFlow 的方式
- 三、线性回归
- 四、支持向量机
- 五、最近邻方法
- 六、神经网络
- 七、自然语言处理
- 八、卷积神经网络
- 九、循环神经网络
- 十、将 TensorFlow 投入生产
- 十一、更多 TensorFlow
- 与 TensorFlow 的初次接触
- 前言
- 1. TensorFlow 基础知识
- 2. TensorFlow 中的线性回归
- 3. TensorFlow 中的聚类
- 4. TensorFlow 中的单层神经网络
- 5. TensorFlow 中的多层神经网络
- 6. 并行
- 后记
- TensorFlow 学习指南
- 一、基础
- 二、线性模型
- 三、学习
- 四、分布式
- TensorFlow Rager 教程
- 一、如何使用 TensorFlow Eager 构建简单的神经网络
- 二、在 Eager 模式中使用指标
- 三、如何保存和恢复训练模型
- 四、文本序列到 TFRecords
- 五、如何将原始图片数据转换为 TFRecords
- 六、如何使用 TensorFlow Eager 从 TFRecords 批量读取数据
- 七、使用 TensorFlow Eager 构建用于情感识别的卷积神经网络（CNN）
- 八、用于 TensorFlow Eager 序列分类的动态循坏神经网络
- 九、用于 TensorFlow Eager 时间序列回归的递归神经网络
- TensorFlow 高效编程
- 图嵌入综述：问题，技术与应用
- 一、引言
- 三、图嵌入的问题设定
- 四、图嵌入技术
- 基于边重构的优化问题
- 应用
- 基于深度学习的推荐系统：综述和新视角
- 引言
- 基于深度学习的推荐：最先进的技术
- 基于卷积神经网络的推荐
- 关于卷积神经网络我们理解了什么
- 第1章概论
- 第2章多层网络
- 2.1.4生成对抗网络
- 2.2.1最近ConvNets演变中的关键架构
- 2.2.2走向ConvNet不变性
- 2.3时空卷积网络
- 第3章了解ConvNets构建块
- 3.2整改
- 3.3规范化
- 3.4汇集
- 第四章现状
- 4.2打开问题
- 参考
- 机器学习超级复习笔记
- Python 迁移学习实用指南
- 零、前言
- 一、机器学习基础
- 二、深度学习基础
- 三、了解深度学习架构
- 四、迁移学习基础
- 五、释放迁移学习的力量
- 六、图像识别与分类
- 七、文本文件分类
- 八、音频事件识别与分类
- 九、DeepDream
- 十、自动图像字幕生成器
- 十一、图像着色
- 面向计算机视觉的深度学习
- 零、前言
- 一、入门
- 二、图像分类
- 三、图像检索
- 四、对象检测
- 五、语义分割
- 六、相似性学习
- 七、图像字幕
- 八、生成模型
- 九、视频分类
- 十、部署
- 深度学习快速参考
- 零、前言
- 一、深度学习的基础
- 二、使用深度学习解决回归问题
- 三、使用 TensorBoard 监控网络训练
- 四、使用深度学习解决二分类问题
- 五、使用 Keras 解决多分类问题
- 六、超参数优化
- 七、从头开始训练 CNN
- 八、将预训练的 CNN 用于迁移学习
- 九、从头开始训练 RNN
- 十、使用词嵌入从头开始训练 LSTM
- 十一、训练 Seq2Seq 模型
- 十二、深度强化学习
- 十三、生成对抗网络
- TensorFlow 2.0 快速入门指南
- 零、前言
- 第 1 部分：TensorFlow 2.00 Alpha 简介
- 一、TensorFlow 2 简介
- 二、Keras：TensorFlow 2 的高级 API
- 三、TensorFlow 2 和 ANN 技术
- 第 2 部分：TensorFlow 2.00 Alpha 中的监督和无监督学习
- 四、TensorFlow 2 和监督机器学习
- 五、TensorFlow 2 和无监督学习
- 第 3 部分：TensorFlow 2.00 Alpha 的神经网络应用
- 六、使用 TensorFlow 2 识别图像
- 七、TensorFlow 2 和神经风格迁移
- 八、TensorFlow 2 和循环神经网络
- 九、TensorFlow 估计器和 TensorFlow HUB
- 十、从 tf1.12 转换为 tf2
- TensorFlow 入门
- 零、前言
- 一、TensorFlow 基本概念
- 二、TensorFlow 数学运算
- 三、机器学习入门
- 四、神经网络简介
- 五、深度学习
- 六、TensorFlow GPU 编程和服务
- TensorFlow 卷积神经网络实用指南
- 零、前言
- 一、TensorFlow 的设置和介绍
- 二、深度学习和卷积神经网络
- 三、TensorFlow 中的图像分类
- 四、目标检测与分割
- 五、VGG，Inception，ResNet 和 MobileNets
- 六、自编码器，变分自编码器和生成对抗网络
- 七、迁移学习
- 八、机器学习最佳实践和故障排除
- 九、大规模训练
- 十、参考文献