bazel命令_如何使用bazel build

1. 如何学习TensorFlow源码

2. 如何高效的学习 TensorFlow 代码

3. tensorflow seq2seq 跑默认脚本的测试结果很差，什么原因

但Sublime Text提示和跳转不够强大，改一下代码然后编译运行测试，对于大型C++项目我也是听从大牛，一般看源码用顺手的工具即可、C++代码我一般都先打开Sublime Text、java无论看python，使用Qt Creator，不要有工具之争，暂时使用体验非常不错。

BTW，或者需要安装各种插件、bazel这些命令上，大部分时间可能还是耗在vim

4. 如何使用bazel build

安装
安装过程请参考: http://bazel.io/docs/install.html
使用工作区（workspace）
所有的Bazel构建都是基于一个工作区（workspace）概念，它是文件系统中一个保存了全部源代码的目录，同时还将包含一些构建后的输出目录的符号链接（例如：bazel-bin和 bazel-out 等输出目录）。工作区目录可以随意放在哪里，但是工作区的根目录必须包含一个名为 WORKSPACE 的工作区配置文件。工作区配置文件可以是一个空文件，也可以包含引用外部构建输出所需的依赖关系。
在一个工作区内，可以根据需要共享多个项目。为了简单，我们先从只有一个项目的工作区开始介绍。
先假设你已经有了一个项目，对应 ~/gitroot/my-project/ 目录。我们先创建一个空的 ~/gitroot/my-project/WORKSPACE 工作区配置文件，用于表示这是Bazel项目对应的根目录。
创建自己的Build构建文件
使用下面的命令创建一个简单的Java项目：
$ # If you're not already there, move to your workspace directory.
$ cd ~/gitroot/my-project
$ mkdir -p src/main/java/com/example
$ cat > src/main/java/com/example/ProjectRunner.java <<EOF
package com.example;

public class ProjectRunner {
public static void main(String args[]) {
Greeting.sayHi();
}
}
EOF
$ cat > src/main/java/com/example/Greeting.java <<EOF
package com.example;

public class Greeting {
public static void sayHi() {
System.out.println("Hi!");
}
}
EOF

Bazel通过工作区中所有名为 BUILD 的文件来解析需要构建的项目信息，因此，我们需要先在 ~/gitroot/my-project 目录创建一个 BUILD 构建文件。下面是BUILD构建文件的内容：
# ~/gitroot/my-project/BUILD
java_binary(
name = "my-runner",
srcs = glob(["**/*.java"]),
main_class = "com.example.ProjectRunner",
)

BUILD文件采用类似Python的语法。虽然不能包含任意的Python语法，但是BUILD文件中的每个构建规则看起来都象是一个Python函数调用，而且你也可以用 "#" 开头来添加单行注释。
java_binary 是一个构建规则。其中 name 对应一个构建目标的标识符，可用用它来向Bazel指定构建哪个项目。srcs 对应一个源文件列表，Bazel需要将这些源文件编译为二进制文件。其中 glob(["**/*.java"]) 表示递归包含每个子目录中以每个 .java 为后缀名的文件。com.example.ProjectRunner 指定包含main方法的类。
现在可以用下面的命令构建这个Java程序了：
$ cd ~/gitroot/my-project
$ bazel build //:my-runner
INFO: Found 1 target...
Target //:my-runner up-to-date:
bazel-bin/my-runner.jar
bazel-bin/my-runner
INFO: Elapsed time: 1.021s, Critical Path: 0.83s
$ bazel-bin/my-runner
Hi!

恭喜，你已经成功构建了第一个Bazel项目了！
添加依赖关系
对于小项目创建一个规则是可以的，但是随着项目的变大，则需要分别构建项目的不同的部件，最终再组装成产品。这种构建方式可以避免因为局部细小的修改儿导致重现构建整个应用，同时不同的构建步骤可以很好地并发执行以提高构建效率。
我们现在将一个项目拆分为两个部分独立构建，同时设置它们之间的依赖关系。基于上面的例子，我们重写了BUILD构建文件：
java_binary(
name = "my-other-runner",
srcs = ["src/main/java/com/example/ProjectRunner.java"],
main_class = "com.example.ProjectRunner",
deps = [":greeter"],
)

java_library(
name = "greeter",
srcs = ["src/main/java/com/example/Greeting.java"],
)

