TensorFlow - 使用TensorFlow开发程序编译环境配置

TensorFlow - 使用TensorFlow开发程序编译环境配置

flyfish

环境：Win7,Microsoft Visual Studio 2017 Community，平台x64

语言：C++

编译器配置如下

C\C++-》 常规-》附加包含目录

E:\lib\tensorflow

E:\lib\tensorflow\tensorflow\contrib\cmake\build

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\zlib_archive

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\gif_archive\giflib-5.1.4

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\png_archive

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\jpeg_archive

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\eigen_archive

E:\lib\tensorflow\third_party\eigen3

E:\lib\tensorflow\tensorflow\contrib\cmake\build\gemmlowp\src\gemmlowp

E:\lib\tensorflow\tensorflow\contrib\cmake\build\jsoncpp\src\jsoncpp

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\farmhash_archive

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\farmhash_archive\util

E:\lib\tensorflow\tensorflow\contrib\cmake\build\external\highwayhash

E:\lib\tensorflow\tensorflow\contrib\cmake\build\protobuf\src\protobuf\src

E:\lib\tensorflow\tensorflow\contrib\cmake\build\grpc\src\grpc\include

C\C++-》预处理器-》预处理器定义

WIN32

_WINDOWS

_DEBUG

EIGEN_AVOID_STL_ARRAY

NOMINMAX

_WIN32_WINNT=0x0A00

LANG_CXX11

COMPILER_MSVC

OS_WIN

_MBCS

WIN64

WIN32_LEAN_AND_MEAN

NOGDI

PLATFORM_WINDOWS

TENSORFLOW_USE_EIGEN_THREADPOOL

EIGEN_HAS_C99_MATH

TF_COMPILE_LIBRARY

CMAKE_INTDIR=”Debug”

链接器-》输入-》附加依赖项

有些lib是windows自己增加的

kernel32.lib

user32.lib

gdi32.lib

winspool.lib

shell32.lib

ole32.lib

oleaut32.lib

uuid.lib

comdlg32.lib

advapi32.lib

Debug\tf_protos_cc.lib

zlib\install\lib\zlibstaticd.lib

gif\install\lib\giflib.lib

png\install\lib\libpng12_staticd.lib

jpeg\install\lib\libjpeg.lib

jsoncpp\src\jsoncpp\src\lib_json$(Configuration)\jsoncpp.lib

farmhash\install\lib\farmhash.lib

fft2d\src\lib\fft2d.lib

highwayhash\install\lib\highwayhash.lib

protobuf\src\protobuf$(Configuration)\libprotobufd.lib

grpc\src\grpc$(Configuration)\grpc++_unsecure.lib

grpc\src\grpc$(Configuration)\grpc_unsecure.lib

grpc\src\grpc$(Configuration)\gpr.lib

wsock32.lib

ws2_32.lib

shlwapi.lib

添加引用如下



使用TensorFlow自带代码示例

// MyTFTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <cstdio>
#include <functional>
#include <string>
#include <vector>

#include "tensorflow/cc/ops/standard_ops.h"
#include "tensorflow/core/framework/graph.pb.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/graph/default_device.h"
#include "tensorflow/core/graph/graph_def_builder.h"
#include "tensorflow/core/lib/core/threadpool.h"
#include "tensorflow/core/lib/strings/stringprintf.h"
#include "tensorflow/core/platform/init_main.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/types.h"
#include "tensorflow/core/public/session.h"

using tensorflow::string;
using tensorflow::int32;

