作为TensorFlow的底层语言,你会用C++构建深度神经网络吗?深度学习
网络
作为TensorFlow的底层语言,你会用C++构建深度神经网络吗?深度学习
python
作为TensorFlow的底层语言,你会用C++构建深度神经网络吗?深度学习
模型
作为TensorFlow的底层语言,你会用C++构建深度神经网络吗?深度学习
神经网络
作为TensorFlow的底层语言,你会用C++构建深度神经网络吗?深度学习
Tensorflow
作为TensorFlow的底层语言,你会用C++构建深度神经网络吗?深度学习
C++

目前流行的深度学习框架 TensorFlow(TensorFlow 中文官方公众号已于月初发布) 是以 C++为底层构建的,但绝大多数人都在 Python 上使用 TensorFlow 来开发自己的模型。随着 C++ API 的完善,直接使用 C++来搭建神经网络已经成为可能,本文将向你介绍一种简单的实现方法。


很多人都知道 TensorFlow 的核心是构建在 C++之上的,但是这种深度学习框架的大多数功能只在 Python API 上才方便使用。


当我写上一篇文章的时候,我的目标是仅使用 TensorFlow 中的 C++ API 和 CuDNN 来实现基本的深度神经网络(DNN)。在实践中,我意识到在这个过程中我们忽略了很多东西。


注意,使用外部操作(exotic operations)训练神经网络是不可能的,你面临的错误最有可能就是缺少梯度运算。目前我正在试图将 Python 上的梯度运算迁移到 C++上。


在本文中,我将展示如何使用 TensorFlow 在 C++ 上构建深度神经网络,并通过车龄、公里数和使用油品等条件为宝马 1 系汽车进行估价。目前,我们还没有可用的 C++ 优化器,所以你会看到训练代码看起来不那么吸引人,但是我们会在未来加入的。


本文章遵从 TensorFlow 1.4 C++ API 官方指南:https://www.tensorflow.org/api_guides/cc/guide

代码 GitHub:https://github.com/theflofly/dnn_tensorflow_cpp


安装

我们会在 C++ 中运行 TensorFlow 框架,我们需要尝试使用已编译的库,但肯定有些人会因为环境的特殊性而遇到麻烦。从头开始构建 TensorFlow 将避免这些问题,同时确保使用的是版本的 API。


首先,你需要安装 bazel 构建工具,这里有安装方法:https://docs.bazel.build/versions/master/install.html


在 OSX 上 brew 就足够了:

brew install bazel


你需要从 TensorFlow 源文件开始构建:

mkdir /path/tensorflow

cd /path/tensorflow

git clone https://github.com/tensorflow/tensorflow.git


随后你需要进行配置,如选择是否使用 GPU,你需要这样运行配置脚本:

cd /path/tensorflow

./configure


现在我们要创建接收 TensorFlow 模型代码的文件。请注意,第一次构建需要花费很长一段时间(10-15 分钟)。非核心的 C++ TF 代码在 /tensorflow/cc 中,这是我们创建模型文件的位置,我们也需要 BUILD 文件让 bazel 可以构建模型。


mkdir /path/tensorflow/model

cd /path/tensorflow/model

touch model.cc

touch BUILD


我们在 BUILD 文件中加入 bazel 指令:

load(

"//tensorflow:tensorflow.bzl"

,

"tf_cc_binary"

)

tf_cc_binary(

name =

"model"

,

srcs = [

"model.cc"

,

],

deps = [

"//tensorflow/cc:gradients"

,

"//tensorflow/cc:grad_ops"

,

"//tensorflow/cc:cc_ops"

,

"//tensorflow/cc:client_session"

,

"//tensorflow/core:tensorflow"

],

)


基本上,它会使用 model.cc 构建一个二进制文件。现在,我们可以开始编写自己的模型了。


读取数据

这些数据从法国网站 leboncoin.fr 上摘取,随后被清理和归一化,并被存储于 CSV 文件中。我们的目标是读取这些数据。经归一化的源数据被存储在 CSV 文件的第一行,我们需要使用它们重构神经网络输出的价格。所以,我们创建 data_set.h 和 data_set.cc 文件来保持代码清洁。它们从 CSV 文件中生成一个浮点型的二维数组,并用于馈送到神经网络。


data_set.h


using namespace std;

//

Meta

data used to normalize the data set.