虽然源文件是一样的，但是现在Bazel将采用不同的方式来构建：首先是构建 greeter库，然后是构建 my-other-runner。可以在构建成功后立刻运行 //:my-other-runner：
$ bazel run //:my-other-runner
INFO: Found 1 target...
Target //:my-other-runner up-to-date:
bazel-bin/my-other-runner.jar
bazel-bin/my-other-runner
INFO: Elapsed time: 2.454s, Critical Path: 1.58s

INFO: Running command line: bazel-bin/my-other-runner
Hi!

现在如果你改动ProjectRunner.java代码并重新构建my-other-runner目标，Greeting.java文件因为没有变化而不会重现编译。
使用多个包（Packages）
对于更大的项目，我们通常需要将它们拆分到多个目录中。你可以用类似//path/to/directory:target-name的名字引用在其他BUILD文件定义的目标。假设src/main/java/com/example/有一个cmdline/子目录，包含下面的文件：
$ mkdir -p src/main/java/com/example/cmdline
$ cat > src/main/java/com/example/cmdline/Runner.java <<EOF
package com.example.cmdline;

import com.example.Greeting;

public class Runner {
public static void main(String args[]) {
Greeting.sayHi();
}
}
EOF

Runner.java依赖com.example.Greeting，因此我们需要在src/main/java/com/example/cmdline/BUILD构建文件中添加相应的依赖规则：
# ~/gitroot/my-project/src/main/java/com/example/cmdline/BUILD
java_binary(
name = "runner",
srcs = ["Runner.java"],
main_class = "com.example.cmdline.Runner",
deps = ["//:greeter"]
)

然而，默认情况下构建目标都是私有的。也就是说，我们只能在同一个BUILD文件中被引用。这可以避免将很多实现的细节暴漏给公共的接口，但是也意味着我们需要手工允许runner所依赖的//:greeter目标。就是类似下面这个在构建runner目标时遇到的错误：
$ bazel build //src/main/java/com/example/cmdline:runner
ERROR: /home/user/gitroot/my-project/src/main/java/com/example/cmdline/BUILD:2:1:
Target '//:greeter' is not visible from target '//src/main/java/com/example/cmdline:runner'.
Check the visibility declaration of the former target if you think the dependency is legitimate.
ERROR: Analysis of target '//src/main/java/com/example/cmdline:runner' failed; build aborted.
INFO: Elapsed time: 0.091s

可用通过在BUILD文件增加visibility = level属性来改变目标的可间范围。下面是通过在~/gitroot/my-project/BUILD文件增加可见规则，来改变greeter目标的可见范围：
java_library(
name = "greeter",
srcs = ["src/main/java/com/example/Greeting.java"],
visibility = ["//src/main/java/com/example/cmdline:__pkg__"],
)

这个规则表示//:greeter目标对于//src/main/java/com/example/cmdline包是可见的。现在我们可以重新构建runner目标程序：
$ bazel run //src/main/java/com/example/cmdline:runner
INFO: Found 1 target...
Target //src/main/java/com/example/cmdline:runner up-to-date:
bazel-bin/src/main/java/com/example/cmdline/runner.jar
bazel-bin/src/main/java/com/example/cmdline/runner
INFO: Elapsed time: 1.576s, Critical Path: 0.81s

INFO: Running command line: bazel-bin/src/main/java/com/example/cmdline/runner
Hi!

参考文档中有可见性配置说明。
部署
如果你查看 bazel-bin/src/main/java/com/example/cmdline/runner.jar 的内容，可以看到里面只包含了Runner.class，并没有保护所依赖的Greeting.class：
$ jar tf bazel-bin/src/main/java/com/example/cmdline/runner.jar
META-INF/
META-INF/MANIFEST.MF
com/
com/example/
com/example/cmdline/
com/example/cmdline/Runner.class

这只能在本机正常工作（因为Bazel的runner脚本已经将greeter jar添加到了classpath），但是如果将runner.jar单独复制到另一台机器上讲不能正常运行。如果想要构建可用于部署发布的自包含所有依赖的目标，可以构建runner_deploy.jar目标（类似<target-name>_deploy.jar以_deploy为后缀的名字对应可部署目标）。
$ bazel build //src/main/java/com/example/cmdline:runner_deploy.jar
INFO: Found 1 target...
Target //src/main/java/com/example/cmdline:runner_deploy.jar up-to-date:
bazel-bin/src/main/java/com/example/cmdline/runner_deploy.jar
INFO: Elapsed time: 1.700s, Critical Path: 0.23s