namespace tensorflow {
namespace example {

struct Options {
int num_concurrent_sessions = 1;   // The number of concurrent sessions
int num_concurrent_steps = 10;     // The number of concurrent steps
int num_iterations = 100;          // Each step repeats this many times
bool use_gpu = false;              // Whether to use gpu in the training
};

// A = [3 2; -1 0]; x = rand(2, 1);
// We want to compute the largest eigenvalue for A.
// repeat x = y / y.norm(); y = A * x; end
GraphDef CreateGraphDef() {
// TODO(jeff,opensource): This should really be a more interesting
// computation.  Maybe turn this into an mnist model instead?
Scope root = Scope::NewRootScope();
using namespace ::tensorflow::ops;  // NOLINT(build/namespaces)

// A = [3 2; -1 0].  Using Const<float> means the result will be a
// float tensor even though the initializer has integers.
auto a = Const<float>(root, { { 3, 2 },{ -1, 0 } });

// x = [1.0; 1.0]
auto x = Const(root.WithOpName("x"), { { 1.f },{ 1.f } });

// y = A * x
auto y = MatMul(root.WithOpName("y"), a, x);

// y2 = y.^2
auto y2 = Square(root, y);

// y2_sum = sum(y2).  Note that you can pass constants directly as
// inputs.  Sum() will automatically create a Const node to hold the
// 0 value.
auto y2_sum = Sum(root, y2, 0);

// y_norm = sqrt(y2_sum)
auto y_norm = Sqrt(root, y2_sum);

// y_normalized = y ./ y_norm
Div(root.WithOpName("y_normalized"), y, y_norm);

GraphDef def;
TF_CHECK_OK(root.ToGraphDef(&def));

return def;
}

string DebugString(const Tensor& x, const Tensor& y) {
CHECK_EQ(x.NumElements(), 2);
CHECK_EQ(y.NumElements(), 2);
auto x_flat = x.flat<float>();
auto y_flat = y.flat<float>();
// Compute an estimate of the eigenvalue via
//      (x' A x) / (x' x) = (x' y) / (x' x)
// and exploit the fact that x' x = 1 by assumption
Eigen::Tensor<float, 0, Eigen::RowMajor> lambda = (x_flat * y_flat).sum();
return strings::Printf("lambda = %8.6f x = [%8.6f %8.6f] y = [%8.6f %8.6f]",
lambda(), x_flat(0), x_flat(1), y_flat(0), y_flat(1));
}

void ConcurrentSteps(const Options* opts, int session_index) {
// Creates a session.
SessionOptions options;
std::unique_ptr<Session> session(NewSession(options));
GraphDef def = CreateGraphDef();
if (options.target.empty()) {
graph::SetDefaultDevice(opts->use_gpu ? "/gpu:0" : "/cpu:0", &def);
}

TF_CHECK_OK(session->Create(def));

// Spawn M threads for M concurrent steps.
const int M = opts->num_concurrent_steps;
std::unique_ptr<thread::ThreadPool> step_threads(
new thread::ThreadPool(Env::Default(), "trainer", M));

for (int step = 0; step < M; ++step) {
step_threads->Schedule([&session, opts, session_index, step]() {
// Randomly initialize the input.
Tensor x(DT_FLOAT, TensorShape({ 2, 1 }));
auto x_flat = x.flat<float>();
x_flat.setRandom();
Eigen::Tensor<float, 0, Eigen::RowMajor> inv_norm =
x_flat.square().sum().sqrt().inverse();
x_flat = x_flat * inv_norm();

// Iterations.
std::vector<Tensor> outputs;
for (int iter = 0; iter < opts->num_iterations; ++iter) {
outputs.clear();
TF_CHECK_OK(
session->Run({ { "x", x } }, { "y:0", "y_normalized:0" }, {}, &outputs));
CHECK_EQ(size_t{ 2 }, outputs.size());

const Tensor& y = outputs[0];
const Tensor& y_norm = outputs[1];
// Print out lambda, x, and y.
std::printf("%06d/%06d %s\n", session_index, step,
DebugString(x, y).c_str());
// Copies y_normalized to x.
x = y_norm;
}
});
}

// Delete the threadpool, thus waiting for all threads to complete.
step_threads.reset(nullptr);
TF_CHECK_OK(session->Close());
}

void ConcurrentSessions(const Options& opts) {
// Spawn N threads for N concurrent sessions.
const int N = opts.num_concurrent_sessions;

// At the moment our Session implementation only allows
// one concurrently computing Session on GPU.
CHECK_EQ(1, N) << "Currently can only have one concurrent session.";

thread::ThreadPool session_threads(Env::Default(), "trainer", N);
for (int i = 0; i < N; ++i) {
session_threads.Schedule(std::bind(&ConcurrentSteps, &opts, i));
}
}

}  // end namespace example
}  // end namespace tensorflow

namespace {

bool ParseInt32Flag(tensorflow::StringPiece arg, tensorflow::StringPiece flag,
int32* dst) {
if (arg.Consume(flag) && arg.Consume("=")) {
char extra;
return (sscanf(arg.data(), "%d%c", dst, &extra) == 1);
}

return false;
}

bool ParseBoolFlag(tensorflow::StringPiece arg, tensorflow::StringPiece flag,
bool* dst) {
if (arg.Consume(flag)) {
if (arg.empty()) {
*dst = true;
return true;
}

if (arg == "=true") {
*dst = true;
return true;
}
else if (arg == "=false") {
*dst = false;
return true;
}
}

return false;
}

}  // namespace

int main(int argc, char* argv[]) {
tensorflow::example::Options opts;
std::vector<char*> unknown_flags;
for (int i = 1; i < argc; ++i) {
if (string(argv[i]) == "--") {
while (i < argc) {
unknown_flags.push_back(argv[i]);
++i;
}
break;
}

if (ParseInt32Flag(argv[i], "--num_concurrent_sessions",
&opts.num_concurrent_sessions) ||
ParseInt32Flag(argv[i], "--num_concurrent_steps",
&opts.num_concurrent_steps) ||
ParseInt32Flag(argv[i], "--num_iterations", &opts.num_iterations) ||
ParseBoolFlag(argv[i], "--use_gpu", &opts.use_gpu)) {
continue;
}

fprintf(stderr, "Unknown flag: %s\n", argv[i]);
return -1;
}

// Passthrough any unknown flags.
int dst = 1;  // Skip argv[0]
for (char* f : unknown_flags) {
argv[dst++] = f;
}
argv[dst++] = nullptr;
argc = static_cast<int>(unknown_flags.size() + 1);
tensorflow::port::InitMain(argv[0], &argc, &argv);
tensorflow::example::ConcurrentSessions(opts);
}

代码执行