Useful

to

// go back

and

forth between normalized data.

class

DataSetMetaData

{

friend

class

DataSet

;

private:

float mean_km;

float std_km;

float mean_age;

float std_age;

float min_price;

float max_price;

};

enum

class

Fuel

{

DIESEL,

GAZOLINE

};

class

DataSet

{

public:

//

Construct

a data set

from

the given csv file path.

DataSet

(string path) {

ReadCSVFile

(path);

}

// getters

vector& x() {

return

x_; }

vector& y() {

return

y_; }

// read the given csv file

and

complete x_

and

y_

void

ReadCSVFile

(string path);

// convert one csv line to a vector of float

vector

ReadCSVLine

(string line);

// normalize a human input using the data set metadata

initializer_list input(float km,

Fuel

fuel, float age);

// convert a price outputted by the DNN to a human price

float output(float price);

private:

DataSetMetaData

data_set_metadata;

vector x_;

vector y_;

};


data_set.cc


#include

#include

#include

#include

#include "data_set.h"

using namespace std;

void

DataSet

::

ReadCSVFile

(string path) {

ifstream file(path);

stringstream buffer;

buffer << file.rdbuf();

string line;

vector lines;

while

(getline(buffer, line,

'\n'

)) {

lines.push_back(line);

}

// the first line contains the metadata

vector metadata =

ReadCSVLine

(lines[

0

]);

data_set_metadata.mean_km = metadata[

0

];

data_set_metadata.std_km = metadata[

1

];

data_set_metadata.mean_age = metadata[

2

];

data_set_metadata.std_age = metadata[

3

];

data_set_metadata.min_price = metadata[

4

];

data_set_metadata.max_price = metadata[

5

];

// the other lines contain the features

for

each car

for

(int i =

2

; i < lines.size(); ++i) {

vector features =

ReadCSVLine

(lines[i]);

x_.insert(x_.end(), features.begin(), features.begin() +

3

);

y_.push_back(features[

3

]);

}

}

vector

DataSet

::

ReadCSVLine

(string line) {

vector line_data;

std::stringstream lineStream(line);

std::string cell;

while

(std::getline(lineStream, cell,

','

))

{

line_data.push_back(stod(cell));

}

return

line_data;

}

initializer_list

DataSet

::input(float km,

Fuel

fuel, float age) {

km = (km - data_set_metadata.mean_km) / data_set_metadata.std_km;

age = (age - data_set_metadata.mean_age) / data_set_metadata.std_age;

float f = fuel ==

Fuel

::DIESEL ? -

1.f

:

1.f

;

return

{km, f, age};

}

float

DataSet

::output(float price) {

return

price * (data_set_metadata.max_price - data_set_metadata.min_price) + data_set_metadata.min_price;

}


我们必须在 bazel BUILD 文件中添加这两个文件。


load(

"//tensorflow:tensorflow.bzl"

,

"tf_cc_binary"

)

tf_cc_binary(

name =

"model"

,

srcs = [

"model.cc"

,

"data_set.h"

,

"data_set.cc"

],

deps = [

"//tensorflow/cc:gradients"

,

"//tensorflow/cc:grad_ops"

,

"//tensorflow/cc:cc_ops"

,

"//tensorflow/cc:client_session"

,

"//tensorflow/core:tensorflow"

],

)


构建模型

第一步是读取 CSV 文件,并提取出两个张量,其中 x 是输入,y 为预期的真实结果。我们使用之前定义的 DataSet 类。


CSV 数据集下载链接:https://github.com/theflofly/dnn_tensorflow_cpp/blob/master/normalized_car_features.csv


DataSet

data_set(

"/path/normalized_car_features.csv"

);

Tensor

x_data(

DataTypeToEnum

::v(),

TensorShape

{static_cast(data_set.x().size())/

3

,

3

});

copy_n(data_set.x().begin(), data_set.x().size(),

x_data.flat().data());

Tensor

y_data(

DataTypeToEnum

::v(),

TensorShape

{static_cast(data_set.y().size()),

1

});

copy_n(data_set.y().begin(), data_set.y().size(),

y_data.flat().data());


要定义一个张量,我们需要知道它的类型和形状。在 data_set 对象中,x 数据以向量的方式保存,所以我们将尺寸缩减为 3(每个保存三个特征)。随后我们使用 std::copy_n 来从 data_set 对象中复制数据到 Tensor(一个 Eigen::TensorMap)的底层数据结构中。现在,我们有了数据和 TensorFlow 数据结构,是时候构建模型了。