runner_deploy.jar中将包含全部的依赖。
下一步
现在，您可以创建自己的目标并组装最终产品了。接下来，可查看相关教程分别学习如何用Bazel构建一个服务器、Android和iOS应用。也可以参考用户手册获得更多的信息。如果有问题的话，可以到 bazel-discuss 论坛提问。

5. 如何学习TensorFlow源码

如果从源码构建TensorFlow会需要执行如下命令：
bazel build -c opt //tensorflow/tools/pip_package:build_pip_package

对应的BUILD文件的rule为：
sh_binary(
name = "build_pip_package",
srcs = ["build_pip_package.sh"],
data = [
"MANIFEST.in",
"README",
"setup.py",
"//tensorflow/core:framework_headers",
":other_headers",
":simple_console",
"//tensorflow:tensorflow_py",
"//tensorflow/examples/tutorials/mnist:package",
"//tensorflow/models/embedding:package",
"//tensorflow/models/image/cifar10:all_files",
"//tensorflow/models/image/mnist:convolutional",
"//tensorflow/models/rnn:package",
"//tensorflow/models/rnn/ptb:package",
"//tensorflow/models/rnn/translate:package",
"//tensorflow/tensorboard",
],
)

sh_binary在这里的主要作用是生成data的这些依赖。一个一个来看，一开始的三个文件MANIFEST.in、README、setup.py是直接存在的，因此不会有什么操作。
“//tensorflow/core:framework_headers”:其对应的rule为：
filegroup(
name = "framework_headers",
srcs = [
"framework/allocator.h",
......
"util/device_name_utils.h",
],
)

这里filegroup的作用是给这一堆头文件一个别名，方便其他rule引用。
“:other_headers”:rule为：
transitive_hdrs(
name = "other_headers",
deps = [
"//third_party/eigen3",
"//tensorflow/core:protos_all_cc",
],
)

transitive_hdrs的定义在：
load("//tensorflow:tensorflow.bzl", "transitive_hdrs")

实现为：
# Bazel rule for collecting the header files that a target depends on.
def _transitive_hdrs_impl(ctx):
outputs = set()
for dep in ctx.attr.deps:
outputs += dep.cc.transitive_headers
return struct(files=outputs)

_transitive_hdrs = rule(attrs={
"deps": attr.label_list(allow_files=True,
providers=["cc"]),
},
implementation=_transitive_hdrs_impl,)

def transitive_hdrs(name, deps=[], **kwargs):
_transitive_hdrs(name=name + "_gather",
deps=deps)
native.filegroup(name=name,
srcs=[":" + name + "_gather"])

其作用依旧是收集依赖需要的头文件。
“:simple_console”:其rule为：
py_binary(
name = "simple_console",
srcs = ["simple_console.py"],
srcs_version = "PY2AND3",
deps = ["//tensorflow:tensorflow_py"],
)
py_library(
name = "tensorflow_py",
srcs = ["__init__.py"],
srcs_version = "PY2AND3",
visibility = ["//visibility:public"],
deps = ["//tensorflow/python"],
)

simple_console.py的代码的主要部分是：
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import code
import sys

def main(_):
"""Run an interactive console."""
code.interact()
return 0

if __name__ == '__main__':
sys.exit(main(sys.argv))