你可以轻易地调试一个张量:

LOG(INFO) << x_data.

DebugString

();


C ++ API 的独特之处在于,您需要一个 Scope 对象来保持构建静态计算图的状态,并将该对象传递给每个操作。


Scope

scope =

Scope

::

NewRootScope

();


我们需要两个占位符,x 包含特征,y 代表每辆车相应的价格。


auto x =

Placeholder

(scope, DT_FLOAT);

auto y =

Placeholder

(scope, DT_FLOAT);


我们的网络有两个隐藏层,因此我们会有三个权重矩阵和三个偏置项向量。在 Python 中,它是由底层直接完成的,在 C++ 中你必须定义一个变量,随后定义一个 Assign 节点以为该变量分配一个默认值。我们使用 RandomNormal 来初始化我们的变量,这会给我们一个服从正态分布的随机值。


// weights init

auto w1 =

Variable

(scope, {

3

,

3

}, DT_FLOAT);

auto assign_w1 =

Assign

(scope, w1,

RandomNormal

(scope, {

3

,

3

}, DT_FLOAT));

auto w2 =

Variable

(scope, {

3

,

2

}, DT_FLOAT);

auto assign_w2 =

Assign

(scope, w2,

RandomNormal

(scope, {

3

,

2

}, DT_FLOAT));

auto w3 =

Variable

(scope, {

2

,

1

}, DT_FLOAT);

auto assign_w3 =

Assign

(scope, w3,

RandomNormal

(scope, {

2

,

1

}, DT_FLOAT));

// bias init

auto b1 =

Variable

(scope, {

1

,

3

}, DT_FLOAT);

auto assign_b1 =

Assign

(scope, b1,

RandomNormal

(scope, {

1

,

3

}, DT_FLOAT));

auto b2 =

Variable

(scope, {

1

,

2

}, DT_FLOAT);

auto assign_b2 =

Assign

(scope, b2,

RandomNormal

(scope, {

1

,

2

}, DT_FLOAT));

auto b3 =

Variable

(scope, {

1

,

1

}, DT_FLOAT);

auto assign_b3 =

Assign

(scope, b3,

RandomNormal

(scope, {

1

,

1

}, DT_FLOAT));


随后我们使用 Tanh 作为激活函数来构建三个层。


// layers

auto layer_1 =

Tanh

(scope,

Add

(scope,

MatMul

(scope, x, w1), b1));

auto layer_2 =

Tanh

(scope,

Add

(scope,

MatMul

(scope, layer_1, w2), b2));

auto layer_3 =

Tanh

(scope,

Add

(scope,

MatMul

(scope, layer_2, w3), b3));


加入 L2 正则化。


// regularization

auto regularization =

AddN

(scope,

initializer_list<

Input

>{L2Loss(scope, w1),

L2Loss(scope, w2),

L2Loss(scope, w3)});


最后计算损失函数,即计算预测价格和实际价格 y 之间的差异,并添加正则化到损失函数中。


// loss calculation

auto loss =

Add

(scope,

ReduceMean

(scope,

Square

(scope,

Sub

(scope, layer_3, y)), {

0

,

1

}),

Mul

(scope,

Cast

(scope,

0.01

, DT_FLOAT), regularization));


在这里,我们完成了前向传播,现在该进行反向传播了。第一步是调用函数以在前向传播操作的计算图中加入梯度运算。


// add the gradients operations to the graph

std::vector<

Output

> grad_outputs;

TF_CHECK_OK(

AddSymbolicGradients

(scope, {loss}, {w1, w2, w3, b1, b2, b3}, &grad_outputs));


所有的运算都需要计算损失函数对每一个变量的导数并添加到计算图中,我们初始化 grad_outputs 为一个空向量,它在 TensorFlow 会话打开时会将梯度传入节点,grad_outputs[0] 会提供损失函数对 w1 的导数,grad_outputs[1] 提供损失函数对 w2 的导数,这一过程会根据 {w1, w2, w3, b1,b2, b3} 的顺序,也是变量被传递到 AddSymbolicGradients 的顺序进行。

现在我们在 grad_outputs 有一系列节点,当在 TensorFlow 会话中使用时,每个节点计算损失函数对一个变量的梯度。我们需要使用它来更新变量。所以,我们在每行放一个变量,使用梯度下降这个最简单的方法来更新。


// update the weights

and

bias using gradient descent

auto apply_w1 =

ApplyGradientDescent

(scope, w1,

Cast

(scope,

0.01

, DT_FLOAT), {grad_outputs[

0

]});

auto apply_w2 =

ApplyGradientDescent

(scope, w2,

Cast

(scope,

0.01

, DT_FLOAT), {grad_outputs[

1

]});

auto apply_w3 =

ApplyGradientDescent

(scope, w3,

Cast

(scope,

0.01

, DT_FLOAT), {grad_outputs[

2

]});

auto apply_b1 =

ApplyGradientDescent

(scope, b1,

Cast

(scope,

0.01

, DT_FLOAT), {grad_outputs[

3

]});

auto apply_b2 =

ApplyGradientDescent

(scope, b2,

Cast

(scope,

0.01

, DT_FLOAT), {grad_outputs[

4

]});

auto apply_b3 =

ApplyGradientDescent

(scope, b3,

Cast

(scope,

0.01

, DT_FLOAT), {grad_outputs[

5

]});


Cast 操作实际上是学习速率的参数,在这里是 0.01。


我们神经网络的计算图已经构建完毕,现在可以打开一个会话并运行该计算图。基于 Python 的 Optimizers API 基本封装了计算和应用过程中的损失函数最小化方法。当 Optimizer API 可以接入 C++ 时我们就可以在这里使用它了。


我们初始化一个以 ClientSession 和一个以 Tensor 命名的输出向量,用来接收网络的输出。


ClientSession

session(scope);

std::vector<

Tensor

> outputs;


随后在 Python 中调用 tf.global_variables_initializer() 就可以初始化变量,因为在构建计算图时,所有变量的列表都是保留的。在 C++中,我们必须列出变量。每个 RandomNormal 输出会分配给 Assign 节点中定义的变量。


// init the weights

and

biases by running the assigns nodes once

TF_CHECK_OK(session.

Run

({assign_w1, assign_w2, assign_w3, assign_b1, assign_b2, assign_b3}, nullptr));


在这一点上,我们可以在训练数量内循环地更新参数,在我们的例子中是 5000 步。第一步是使用 loss 节点运行前向传播部分,输出是网络的损失。每 100 步我们都会记录一次损失值,损失的减少是网络成功运行的标志。随后我们必须计算梯度节点并更新变量。我们的梯度节点是 ApplyGradientDescent 节点的输入,所以运行 apply_nodes 会首先计算梯度,随后将其应用到正确的变量上。


// training steps

for

(int i =

0

; i <

5000

; ++i) {

TF_CHECK_OK(session.

Run

({{x, x_data}, {y, y_data}}, {loss}, &outputs));

if

(i %

100

==

0

) {

std::cout <<

"Loss after "

<< i <<

" steps "

<< outputs[

0

].Scalar() << std::endl;

}

// nullptr because the output

from

the run

is

useless

TF_CHECK_OK(session.

Run

({{x, x_data}, {y, y_data}}, {apply_w1, apply_w2, apply_w3, apply_b1, apply_b2, apply_b3, layer_3}, nullptr));

}


在网络训练到这种程度后,我们可以尝试预测汽车的价格了——进行推断。让我们来尝试预测一辆车龄为 7 年,里程 11 万公里,柴油发动机的宝马 1 系轿车。为了这样做我们需要运行 layer_3 节点,将汽车的数据输入 x,这是一个前向传播的步骤。因为我们之前运行了 5000 步的训练,权重已经得到了学习,所以输出的结果将不是随机的。


我们不能直接使用汽车的属性,因为我们的神经网络是从归一化属性中学习的,所以数据必须经过同样的归一化过程。DataSet 类有一个 input 方法在 CSV 读取器件处理数据集中的元数据。


// prediction using the trained neural net

TF_CHECK_OK(session.

Run

({{x, {data_set.input(

110000.f

,

Fuel

::DIESEL,

7.f

)}}}, {layer_3}, &outputs));

cout <<

"DNN output: "

<< *outputs[

0

].scalar().data() << endl;

std::cout <<

"Price predicted "