可以看到起通过deps = [“//tensorflow/python”]构建了依赖包，然后生成了对应的执行文件。看下依赖的rule规则。//tensorflow/python对应的rule为：
py_library(
name = "python",
srcs = [
"__init__.py",
],
srcs_version = "PY2AND3",
visibility = ["//tensorflow:__pkg__"],
deps = [
":client",
":client_testlib",
":framework",
":framework_test_lib",
":kernel_tests/gradient_checker",
":platform",
":platform_test",
":summary",
":training",
"//tensorflow/contrib:contrib_py",
],
)

这里如果仔细看的话会发现其主要是生成一堆python的模块。从这里貌似可以看出每个python的mole都对应了一个rule，且mole依赖的mole都写在了deps里。特别的，作为一个C++的切入，我们关注下training这个依赖：
py_library(
name = "training",
srcs = glob(
["training/**/*.py"],
exclude = ["**/*test*"],
),
srcs_version = "PY2AND3",
deps = [
":client",
":framework",
":lib",
":ops",
":protos_all_py",
":pywrap_tensorflow",
":training_ops",
],
)

这里其依赖的pywrap_tensorflow的rule为：
tf_py_wrap_cc(
name = "pywrap_tensorflow",
srcs = ["tensorflow.i"],
swig_includes = [
"client/device_lib.i",
"client/events_writer.i",
"client/server_lib.i",
"client/tf_session.i",
"framework/python_op_gen.i",
"lib/core/py_func.i",
"lib/core/status.i",
"lib/core/status_helper.i",
"lib/core/strings.i",
"lib/io/py_record_reader.i",
"lib/io/py_record_writer.i",
"platform/base.i",
"platform/numpy.i",
"util/port.i",
"util/py_checkpoint_reader.i",
],
deps = [
":py_func_lib",
":py_record_reader_lib",
":py_record_writer_lib",
":python_op_gen",
":tf_session_helper",
"//tensorflow/core/distributed_runtime:server_lib",
"//tensorflow/core/distributed_runtime/rpc:grpc_server_lib",
"//tensorflow/core/distributed_runtime/rpc:grpc_session",
"//util/python:python_headers",
],
)

tf_py_wrap_cc为其自己实现的一个rule，这里的.i就是SWIG的interface文件。来看下其实现：
def tf_py_wrap_cc(name, srcs, swig_includes=[], deps=[], copts=[], **kwargs):
mole_name = name.split("/")[-1]
# Convert a rule name such as foo/bar/baz to foo/bar/_baz.so
# and use that as the name for the rule procing the .so file.
cc_library_name = "/".join(name.split("/")[:-1] + ["_" + mole_name + ".so"])
extra_deps = []
_py_wrap_cc(name=name + "_py_wrap",
srcs=srcs,
swig_includes=swig_includes,
deps=deps + extra_deps,
mole_name=mole_name,
py_mole_name=name)
native.cc_binary(
name=cc_library_name,
srcs=[mole_name + ".cc"],
copts=(copts + ["-Wno-self-assign", "-Wno-write-strings"]
+ tf_extension_copts()),
linkopts=tf_extension_linkopts(),
linkstatic=1,
linkshared=1,
deps=deps + extra_deps)
native.py_library(name=name,
srcs=[":" + name + ".py"],
srcs_version="PY2AND3",
data=[":" + cc_library_name])

按照SWIG的正常流程，先要通过swig命令生成我们的wrap的c文件，然后和依赖生成我们的so文件，最后生成一个同名的python文件用于import。这里native.cc_binary和native.py_library做了我们后面的两件事情，而swig命令的执行则交给了_py_wrap_cc。其实现为：
_py_wrap_cc = rule(attrs={
"srcs": attr.label_list(mandatory=True,
allow_files=True,),
"swig_includes": attr.label_list(cfg=DATA_CFG,
allow_files=True,),
"deps": attr.label_list(allow_files=True,
providers=["cc"],),
"swig_deps": attr.label(default=Label(
"//tensorflow:swig")), # swig_templates
"mole_name": attr.string(mandatory=True),
"py_mole_name": attr.string(mandatory=True),
"swig_binary": attr.label(default=Label("//tensorflow:swig"),
cfg=HOST_CFG,
executable=True,
allow_files=True,),
},
outputs={
"cc_out": "%{mole_name}.cc",
"py_out": "%{py_mole_name}.py",
},
implementation=_py_wrap_cc_impl,)

_py_wrap_cc_impl的实现为：
# Bazel rules for building swig files.
def _py_wrap_cc_impl(ctx):
srcs = ctx.files.srcs
if len(srcs) != 1:
fail("Exactly one SWIG source file label must be specified.", "srcs")
mole_name = ctx.attr.mole_name
cc_out = ctx.outputs.cc_out
py_out = ctx.outputs.py_out
src = ctx.files.srcs[0]
args = ["-c++", "-python"]
args += ["-mole", mole_name]
args += ["-l" + f.path for f in ctx.files.swig_includes]
cc_include_dirs = set()
cc_includes = set()
for dep in ctx.attr.deps:
cc_include_dirs += [h.dirname for h in dep.cc.transitive_headers]
cc_includes += dep.cc.transitive_headers
args += ["-I" + x for x in cc_include_dirs]
args += ["-I" + ctx.label.workspace_root]
args += ["-o", cc_out.path]
args += ["-outdir", py_out.dirname]
args += [src.path]
outputs = [cc_out, py_out]
ctx.action(executable=ctx.executable.swig_binary,
arguments=args,
mnemonic="PythonSwig",
inputs=sorted(set([src]) + cc_includes + ctx.files.swig_includes +
ctx.attr.swig_deps.files),
outputs=outputs,
progress_message="SWIGing {input}".format(input=src.path))
return struct(files=set(outputs))

这里的ctx.executable.swig_binary是一个shell脚本，内容为：
# If possible, read swig path out of "swig_path" generated by configure
SWIG=swig
SWIG_PATH=tensorflow/tools/swig/swig_path
if [ -e $SWIG_PATH ]; then
SWIG=`cat $SWIG_PATH`
fi

# If this line fails, rerun configure to set the path to swig correctly
"$SWIG" "$@"

可以看到起就是调用了swig命令。
“//tensorflow:tensorflow_py”:其rule为：
py_library(
name = "tensorflow_py",
srcs = ["__init__.py"],
srcs_version = "PY2AND3",
visibility = ["//visibility:public"],
deps = ["//tensorflow/python"],
)

6. 看caffe和tensorflow源码用什么IDE

无论看Python、Java、C++代码我一般都先打开Sublime Text，改一下代码然后编译运行测试。
但Sublime Text提示和跳转不够强大，或者需要安装各种插件，对于大型C++项目我也是听从大牛推荐，使用Qt Creator，暂时使用体验非常不错。
BTW，一般看源码用顺手的工具即可，不要有工具之争，大部分时间可能还是耗在vim、bazel这些命令上。

7. ubuntu16.04 tensoflow使用服务器需要支持gpu吗

1. 下载
1.1 系统镜像
由于我尝试了ubuntu14.04，安装Nvidia驱动之后，会出现循环登录的问题，并始终无法找到有效的解决途径，所以只能选择ubuntu16.04了。

1.2 CUDA 8.0

说明：
（1）在NVIDIA的CUDA下载页面下，选择要使用的CUDA版本进行下载。
（2）我们这里使用CUDA8.0（页面有提示GTX1070、GTX1080支持8.0版本），学员如果没有使用以上两个版本的GPU，可以下载CUDA7.5。DOWNLOAD（下载）。
（3）下载需要注册。
（4）图解选择

1.3 cuDNN v5

说明：
（1）下载需要填写一个调查问卷，就三个选项，建议认真填写，毕竟人家免费给咱使用。
（2）填写完毕点击 I Agree To 前面的小方框，出现如下：

1.4 Tensorflow 0.11
tensorflow github上面提到 4 种安装方式，本教程使用第四种源码安装
Virtualenv installation
Anaconda installation
Docker installation
Installing from sources

说明：
（1）打开下载页面，往下翻，直到下图这个位置：

（2）点击Python 2开始下载。

最后，将1.2-1.4中下载文件全部存放至自己的移动硬盘/U盘内，等待安装时候使用。
2. 安装ubuntu16.04 LTS 系统
安装Ubuntu16.04：

说明：
（1）我们直接安装的英文原版系统，语言也是选择英文的。
（2）上述链接在–第三步：安装类型上选择的是–自定义。我们选择的是–清除整个磁盘并且安装，如果你有Windows系统，还会提示安装Ubuntu16.04与Windows并存模式。这个自行选择，切记！这个地方谨慎选择。
（3）感谢网络经验上传者！
3. 安装NVIDIA驱动
打开terminal输入以下指令:
sudo apt-get update1

然后在系统设置->软件更新->附加驱动->选择nvidia最新驱动(361)->应用更改
3. cuda 8.0
3.1 安装cuda
在cuda所在目录打开terminal依次输入以下指令：
cd /home/***(自己的用户名)/Desktop/###(这个命令意思是找到刚刚我们用U盘传过来的文件)
sudo dpkg -i cuda-repo-ubuntu1604-8-0-rc_8.0.27-1_amd64.deb
sudo apt-get update
sudo apt-get install cuda1234

3.2 gcc降版本
ubuntu的gcc编译器是5.4.0，然而cuda8.0不支持5.0以上的编译器，因此需要降级，把编译器版本降到4.9：
在terminal中执行：
sudo apt-get install g++-4.9
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 20
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 10
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.9 20
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-5 10
sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc 30
sudo update-alternatives --set cc /usr/bin/gcc
sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++ 30
sudo update-alternatives --set c++ /usr/bin/g++123456789

3. 安装cuDNN
打开terminal依次输入以下指令：
cd /home/***(自己的用户名)/Desktop/###(这个命令意思是找到刚刚我们用U盘传过来的文件)
tar xvzf cudnn-8.0-linux-x64-v5.1-ga.tgz###（解压这个文件）
sudo cp cuda/include/cudnn.h /usr/local/cuda/include###（复制）
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64###（复制）
sudo chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*12345

4. 安装其他依赖
4.1 配置环境变量

按照上图的教程，在terminal中输入以下命令：
sudo gedit ~/.bash_profile #打开.bash_profile1

然后在打开的文本末尾加入：
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64"
export CUDA_HOME=/usr/local/cuda12

继续在terminal中输入:
source ~/.bash_profile #使更改的环境变量生效1

当然，也有其他教程在文件~/.bashrc文件中写入的，方法与上面的类似。如果在后面配置./config文件出现问题时，可以实现这个方法。
4.2 安装其他库
/tensorflow/tensorflow/blob/master/tensorflow/g3doc/get_started/os_setup.md
我们是在github的Tensorflow官方网页上，根据提示安装，地址如上。
按步骤截图如下

在terminal中输入以下命令：
sudo apt-get install python-pip python-dev 1

4. 安装Bazel
4.1 安装Bazel依赖
由于本教程使用tensorflow源码编译/安装，所以需要使用 bazel build。

在terminal中依次输入以下1-7的命令

4.2 安装Bazel
之后回到之前的Tensorflow安装教程页面： /tensorflow/tensorflow/blob/master/tensorflow/g3doc/get_started/os_setup.md

点击链接： installer for your system，跳转到Bazel的下载页面：

下载bazel-0.3.2-installer-linux-x86_64.sh到桌面，然后在terminal中输入以下命令
cd /home/***(自己的用户名)/Desktop/###(这个命令意思是找到刚刚我们用U盘传过来的文件)
chmod +x PATH_TO_INSTALL.SH #对.sh文件授权
./PATH_TO_INSTALL.SH --user #运行.sh文件123

4.3 安装第三方库
在terminal中输入以下命令
sudo apt-get install python-numpy swig python-dev python-wheel #安装第三方库
sudo apt-get install git
git clone git://github.com/numpy/numpy.git numpy 123

5. 安装tensorflow
5.1 下载tensorflow
在terminal中输入以下命令
git clone /tensorflow/tensorflow1

特别注意，我使用的是tensorflow 0.11版本，该版本要求cuda 7.5 以上，cuDNN v5。
默认下载目录是在/home下
5.2 配置tensorflow
还是刚刚的网址
/tensorflow/tensorflow/blob/master/tensorflow/g3doc/get_started/os_setup.md
在terminal中输入以下命令：
cd ~/tensorflow #切换到tensorflow文件夹
./configure #执行configure文件12

然后按照下图选项进行操作：

5.3 创建pip

在terminal中输入以下命令：
bazel build -c opt //tensorflow/tools/pip_package:build_pip_package
bazel build -c opt --config=cuda //tensorflow/tools/pip_package:build_pip_package
bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
sudo pip install /home/***（你自己的用户名）/Desktop/tensorflow-0.10.0-cp2-none-any.whl1234

5.4 设置tensorflow环境

bazel build -c opt //tensorflow/tools/pip_package:build_pip_package
# To build with GPU support:
bazel build -c opt --config=cuda //tensorflow/tools/pip_package:build_pip_package
mkdir _python_build
cd _python_build
ln -s ../bazel-bin/tensorflow/tools/pip_package/build_pip_package.runfiles/org_tensorflow/* .
ln -s ../tensorflow/tools/pip_package/* .
python setup.py develop12345678

这样就大功告成啦~！！！
6. 测试tensorflow
这里进行测试，如果你能跟我看到同样的画面，那恭喜你成功配置GPU版的tensorflow啦！

8. 在win10里为什么 Bazel 编译 tensorflow.dll 提示 /arch:SSE4.2 无效命令要编译SSE4.2的参数怎么配置

河南新华正在火热报名，欢迎参观！！！

9. 谁有Crystal FLOW C++ 的破解版

10. 关于C代码报不安全的时候怎么办

方法一：在程序最前面加#define _CRT_SECURE_NO_DEPRECATE；

方法二：在程序最前面加#define _CRT_SECURE_NO_WARNINGS；

方法三：在程序最前面加#pragma warning(disable:4996)；
方法四：把scanf改为scanf_s；

方法五：无需在程序最前面加那行代码，只需在新建项目时取消勾选“SDL检查”即可；

方法六：若项目已建立好，在项目属性里关闭SDL也行；

方法七：在工程项目设置一下就行；将报错那个宏定义放到项目属性 -- C/C++-- 预处理器 -- 预处理器定义；

方法八：在项目属性 -- c/c++ -- 命令行添加：/D _CRT_SECURE_NO_WARNINGS 就行了。

导航:首页 > 程序命令 > bazel命令

bazel命令

与bazel命令相关的资料