<< data_set.output(*outputs[

0

].scalar().data()) <<

" euros"

<< std::endl;


网络的输出值在 0 到 1 之间,data_set 的 output 方法还负责将数值从元数据转换回人类可读的数字。模型可以使用 bazel run -c opt //tensorflow/cc/models:model 命令来运行,如果 TensorFlow 刚刚被编译,你可以看到这样形式的输出:


Loss

after

0

steps

0.317394

Loss

after

100

steps

0.0503757

Loss

after

200

steps

0.0487724

Loss

after

300

steps

0.047366

Loss

after

400

steps

0.0460944

Loss

after

500

steps

0.0449263

Loss

after

600

steps

0.0438395

Loss

after

700

steps

0.0428183

Loss

after

800

steps

0.041851

Loss

after

900

steps

0.040929

Loss

after

1000

steps

0.0400459

Loss

after

1100

steps

0.0391964

Loss

after

1200

steps

0.0383768

Loss

after

1300

steps

0.0375839

Loss

after

1400

steps

0.0368152

Loss

after

1500

steps

0.0360687

Loss

after

1600

steps

0.0353427

Loss

after

1700

steps

0.0346358

Loss

after

1800

steps

0.0339468

Loss

after

1900

steps

0.0332748

Loss

after

2000

steps

0.0326189

Loss

after

2100

steps

0.0319783

Loss

after

2200

steps

0.0313524

Loss

after

2300

steps

0.0307407

Loss

after

2400

steps

0.0301426

Loss

after

2500

steps

0.0295577

Loss

after

2600

steps

0.0289855

Loss

after

2700

steps

0.0284258

Loss

after

2800

steps

0.0278781

Loss

after

2900

steps

0.0273422

Loss

after

3000

steps

0.0268178

Loss

after

3100

steps

0.0263046

Loss

after

3200

steps

0.0258023

Loss

after

3300

steps

0.0253108

Loss

after

3400

steps

0.0248298

Loss

after

3500

steps

0.0243591

Loss

after

3600

steps

0.0238985

Loss

after

3700

steps

0.0234478

Loss

after

3800

steps

0.0230068

Loss

after

3900

steps

0.0225755

Loss

after

4000

steps

0.0221534

Loss

after

4100

steps

0.0217407

Loss

after

4200

steps

0.0213369

Loss

after

4300

steps

0.0209421

Loss

after

4400

steps

0.020556

Loss

after

4500

steps

0.0201784

Loss

after

4600

steps

0.0198093

Loss

after

4700

steps

0.0194484

Loss

after

4800

steps

0.0190956

Loss

after

4900

steps

0.0187508

DNN output:

0.0969611

Price

predicted

13377.7

euros


这里的预测车价是 13377.7 欧元。每次预测的到的车价都不相同,甚至会介于 8000-17000 之间。这是因为我们只使用了三个属性来描述汽车,而我们的的模型架构也相对比较简单。


正如之前所说的,C++ API 的开发仍在进行中,我们希望在不久的将来,更多的功能可以加入进来。


原文链接:https://matrices.io/training-a-deep-neural-network-using-only-tensorflow-c/


欢迎加入本站公开兴趣群

商业智能与数据分析群

兴趣范围包括各种让数据产生价值的办法,实际应用案例分享与讨论,分析工具,ETL工具,数据仓库,数据挖掘工具,报表系统等全方位知识

QQ群:418451831

tags: #160,scope,data,after,steps,set,lt,tensorflow,metadata,cc,FLOAT,DT,auto,outputs,std
分页:12
转载请注明
本文标题:作为TensorFlow的底层语言,你会用C++构建深度神经网络吗?深度学习
本站链接:http://www.codesec.net/view/570386.html
分享请点击:


1.凡CodeSecTeam转载的文章,均出自其它媒体或其他官网介绍,目的在于传递更多的信息,并不代表本站赞同其观点和其真实性负责;
2.转载的文章仅代表原创作者观点,与本站无关。其原创性以及文中陈述文字和内容未经本站证实,本站对该文以及其中全部或者部分内容、文字的真实性、完整性、及时性,不作出任何保证或承若;
3.如本站转载稿涉及版权等问题,请作者及时联系本站,我们会及时处理。
登录后可拥有收藏文章、关注作者等权限...
技术大类 技术大类 | 商业智能 | 评论(0) | 阅读(205)