Tensorflow_安装和运行
本文主要描述基于ubuntu操作系统下Tensorflow安装运行的一个完整的过程。其中包含了对于ubuntu操作系统的相关的命令和功能进行介绍，以便于对ubuntu不熟悉的爱好者顺利完成Tensorflow的安全中运行。在根据本文实施Tensorflow的安装及运行之前，需要安装好ubuntu14或更高级别的操作系统。
Bazel是google的代码构架工具。Tensorflow是基于Bazel和Swig来建立Tensorflow的框架的。Tensorflow框架以Python为主要语言开发，同时将一些运算密集的功能模块通过C/C++来实现并进行封装。Tensorflow利用Swig提供了Python调用C/C++所开发功能模块的接口。Tensorflow中算法模块的运行要依靠Bazel进行Build后运行。Bazel的安装及使用可参考bazel.io网站的资料和软件。
Swig中的*.i文件，用于记录被python调用文件名为“*.py”的功能模块。
本文档中关于Tensorflow安装的内容主要为前两章。第三章讲述了采用bazel构建tensorflow框架。后面章节的内容主要涉及bazel以及swig的安装和实例。
1.Tensorflow的安装
1.1 无Tensorflow源码的安装及运行
备注：如果之前安装过TensorFlow < 0.7.1 的版本,应该先使用pip uninstall卸载TensorFlow 和protobuf ,保证获取的是一个最新protobuf 依赖下的安装包. 可以先下载tensorflow-0.8.0-cp27-none-linux_x86_64.whl文件在采用上述命令进行安装。
Tensorflow0.6.0的网址：
https://https://www.doczj.com/doc/7c19227786.html,/tensorflow/tensorflow/tree/0.6.0
千万别用tensorflow的0.5.0版本，各种编译和attribute等类型的错误。
进行以上安装之后，就可以运行以下简单的代码：
运行一个简单的TensorFlow
1.2 可以修改Tensorflow源码的安装及运行
从源码安装，需要克隆TensorFlow 仓库。采用源码安装可以看到各种被调用的库文件和函数的功能语句。采用源码安装需要同时安装bazel来对所安装的源码进行编译。
在tensorflow根目录下，可能需要先执行编译命令：./compile
-c opt
1.3采用源码安装后tensorflow项目的运行例子
采用bazel build tensorflow中项目文件的关键步骤，按照本文的步骤安装并下载tensorflow、bazel、swig等软件和项目后，进入顶层目录tensorflow。与1.2中对于tensorflow库的整体编译不同，本小节注重于具体tensorflow项目的build和运行。由于Tensorflow是基于bazel系统来构建的，因此对于具体应用项目的build采用bazel中的对应的命令如下：
(1)对mnist中的convolutional模块进行build
bazel build //tensorflow/models/image/mnist:convolutional
(2)运行build之后的上述convolutional模块：
Bazel-bin/tensorflow/models/image/mnist/convolutional
“bazel build”命令所针对的模块所处的文件夹下必须要有BUILD文件。此份BUILd文件中必须定义convolutional模块的名称；定义语句为：name=“convolutional”。注意，在tensorflow 所处的目录下也必须要有BUILD文件和WORKSPACE文件。
利用bazel进行功能模块build的过程参考bazel io目录下的getting started with bazel文档。
其它bazel中BUILD的例子
bazel build -c opt //tensorflow/models/image/mnist:convolutional
bazel build //tensorflow/examples/tutorials/mnist:fully_connected_feed
bazel build //tensorflow/examples/tutorials/word2vec:word2vec_basic
bazel BUILD至运行的例子
Make sure you have "/usr/local/bin" in your path. You can also activate bash
completion by adding the following line to your ~/.bashrc:
source /usr/local/lib/bazel/bin/bazel-complete.bash
设置环境变量PATH 为/usr/local/arm/3.3.2/bin 外加原来的PATH 变量内容。
比如PA TH 原来的变量为/usr/bin
这个命令之后，PATH 内容就是/usr/local/arm/3.3.2/bin:/usr/bin
其中: 是每个目录的分隔符，$XXXX 是引用XXXX 这个变量的值，没$ ，PATH 就是4个字母，不会被识别为变量。
export 是赋值的命令
export PATH="$PATH:/usr/local/bin"
$ 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!
2.Ubuntu常用命令及功能
2.1 安装文件命令
sudo apt-get install python-dev; # 安装python的辅助库文件等文件。
pip install six # 安装python的six库文件
sudo apt-get intall python-pip # 安装python的pip文件包
sudo apt-get intall swig # 安装python的swig软件
sudo apt-get intall pcre # 安装python的pcre软件，
#安装swig之前可能需要先安装pcre软件；
sudo apt-get update
sudo apt-get install libpcre3 libpcre3-dev
可能还需要安装：
Sudo apt-get install openssl libssl-dev
安装swig如果采用linux下的压缩文件.gz、.tar.gz压缩文件作为swig的安装文件，则采用以下三个命令：./configure, make, makeinstall 三个命令；
2.2功能命令
Sudo su更改当前用户为root用户；
chmod 777 folder 改变folder文件夹的属性为所有用户都具备读写权限；
搜索某个程序的命令：whereis command
搜索某个文件的命令：find filename；locate filename或folder name
$ which python命令可以查看python可执行文件所处位置；
mkdir newfolder 生成新的文件夹命令；这个命令在root用户的权限下可生成任何文件夹。rm –rf filefolder删除文件夹命令
echo $PATH 显示路径
export PATH=”$PATH:/home/zj/bazel….”添加目录
ubuntu系统下的*.sh文件是可运行的脚本文件。
$cat >filename 创建新的文件，不能编辑已有文件
按下ctrl-h 命令可显示当前目录下隐藏的文件。
ls –l 列出当前目录下所有文件夹的读写属性
grep …function_name?–R 可用于搜索ubuntu的文档中所包含的? function_name?字符。
2.3 重要文件及功能
~/.bashrc代表用户主目录下的.bashrc文件，这个文件包含ubuntu可执行文件所处的目录，用
于执行命令时(可执行文件对应的命令)时供系统进行搜索。
~/代表当前用户的主目录
./filename: 一个点代表当前目录，两个点代表上级目录
通过用户目录下的./bashrc文件可设置本用户的路径
$gedit ~/.bashrc
在所打开文件的最后增加需要设置变量的shell语句，例如：
export PATH=~/mypath/bin $PATH
保存后，在新打开的终端生效。
Python的可执行文件位于“/usr/bin/”文件夹下面；
Python的其它头文件位于“/usr/include/python2.7/”文件夹下面；
3.VirtualEnv环境的搭建
基于VirtualEnv 的安装：我们推荐使用virtualenv 创建一个隔离的容器, 来安装TensorFlow. 这是可选的, 但是这样做能使排查安装问题变得更容易.
首先, 安装所有必备工具:
# 在Linux 上:
$ sudo apt-get install python-pip python-dev python-virtualenv
# 在Mac 上:
$ sudo easy_install pip # 如果还没有安装pip
$ sudo pip install --upgrade virtualenv
接下来, 建立一个全新的virtualenv 环境. 为了将环境建在~/tensorflow 目录下, 执行:
$ virtualenv --system-site-packages ~/tensorflow
$ cd ~/tensorflow
然后, 激活virtualenv:
$ source bin/activate # 如果使用bash
$ source bin/activate.csh # 如果使用csh
(tensorflow)$ # 终端提示符应该发生变化
在virtualenv 内, 安装TensorFlow:
(tensorflow)$ pip install --upgrade <$url_to_binary.whl>
接下来, 使用类似命令运行TensorFlow 程序:
(tensorflow)$ cd tensorflow/models/image/mnist
(tensorflow)$ python convolutional.py
# 当使用完TensorFlow
(tensorflow)$ deactivate # 停用virtualenv
4.Tensorflow的构建框架
在静下心来默默看了大半年机器学习的资料并做了些实践后，打算学习下现在热门的TensorFlow的实现，毕竟系统这块和自己关系较大。本文会简单的说明一下如何阅读TensorFlow的源码。最重要的是了解其构建工具bazel以及脚本语言调用c或cpp的包裹工具
swig。这里假设大家对bazel及swig以及有所了解（不了解的可以google下）。要看代码首先要知道代码怎么构建，因此本文的一大部分会关注构建这块。
如果从源码构建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”:r ule为：
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 += https://www.doczj.com/doc/7c19227786.html,.transitive_headers
return struct(files=outputs)
_transitive_hdrs = rule(attrs={
"deps": https://www.doczj.com/doc/7c19227786.html,bel_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 的module都对应了一个rule，且module依赖的module都写在了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):
module_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 producing the .so file.
cc_library_name = "/".join(name.split("/")[:-1] + ["_" + module_name + ".so"])
extra_deps = []
_py_wrap_cc(name=name + "_py_wrap",
srcs=srcs,
swig_includes=swig_includes,
deps=deps + extra_deps,
module_name=module_name,
py_module_name=name)
https://www.doczj.com/doc/7c19227786.html,_binary(
name=cc_library_name,
srcs=[module_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。这里https://www.doczj.com/doc/7c19227786.html,_binary和
native.py_library做了我们后面的两件事情，而swig命令的执行则交给了_py_wrap_cc。其实现为：
_py_wrap_cc = rule(attrs={
"srcs": https://www.doczj.com/doc/7c19227786.html,bel_list(mandatory=True,
allow_files=True,),
"swig_includes": https://www.doczj.com/doc/7c19227786.html,bel_list(cfg=DATA_CFG,
allow_files=True,),
"deps": https://www.doczj.com/doc/7c19227786.html,bel_list(allow_files=True,
providers=["cc"],),
"swig_deps": https://www.doczj.com/doc/7c19227786.html,bel(default=Label(
"//tensorflow:swig")), # swig_templates
"module_name": attr.string(mandatory=True),
"py_module_name": attr.string(mandatory=True),
"swig_binary": https://www.doczj.com/doc/7c19227786.html,bel(default=Label("//tensorflow:swig"),
cfg=HOST_CFG,
executable=True,
allow_files=True,),
},
outputs={
"cc_out": "%{module_name}.cc",
"py_out": "%{py_module_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")
module_name = ctx.attr.module_name
cc_out = https://www.doczj.com/doc/7c19227786.html,_out
py_out = ctx.outputs.py_out
src = ctx.files.srcs[0]
args = ["-c++", "-python"]
args += ["-module", module_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 https://www.doczj.com/doc/7c19227786.html,.transitive_headers]
cc_includes += https://www.doczj.com/doc/7c19227786.html,.transitive_headers
args += ["-I" + x for x in cc_include_dirs]
args += ["-I" + https://www.doczj.com/doc/7c19227786.html,bel.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"],
)
可以看到起主要依赖了我们上面生成的”//tensorflow/python”这个module。剩余的几个其实和主框架关系不大，主要是生成一些model、文档啥的。
现在清楚了其构建链后，我们来看个简单的程序，其通过梯度下降算法求线性拟合的W和b。我们会从这个例子入手看下如何找到其使用的函数的具体实现的源码位置:
(python3.5)?tmp cat th.py
import tensorflow as tf
import numpy as np
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for step in range(0, 201):
sess.run(train)
if step % 20 == 0:
print(step, sess.run(W), sess.run(b))
(python3.5)?tmp python th.py
0 [ 0.42190057] [ 0.17155224]
20 [ 0.1743494] [ 0.26045772]
40 [ 0.11817314] [ 0.29033473]
60 [ 0.10444205] [ 0.29763755]
80 [ 0.10108578] [ 0.29942256]
100 [ 0.10026541] [ 0.29985884]
120 [ 0.10006487] [ 0.2999655]
140 [ 0.10001585] [ 0.29999158]
160 [ 0.10000388] [ 0.29999796]
180 [ 0.10000096] [ 0.29999951]
200 [ 0.10000025] [ 0.29999989]
从我们上面的分析可以看到，import tensorflow as tf来自于tensorflow目录下的__init__.py文件，其内容为：
from tensorflow.python import *
再来看tf.Variable，在tensorflow.python的__init__.py中可以看到其导入了很多符号。但要定位到Variable还是比较困难，因为其很多直接是import *。所以一个快速定位的方法是直接grep 这个class：
?python grep 'class Variable(' -R ./*
./ops/variables.py:class Variable(object):
对于tf.Session等也可以用同样的方法定位。
我们来找个走SWIG包裹的，如果我们去看sess.run，我们会看到如下的代码：
return tf_session.TF_Run(session, options,
feed_dict, fetch_list, target_list,
run_metadata)
这里tf_session就是一个SWIG包裹的模块：
from tensorflow.python import pywrap_tensorflow as tf_session
pywrap_tensorflow在源码里是找不到的，因为这个得从SWIG生成后才有，我们可以从.i文件里找下TF_Run的声明，或者直接grep下这个函数：
?tensorflow grep 'TF_Run(' -R ./*
./core/client/tensor_c_https://www.doczj.com/doc/7c19227786.html,:void TF_Run(TF_Session* s, const TF_Buffer* run_options,
这样就可以看其实现了：
void TF_Run(TF_Session* s, const TF_Buffer* run_options,
// Input tensors
const char** c_input_names, TF_Tensor** c_inputs, int ninputs,
// Output tensors
const char** c_output_tensor_names, TF_Tensor** c_outputs,
int noutputs,
// Target nodes
const char** c_target_node_names, int ntargets,
TF_Buffer* run_metadata, TF_Status* status) {
TF_Run_Helper(s, nullptr, run_options, c_input_names, c_inputs, ninputs,
c_output_tensor_names, c_outputs, noutputs, c_target_node_names,
ntargets, run_metadata, status);
}
5.Installing Bazel
Bazel的源码安装和非源码安装只要选一种即可，不需要采用两种方式进行bazel的安装。
System Requirements
Supported platforms:
?Ubuntu Linux (Wily 15.10 and Trusty 14.04 LTS)
?Mac OS X
Java:
?Java JDK 8 or later (JDK 7 is still supported but deprecated).
Windows Support
?Currently, Windows support is highly experimental. For more information, see Building Bazel on Windows.
Install dependencies
Ubuntu
1. Install JDK 8
Ubuntu Trusty (14.04 LTS). OpenJDK 8 is not available on Trusty. To install Oracle JDK 8:
$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java8-installer
Note: You might need to sudo apt-get install software-properties-common if you don't have the add-apt-repository command. See here.
Ubuntu Wily (15.10). To install OpenJDK 8:
$ sudo apt-get install openjdk-8-jdk
2. Install required packages
$ sudo apt-get install pkg-config zip g++ zlib1g-dev unzip
Download Bazel
Download the Bazel installer for your operating system.
Run the installer
Run the installer:
$ chmod +x bazel-version-installer-os.sh
$ ./bazel-version-installer-os.sh --user
The --user flag installs Bazel to the $HOME/bin directory on your system and sets the .bazelrc path to $HOME/.bazelrc. Use the --help command to see additional installation options.
Bazel installation completion by adding the following line to your ~/.bashrc:
source /root/.bazel/bin/bazel-complete.bash
Set up your environment
If you ran the Bazel installer with the --user flag as above, the Bazel executable is installed in your $HOME/bin directory. It's a good idea to add this directory to your default paths, as follows:
$ export PATH="$PATH:$HOME/bin"
You can also add this command to your ~/.bashrc file.
Compiling from source
If you would like to build Bazel from source, clone the source from GitHub and run ./compile.sh to build it:
$ git clone https://https://www.doczj.com/doc/7c19227786.html,/bazelbuild/bazel.git
$ cd bazel
$ ./compile.sh
This will create a bazel binary in bazel-bin/src/bazel.
Check our continuous integration for the current status of the build.
For more information on using Bazel, see Getting started.
Questions and solutions:
configure: error: zlib not installed
Target //tensorflow/models/image/mnist:convolutional failed to build
在ubuntu软件源里zlib和zlib-devel叫做zlib1g zlib1g.dev
$ sudo apt-get install zlib1g
$ sudo apt-get install zlib1g.dev
直接输入上述命令后还是不能安装。这就要求我们先装ruby.
在ubuntu里，zlib叫zlib1g，相应的zlib-devel叫zlib1g.dev。默认的安装源里没有zlib1g.dev。要在https://www.doczj.com/doc/7c19227786.html,上找。
$sudo apt-get install ruby
然后再装zlib1g-dev就可以了
$sudo apt-get install zlib1g-dev
6.Getting Started with Bazel
Setup
Use the installation instructions to install a copy of Bazel on your machine.
Using a workspace
All Bazel builds take place in a workspace, a directory on your filesystem that contains source code for the software you want to build, as well symbolic links to directories that contain the build outputs (for example, bazel-bin and bazel-out). The location of the workspace directory is not significant, but it must contain a file called WORKSPACE (workspace中包含对外部的依赖) in the top-level directory. The WORKSPACE file may be an empty file, or it may contain references to external
Suppose that you have an existing project in a directory, say, ~/gitroot/my-project/. Create an empty file at ~/gitroot/my-project/WORKSPACE to show Bazel where your project's root is. Creating Your Own Build File
Use the following commands to make a small Java project for this example:
$ # 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 < package com.example; public class ProjectRunner { public static void main(String args[]) { Greeting.sayHi(); } } EOF $ cat > src/main/java/com/example/Greeting.java < package com.example; public class Greeting { public static void sayHi() { System.out.println("Hi!"); } } EOF Bazel figures out what to build by looking for files named BUILD in your workspace, so we'll create a BUILD file in the ~/gitroot/my-project directory. Add the following lines to this BUILD file: # ~/gitroot/my-project/BUILD java_binary( name = "my-runner", srcs = glob(["**/*.java"]), # glob是python中查找符合条件文件的命令 main_class = "com.example.ProjectRunner", ) BUILD files are Python-like scripts. BUILD files cannot contain arbitrary Python, but each build rule looks like a Python function call and you can use "#" to start a single-line comment. java_binary is the type of thing this rule will build. name is the identifier you'll use when you ask bazel to build the binary. srcs lists the Java source files Bazel should compile into a Java binary. glob(["**/*.java"]) is a handy shorthand for "recursively include every file that ends with .java" (see the build encyclopedia for more information about globbing). com.example.ProjectRunner specifies the class that contains the main method. Now you are ready to build your Java binary: $ 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! Congratulations, you've just built your first Bazel target! Adding Dependencies Creating one rule to build your entire project may be sufficient for small projects, but as projects get larger it's important to break up the build into self-contained libraries that can be assembled into a final product. This way the entire world doesn't need to be rebuilt on small changes and Bazel can parallelize more of the build steps. To break up a project, create separate rules for each subcomponent and then make them depend on each other. For the example above, add the following rules to the BUILD file: java_binary( name = "my-other-runner", srcs = ["src/main/java/com/example/ProjectRunner.java"], main_class = "com.example.ProjectRunner", deps = [":greeter"], “:greeter”中没有//表示“greeter”和“my-other-runner”位于同一BUILD文件中。 ) java_library( name = "greeter", srcs = ["src/main/java/com/example/Greeting.java"], ) This builds the same files as before, but in a different way: now Bazel will build the greeter library first and then build my-other-runner. Try building and running //: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! Now if you edit ProjectRunner.java and rebuild my-other-runner, Greeting.java will not need to be recompiled. Using Multiple Packages For larger projects, you will often be dealing with several directories. You can refer to targets defined in other BUILD files using the syntax //path/to/directory:target-name. For example, suppose src/main/java/com/example/ has a cmdline/ subdirectory with the following file: $ mkdir -p src/main/java/com/example/cmdline # cmdline是新建的一个子目录，调用原来的函数。 $ cat > src/main/java/com/example/cmdline/Runner.java < package com.example.cmdline; import com.example.Greeting; public class Runner { public static void main(String args[]) { Greeting.sayHi(); } } EOF Runner.java depends on com.example.Greeting, so we could add a BUILD file at src/main/java/com/example/cmdline/BUILD that contained the following rule: # ~/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"] #“//:greeter”中前面有//表示“greeter”和“runner”位于不同的BUILD文件中。 ) However, by default, build rules are private. This means that they can only be referred to by rules in the same BUILD file. This prevents libraries that are implementation details from leaking into public APIs, but it also means that you must explicitly allow runner to depend on //:greeter. As is, if we build runner we'll get a permissions error: # 构建不同目录下的py文件，系统位于src同一级的目录，被BUIDL的runner.py模块位于“src/main/java/com/example/cmdline”目录下面。 $ 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 You can make a rule visibile to rules in other BUILD files by adding a visibility = level attribute. Change the greeter rule in ~/gitroot/my-project/BUILD to be visible to our new rule: java_library( name = "greeter", srcs = ["src/main/java/com/example/Greeting.java"], visibility = ["//src/main/java/com/example/cmdline:__pkg__"], ) This makes //:greeter visible to any rule in the //src/main/java/com/example/cmdline package. Now we can build and run the runner binary: $ 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! See the build encyclopedia for more visibility options. Deploying If you look at the contents of bazel-bin/src/main/java/com/example/cmdline/runner.jar, you can see that it only contains Runner.class, not its dependencies (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 This works for running locally (the runner script Bazel generates adds the greeter jar to the classpath) but will not work if we want to copy runner.jar to another machine and use it as a standalone binary. To build a self-contained jar that can be deployed, build runner_deploy.jar (or, more generally, $ 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 will contain all of its dependencies. Next Steps You can now create your own targets and compose them. Next, check out the tutorial to learn how to build a server backend, Android app, and iOS app with Bazel. Also see the build encyclopedia and user manual for more information. Let us know if you have any questions! 7.PCRE Perl-compatible regular expression library. PCRE has its own native API, but a set of “wrapper” functions that are based on the POSIX API are also supplied in the library libpcreposix. Note that this just provides a POSIX calling interface to PCRE: the regular expressions themselves still follow Perl syntax and semantics. The header file for the POSIX-style functions is called pcreposix.h. To install PCRE, type thy following command: Perl兼容正则表达式库（PCRE）有自己原生API，但是这一系列封装函是基于POSIX API，而POSIX API也支持libpcreposix库。这样只要提供一个POSIX的调用接口给PCRE后，正则表达式本身仍遵循Perl的语法和语义。POSIX- style的头文件是pcreposix.h，所以，安装PCRE，需要运行以下命令。 Professional Matrix Switcher . 在使用本系统前，请详细阅读本说明书，并请保管好该手册。 注意： 《专业级 VGA 矩阵切换器用户操作手册》以 VGA1209/1218 系列为例作为使用说明， 并可作为其它型号的 VGA 矩阵切换器用户手册。 本手册只作为用户操作指示，不作为维修服务用途。其所述功能截止日期为 2013 年 5 月，该日期之后因 VGA 矩阵切换器版本不断更新，VGA 矩阵切换器 的实际使用可能会与本手册的内容有出入，这种情况将不属错漏，将根据实际情 况另作书面说明。 目 录 一、前面板按键及遥控器说明及操作方法 (3) 二、通讯协议及控制指令代码 (9) 三、控制软件使用 (11) 一、 前面板按键及遥控器说明及操作方法 前面板图示: 按遥控器控制操作方法如下图： 操作界面显示(前面板LCD屏): 待机画面, 在任何状态下按“Cancel”返回此画面: 菜单说明，按 S witch 键进入切换菜单，多次按此键，在以下功能间切换： Switch各界面功能及操作: 一对一单通道切换界面 在箭头前输入想要切换通道的输入端口, 箭头后输入输出端口, 输入两位数会自动执行或按”OK”键执行. N对N多通道切换界面 按”OK”键执行N对N多通道切换, 依次将输入通道1切换到输出通 道1, 输入通道2切换到输出通道2,….输入通道N切换到输出通道N. 如输入输出通道数目非一一对应, 则多余输入或输出通道关闭. 一对N 多通道切换界面 在箭头前输入想要切换的输入通道,将此通道输出到所有输出通道. 巡检功能界面 如图所示依次输入巡检功能各参数,通过巡检开关参数打开或 关闭巡检功能,可通过上或下键在各参数编辑区域跳转,巡检 功能在退出此界面后依然有效,如需改变巡检功能请再次进入此界面设置. 实验算法BP神经网络实验 【实验名称】 BP神经网络实验 【实验要求】 掌握BP神经网络模型应用过程，根据模型要求进行数据预处理，建模，评价与应用； 【背景描述】 神经网络：是一种应用类似于大脑神经突触联接的结构进行信息处理的数学模型。BP神经网络是一种按照误差逆向传播算法训练的多层前馈神经网络，是目前应用最广泛的神经网络。其基本组成单元是感知器神经元。 【知识准备】 了解BP神经网络模型的使用场景，数据标准。掌握Python/TensorFlow数据处理一般方法。了解keras神经网络模型搭建，训练以及应用方法 【实验设备】 Windows或Linux操作系统的计算机。部署TensorFlow，Python。本实验提供centos6.8环境。 【实验说明】 采用UCI机器学习库中的wine数据集作为算法数据，把数据集随机划分为训练集和测试集，分别对模型进行训练和测试。 【实验环境】 Pyrhon3.X，实验在命令行python中进行，或者把代码写在py脚本，由于本次为实验，以学习模型为主，所以在命令行中逐步执行代码，以便更加清晰地了解整个建模流程。 【实验步骤】 第一步：启动python： 1 命令行中键入python。 第二步：导入用到的包，并读取数据： (1).导入所需第三方包 import pandas as pd import numpy as np from keras.models import Sequential from https://www.doczj.com/doc/7c19227786.html,yers import Dense import keras (2).导入数据源,数据源地址:/opt/algorithm/BPNet/wine.txt df_wine = pd.read_csv("/opt/algorithm/BPNet/wine.txt", header=None).sample(frac=1) (3).查看数据 df_wine.head() 1 算法分析与设计课程论文 —通过C语言实现矩阵的相关操作 一．摘要 本文在Microsoft Visual Studio 2010的编译环境下，通过C语言进行一些矩阵的基本操作，包括矩阵的设置，加减乘除，数乘运算。求矩阵的逆等操作。 关键词 矩阵 C语言逆矩阵 二．正文 1.引言 矩阵的相关知识只是是高等数学的基础，但是其庞大的运算量和纷繁的步骤让人却步。虽然有Matlab等软件可以实现矩阵的相关操作，但是我校一些专业并不学习数学实验，故通过C语言实现矩阵的操作也是一种可行的方法，本文列举的了一些矩阵的加减乘除等基本运算规则，还有对矩阵进行转置，也有矩阵求逆的相关操作。 同时，还介绍了行列式的计算，通过运行该程序，可以大大简化行列式的计算量。 2.算法分析 矩阵的初始化 相关概念 在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合，最早来自于方程组的系数及常数所构成的方阵。这一概念由19世纪英国数学家凯利首先提出。 矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。在物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。矩阵的运算是数值分析领域的重要问题。将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。对一些应用广泛而形式特殊的矩阵，例如稀疏矩阵和准对角矩阵，有特定的快速运算算法。 理论分析 在C语言中，可以使用二维数组来描绘一个矩阵。值得注意的是，在二维数组中，必须标明列数，否则编译器就会报错。故二维极其多维数组使用时要注意数组下标。 代码实现 #include .. 主控键盘 （SYSTEM KEYBOARD） 使用说明书 （中文版第二版） Copyright 2009-2012. All Rights Reserved. 注意事项： 1.安装场所 远离高温的热源和环境，避免直接照射。 为确保本机的正常散热，应避开通风不良的场所。 为了防止电击和失火，请勿将本机放置于易燃、易爆的场所。 小心轻放本机避免强烈碰撞、振动等，避免安装在会剧烈震动的场所。避免在过冷、过热的场所间相互搬动本机，以免机器部产生结露，影响机器的使用寿命。 2.避免电击和失火 切记勿用湿手触摸电源开关和本机。 勿将液体溅落在本机上，以免造成机器部短路或失火。 勿将其它设备直接放置于本机上部。 安装过程中进行接线或改线时，都应将电源断开，预防触电。 重要提示： 为了避免损坏，请勿自动拆开机壳，必须委托有资格有专业维修人员在指定的维修单位进行维修。 清洁装置时,请勿使用强力清洗剂,当有灰尘时用干布擦拭装置。 不得在电源电压过高和过低的场合下使用该本机。 务请通读本使用说明书，以便您掌握如正确使用本机。当您读本说明书后，请把它妥善保存好，以备日后参考。如果需要维修，请在当地与经本公司授权的维修站联系。 环境防护： 本机符合电磁辐射标准，对人体无电磁辐射伤害。 申明： 产品的发行和销售由原始购买者在可协议条款下使用； 未经允，任单位和个人不得将该产品全部或部分复制、再生或翻译成其它机器可读形式的电子媒介； 本手册若有任修改恕不另行通知； 因软件版本升级而造成的与本手册不符，以软件为准。 目录 设备概述 (3) 第一部分控制矩阵切换系统 (4) 1.1键盘通电 (4) 1.2键盘操作加锁 (4) 1.3键盘操作解锁 (4) 1.4键盘密码设置 (4) 1.5选择监视器 (5) 1.6选择摄像机 (5) 1.7控制解码器 (5) 1.8控制智能高速球 (6) 1.9操作辅助功能 (7) 1.10系统自由切换 (8) 1.11系统程序切换 (9) 1.12系统同步切换 (10) 1.13系统群组切换 (10) 1.14报警联动 (10) 1.15防区警点 (11) 1.16警点状态 (11) 1.17声音开关 (11) 第二部分控制数字录像机、画面处理器 (11) 2.1进入数字录像机、画面处理器模式 (11) 2.2退出数字录像机、画面处理器模式 (11) 2.3选择数字录像机、画面处理器 (11) 2.4控制数字录像机、画面处理器 (12) 第三部分设置连接 (12) 3.1键盘工作模式 (12) 资源Github，kaggle Python工具库：Numpy，Pandas，Matplotlib，Scikit-Learn，tensorflow Numpy支持大量维度数组与矩阵运算，也针对数组提供大量的数学函数库 Numpy : 1.aaa = Numpy.genfromtxt(“文件路径”,delimiter = “,”,dtype = str)delimiter以指定字符分割，dtype 指定类型该函数能读取文件所以内容 aaa.dtype 返回aaa的类型 2.aaa = numpy.array([5,6,7,8]) 创建一个一维数组里面的东西都是同一个类型的 bbb = numpy.array([[1,2,3,4,5],[6,7,8,9,0],[11,22,33,44,55]]) 创建一个二维数组aaa.shape 返回数组的维度print(bbb[:,2]) 输出第二列 3.bbb = aaa.astype(int) 类型转换 4.aaa.min() 返回最小值 5.常见函数 aaa = numpy.arange(20) bbb = aaa.reshape(4,5) numpy.arange(20) 生成0到19 aaa.reshape(4,5) 把数组转换成矩阵aaa.reshape(4,-1)自动计算列用-1 aaa.ravel()把矩阵转化成数组 bbb.ndim 返回bbb的维度 bbb.size 返回里面有多少元素 aaa = numpy.zeros((5,5)) 初始化一个全为0 的矩阵需要传进一个元组的格式默认是float aaa = numpy.ones((3,3,3),dtype = numpy.int) 需要指定dtype 为numpy.int aaa = np 随机函数aaa = numpy.random.random((3,3)) 生成三行三列 linspace 等差数列创建函数linspace(起始值，终止值，数量) 矩阵乘法： aaa = numpy.array([[1,2],[3,4]]) bbb = numpy.array([[5,6],[7,8]]) print(aaa*bbb) *是对应位置相乘 print(aaa.dot(bbb)) .dot是矩阵乘法行乘以列 print(numpy.dot(aaa,bbb)) 同上 6.矩阵常见操作 数字矩阵/网络视频解码矩阵 使用说明书扫码查看 数字矩阵简要操作说明 （IE 操作） 系统连接示意图 数字视频墙Digital V ideo W all NV R D V R IP C amera 网络摄像机I P Camer a 网 络摄像机NE TWORK N e twork Vi de o R e cod e r 网络视频服务器D i gi ta l Vi de o R e cod e r 硬盘录像机 N e t w o r k V id e o D e c o d e r M a t r ix 网络数字矩阵 Key board 控制键盘(V 20.以上) P C 计算机 NO TEB O OK 计算机 设备连接：数字矩阵的网络口与交换机连接，注：后背板上所有“LAN ”的网络口都需要接上网线。矩阵HDMI 输出口与大屏的HDMI 接口相连接。 操作步骤： 1、设备出厂时，默认IP 地址为192.168.0.200，默认子网掩码：255.255.255.0，默认用户名：admin ，默认密码：admin 。 2、需要将主控计算机IP 地址设置为和数字矩阵同一个网段，如192.168.0.XXX. 3、直接打开浏览器，在地址栏输入192.168.0.200敲回车键，进入矩阵登陆界面，输入用户名密码登陆，建议使用谷歌浏览器。 4、初始化窗口：进入主界面点输出管理，点初始化窗口，可根据现场大屏布局排列来初始化窗口，如现场大屏是行3列4，则初始化时也选择行3列4，分辨率一般选择1080P ，制式可选P 制或N 制。 5、添加信号源：进入主界面点“输入源管理”来添加信号源，此时注意查看输入源IP 段是否与矩阵同一网段，如网段相同，直接点“搜索”，即可自动搜索出同网段所有信号源。点击全选，批量输入用账号密码，此时输入的是信号源的用户名和密码，点确定，再点添加，再点“同步管理”里的上传数据。 6、如网段不相同，则需要修改矩阵的IP 或添加网段，进入主界面点“系统管理”里的系统设置，在左侧点网络设置，弹出IP 地址窗口，点添加IP 地址，输入与信号源相同的网段地址后，点确定再点设置，然后重复第6步骤。注：可添加多个网段。 7、切换图像：进入主界面，选中某输入源按住鼠标左键，在不松开的情况下拖动至某显示区域，则在当前显示区域显示该输入源。也可选中窗口后，双击信号源来调用图像。 8、键盘与配件转接盒通过网线连接，转接盒RS485端接数字矩阵的RS485端口上。键盘协议要选择NVDM 、波特率9600才能与数字矩阵通信，数字矩阵设置好后请重新启动机器， *矩阵与其它设备之间的连接、操作方法，请阅读矩阵操作说明书，有疑问请致电供应商！* 1.简述激活函数的作用 使用激活函数的目的是为了向网络中加入非线性因素；加强网络的表示能力，解决线性模型无法解决的问题 2.那为什么要使用非线性激活函数？ 为什么加入非线性因素能够加强网络的表示能力？——神经网络的万能近似定理 ?神经网络的万能近似定理认为主要神经网络具有至少一个非线性隐藏层，那么只要给予网络足够数量的隐藏单元，它就可以以任意的精度来近似任何从一个有限维空间到另一个有限维空间的函数。 ?如果不使用非线性激活函数，那么每一层输出都是上层输入的线性组合；此时无论网络有多少层，其整体也将是线性的，这会导致失去万能近似的性质 ?但仅部分层是纯线性是可以接受的，这有助于减少网络中的参数。3.如何解决训练样本少的问题？ 1.利用预训练模型进行迁移微调（fine-tuning），预训练模型通常在特征上拥有很好的语义表达。此时，只需将模型在小数据集上进行微调就能取得不错的效果。CV 有 ImageNet，NLP 有 BERT 等。 2.数据集进行下采样操作，使得符合数据同分布。 3.数据集增强、正则或者半监督学习等方式来解决小样本数据集的训练问题。 4.如何提升模型的稳定性？ 1.正则化（L2, L1, dropout）：模型方差大，很可能来自于过拟合。正则化能有效的降低模型的复杂度，增加对更多分布的适应性。 2.前停止训练：提前停止是指模型在验证集上取得不错的性能时停止训练。这种方式本质和正则化是一个道理，能减少方差的同时增加的偏差。目的为了平衡训练集和未知数据之间在模型的表现差异。 3.扩充训练集：正则化通过控制模型复杂度，来增加更多样本的适应性。 4.特征选择：过高的特征维度会使模型过拟合，减少特征维度和正则一样可能会处理好方差问题，但是同时会增大偏差。 5.你有哪些改善模型的思路？ 1.数据角度 增强数据集。无论是有监督还是无监督学习，数据永远是最重要的驱动力。更多的类型数据对良好的模型能带来更好的稳定性和对未知数据的可预见性。对模型来说，“看到过的总比没看到的更具有判别的信心”。 2.模型角度 键盘控制器 （KEYBOARD CONTROLLER）使用说明书Operation Instruction Copyright 2003-2009. All Rights Reserved. 温馨提示: 感谢您使用本公司产品。 为了让您能够尽快熟练的操作本机，请您仔细阅读我们为您配备内容详细的使用说明书，从中您可以获取有关产品安全注意事项、产品介绍以及产品使用方法等方面的知识。当您阅读完说明书后，请将它妥善保存好，以备日后参考。 如果您在产品的使用过程中发现什么问题，请联系产品技术服务人员。谢谢您的合作！ 申明： 在编写此说明书时我们非常小心谨慎，并认为此说明书中所提供的信息是正确可靠的，然而难免会有错误和疏漏之处，请您多加包涵并热切欢迎您的指正。但是我们将不对本手册可能出现的问题和疏漏负责。同时，由于我们无法控制用户对本手册可能造成的误解，因此，将不负责在使用本手册的过程中出现的事故或由此引起的损坏。对于因使用本产品所造成的任何损坏第三方的索赔不负责任。对于因软件的误操作、产品维修、或其它意外情况等引起资料的删改或丢失不负任何责任，也不对由此造成的其它间接损失负责。 本产品的发行和销售由原始购买者在许可协议条款下使用。 未经允许，任何单位和个人不得将本说明书全部或部分复制、再生或翻译成其它机器可读形式的电子媒介。 本说明书若有任何修改恕不另行通知。 因软件版本升级而造成的与本说明书不符，以软件为准。 注：本设备在出厂前已经过严格的质量测试，符合国家电磁辐射标准。 目录 第一部分键盘操作 (4) 1.1 设备概述 (4) 1.2 开机运行 (6) 1.3 键盘登录 (6) 1.4 键盘注销 (6) 第二部分控制监控主机 (6) 2.1 选择监视器 (6) 2.2 选择图像 (7) 2.3 向前、向后切换图像 (7) 2.4 图像保持 (7) 2.5 主机自由切换 (7) 2.6 主机程序切换 (8) 2.7 主机同步切换 (9) 2.8 主机群组切换 (10) 2.9 屏幕分割控制 (10) 2.10 屏幕拼接控制 (10) 2.11 保存主机当前设置 (11) 2.12 网络主机控制 (11) 2.13 监控主机菜单设置 (11) 第三部分控制摄像机 (12) 3.1 选择摄像机 (12) 3.2 控制摄像机方向 (12) 3.3 控制摄像机镜头 (13) 3.4 预置位操作 (13) 3.5 图像返回 (14) 3.6 自动巡视 (14) 3.7 轨迹扫描 (14) 3.8 区域扫描 (15) 3.9 云台自动扫描 (15) 3.10 操作辅助功能 (16) 3.11 智能摄像机菜单设置 (16) 第四部分控制报警主机 (16) 4.1 选择警点 (16) 4.2 防区警点设防、撤防 (16) Tensorflow笔记：第七讲 卷积神经网络 本节目标：学会使用CNN实现对手写数字的识别。 7.1 √全连接NN：每个神经元与前后相邻层的每一个神经元都有连接关系，输入是特征，输出为预测的结果。 参数个数：∑（前层×后层+后层） 一张分辨率仅仅是28x28的黑白图像，就有近40万个待优化的参数。现实生活中高分辨率的彩色图像，像素点更多，且为红绿蓝三通道信息。 待优化的参数过多，容易导致模型过拟合。为避免这种现象，实际应用中一般不会将原始图片直接喂入全连接网络。 √在实际应用中，会先对原始图像进行特征提取，把提取到的特征喂给全连接网络，再让全连接网络计算出分类评估值。 例：先将此图进行多次特征提取，再把提取后的计算机可读特征喂给全连接网络。 √卷积Convolutional 卷积是一种有效提取图片特征的方法。一般用一个正方形卷积核，遍历图片上的每一个像素点。图片与卷积核重合区域内相对应的每一个像素值乘卷积核内相对应点的权重，然后求和，再加上偏置后，最后得到输出图片中的一个像素值。 例：上面是5x5x1的灰度图片，1表示单通道，5x5表示分辨率，共有5行5列个灰度值。若用一个3x3x1的卷积核对此5x5x1的灰度图片进行卷积，偏置项 b=1，则求卷积的计算是：(-1)x1+0x0+1x2+(-1)x5+0x4+1x2+(-1)x3+0x4+1x5+1=1（注意不要忘记加偏置1）。 输出图片边长=（输入图片边长–卷积核长+1）/步长，此图为：（5 – 3 + 1）/ 1 = 3，输出图片是3x3的分辨率，用了1个卷积核，输出深度是1，最后输出的是3x3x1的图片。 √全零填充Padding 有时会在输入图片周围进行全零填充，这样可以保证输出图片的尺寸和输入图片一致。 例：在前面5x5x1的图片周围进行全零填充，可使输出图片仍保持5x5x1的维度。这个全零填充的过程叫做padding。 输出数据体的尺寸=(W?F+2P)/S+1 W：输入数据体尺寸，F：卷积层中神经元感知域，S：步长，P：零填充的数量。 例：输入是7×7，滤波器是3×3，步长为1，填充为0，那么就能得到一个5×5的输出。如果步长为2，输出就是3×3。 如果输入量是32x32x3，核是5x5x3，不用全零填充，输出是（32-5+1）/1=28，如果要让输出量保持在32x32x3，可以对该层加一个大小为2的零填充。可以根据需求计算出需要填充几层零。32=（32-5+2P）/1 +1，计算出P=2，即需填充2 基本操作—矩阵（1） 开始学习这部分内容前，我们先来回顾一下矩阵的都有哪些运算呢？ 一、加法、减法 想一想：两个矩阵相加有什么条件 二、乘法 想一想：矩阵的乘法有什么规则？ 三、矩阵的转置 转置运算的输入：按快捷键Ctrl+1,或直接单击Matrix工具板上的工具按钮. 四、矩阵的行列式 注意：只有方阵才可求行列式 求行列式的运算符的输入：利用快捷键| 或单击Matrix工具板上的按钮. 五、矩阵的逆矩阵 1、回顾学过的高等代数知识： （1）逆矩阵的定义是什么？ （2）怎样的矩阵才有逆矩阵？ 2.求逆运算符的输入：看成-1次方输入或单击Matrix工具板上的按钮 六、向量的运算 1、向量的加法、减法 2、向量的乘法 （1）回顾解析几何知识，两个向量的乘法有哪些？ （2）点乘（数量积、内积） 与矩阵类似直接输入键盘乘号，或单击Matrix工具板上的按钮；其结果为一数字。例:定义两个向量 则它们的内积为 （3）叉乘（向量积、外积） 叉乘运算符的输入：通过快捷键Ctrl+8或单击Matrix工具板上的按钮。叉乘的结果是一个向量。例如u与v的外积为： 3、向量的模 （1）回顾：解析几何知识中向量的模怎么计算呢?（若 () a x,y,z =r ，则222|a|x y z =++r ） 在高等代数中：若向量，则 222 12n ||x x x α=+++L （2）向量的模运算：利用快捷键 | 或单击Matrix 工具板上的 按钮. 例： 根据向量模的定义进行验证： 补充：Matrix 工具板上的 按钮是对向量求其各个分量之和，即对向量 ，单击所得结果为 1 2 n x x x α=+++∑L 一、高清混合矩阵切换器（HDMI） 原理 矩阵的接口分为信号输入\输出接口，INPUT 部分为信号输入端，OUTPUT部分为信号输出端。将信号源（如电脑、DVD机）设备的输出端接入矩阵输入端（INPUT），将矩阵输出端（OUTPUT）接至信号使用设备（如投影机、电视机）的输入接口。 主要按键 1、Cancel键（取消键）在任何页面按“Cancel”都会回到待机画面状态。 2、ENTER键（确认键）相当于电脑的回车键，表示进入、确认 3、VIDEO键（视频键）视频切换模式按钮 4、AUDIO键（音频键）音频切换模式按钮 5、AV键（音视频键）音视频同步切换模式按钮 6、ALL：所有按钮，输入端口对所有输出端口时使用 7、SWITCH切换键按Switch 键进入切换菜单，多次按此键，可以在VIDEO、AUDIO、AV模式切换。 7.1 AV SWITCH，音视频同时切换。在这个状态下，用数字键输入输入通道号和输出通道号，然后按OK（Enter）键，实现切换 7.2 VIDEO SWITCH，只切换视频，而不切换音频 7.3 AUDIO SWITCH，只切换音频，而不切换视频 7.4 AV TO ALL，把某路输入音视频同时切换到所有输出 7.5 AV N TO N，进行一对一切换，1到1,2到2,3到3，······n 到n 其它按键（选择了解） POWER：电源指示灯RUN：矩阵工作指示灯IR：红外遥控接收头窗口SAVE：模式保存按钮MODE：模式调用按钮ALL：所有按钮，输入端口对所有输出端口时使用F1：自定义键（默认一一对应）FUN键（功能键）：进入功能菜单，多次按此键可以在对应功能间切换。 Tensorflow笔记：第四讲 神经网络优化 4.1 √神经元模型：用数学公式表示为：f(∑i x i w i+b)，f为激活函数。神经网络是以神经元为基本单元构成的。 √激活函数：引入非线性激活因素，提高模型的表达力。 常用的激活函数有relu、sigmoid、tanh等。 ①激活函数relu: 在Tensorflow中，用tf.nn.relu()表示 r elu()数学表达式 relu()数学图形 ②激活函数sigmoid：在Tensorflow中，用tf.nn.sigmoid()表示 sigmoid ()数学表达式 sigmoid()数学图形 ③激活函数tanh：在Tensorflow中，用tf.nn.tanh()表示 tanh()数学表达式 tanh()数学图形 √神经网络的复杂度：可用神经网络的层数和神经网络中待优化参数个数表示 √神经网路的层数：一般不计入输入层，层数 = n个隐藏层 + 1个输出层 √神经网路待优化的参数：神经网络中所有参数w 的个数 + 所有参数b 的个数 例如： 输入层 隐藏层 输出层 在该神经网络中，包含1个输入层、1个隐藏层和1个输出层，该神经网络的层数为2层。 在该神经网络中，参数的个数是所有参数w 的个数加上所有参数b 的总数，第一层参数用三行四列的二阶张量表示（即12个线上的权重w ）再加上4个偏置b ；第二层参数是四行两列的二阶张量（）即8个线上的权重w ）再加上2个偏置b 。总参数 = 3*4+4 + 4*2+2 = 26。 √损失函数（loss ）：用来表示预测值（y ）与已知答案（y_）的差距。在训练神经网络时，通过不断改变神经网络中所有参数，使损失函数不断减小，从而训练出更高准确率的神经网络模型。 √常用的损失函数有均方误差、自定义和交叉熵等。 √均方误差mse ：n 个样本的预测值y 与已知答案y_之差的平方和，再求平均值。 MSE(y_, y) = ?i=1n (y?y_) 2n 在Tensorflow 中用loss_mse = tf.reduce_mean(tf.square(y_ - y)) 例如： 预测酸奶日销量y ，x1和x2是影响日销量的两个因素。 应提前采集的数据有：一段时间内，每日的x1因素、x2因素和销量y_。采集的数据尽量多。 在本例中用销量预测产量，最优的产量应该等于销量。由于目前没有数据集，所以拟造了一套数据集。利用Tensorflow 中函数随机生成 x1、 x2，制造标准答案y_ = x1 + x2，为了更真实，求和后还加了正负0.05的随机噪声。 我们把这套自制的数据集喂入神经网络，构建一个一层的神经网络，拟合预测酸奶日销量的函数。 矩阵键盘操作说明 一、系统复位 1按数字键0后，按MON键 2输入99后，按NEXT键 二、键盘视频选择 首先是监视器选择然后是摄像机选择 1、按键盘上的CLEAR键，清除键盘数字输入ENTER区中的数字显示 2、输入所选择的监视器号，该数字在键盘数字输入ENTER区中显示 3、按MON键，该监视器号在键盘监视器MONITOR区中显示 4、同时系统主机将返回该监视器对应的图像号，在键盘的摄像机CAMERA区中显示。 5、输入选择的摄像机号，该数字在键盘数字输入ENTER区中显示 6、按CAM键 7、系统主机将返回该图像号，在键盘的摄像机CAMERA区中显示则选择的图像再选择的 监视器上显示 三、图像区域切换 在指定的监视器上运行一个指定区域的图像切换，该功能可以在任何一个监视上浏览切换所有的图像操作步骤如下： 1、按键盘上CLERA键，清除数字输入ENTER区中的数字显示 2、输入所选择的监视器号，该数字在键盘数字输入ENTER区中显示 3、按MON键，该监视器号在键盘监视器MONITOR区中显示 4、输入区域切换中的开始图像号 5、按ON键，确认开始区域的开始图像 6、输入区域切换中的结束图像号 7按OFF键确定区域切换的结束图像 完成后则该监视器开始区域切换依次按照设定的图像号进行切换如要添加一个图像到切换序列中则： 1和设置区域切换的步骤一样重复1-3步，选择一个监视器，该监视必须已存在一个切换队列 2、输入所希望添加的摄像机图像好，该摄像机图像号必须在系统的最大允许摄像机图像号的范围内 3、按组合键ENTER-ON,ENTER键必须在前面，确定添加的图像。 如要在切换队列中删除一个图像： 1、和设置区域切换的步骤一样重复1-3步，选择一个监视器，该监视必须已存在一个切换队列 2输入所希望添加的摄像机图像好，该摄像机图像号必须在这个序列切换范围内。 3、按组合键ENTER-OFF,ENTER必须在前面，确认删除图像。 四、报警设置 单布防 针对需要布防的防区一个一个的布防，防区布防后，根据监视器与防区触点权限表，自动将该防区分配到与之对应的监视器上。一旦报警，则与之相关的报警监视器就可以对这个报警防区进行响应。具体操作如下1、输入防区号 2、按组合键ARM-ON,ARM键必须先按，对该报警防区进行确认。 全布防。撤防即按ARM-OFF键 1、输入数字键0 矩阵控制键盘操作说明 键盘概述 控制器是智能电视监控系统中的控制键盘，也是个监控系统中人机对话的主要设备。可作为主控键盘，也可作为分控键盘使用。对整个监控系统中的每个单机进行控制。 键盘功能 １．中文/英文液晶屏显示 ２．比例操纵杆（二维、三维可选）可全方位控制云台，三维比例操纵杆可控制摄像机的变倍 ３．摄像机可控制光圈开光、聚集远近、变倍大小 ４．室外云台的防护罩可除尘和除霜 ５．控制矩阵的切换、序切、群组切换、菜单操作等 ６．控制高速球的各种功能，如预置点参数、巡视组、看守卫设置、菜单操作等 ７．对报警设备进行布/撤防及报警联动控制 ８．控制各种协议的云台、解码器、辅助开头设置、自动扫描、 自动面扫及角度设定 ９．在菜单中设置各项功能 10．键盘锁定可避免各种误操作，安全性高 11．内置蜂鸣器桌面上直接听到声音，可判断操作是否有效 技术参数 １．控制模式主控、分控 ２．可接入分控数16个 ３．可接入报警模块数239个 ４．最大报警器地址1024个 ５．最大可控制摄像机数量1024个 ６．最大可控制监视器数量 64个 ７．最大可控制解码器数量 1024个 ８．电源 AC/DC9V（最低500mA的电源） ９．功率 5W 10．通讯协议Matri、PEL-D、PEL-P、VinPD 11．通讯波特率1200 Bit/S,2400 Bit/S,4800 Bit/S ,9600Bit/S， Start bit1,Data bit8,Stop bit1 键盘按键说明 Focus Far 聚焦远 Focus Near 聚焦近 Zoom Tele 变倍大 Zoom Wide 变倍小 DVR 设备操作 DVR 功能键 Shift 用户登入 Login 退出键 Exit 报警记录查询 List 进入键盘主菜单 MENU 启动功能 F1/ON 关闭功能 F2/OFF 液晶显示区 一、软件下载 为了更好的达到预期的效果，本次tensorflow开源框架实验在Linux环境下进行，所需的软件及相关下载信息如下： 1.CentOS 软件介绍： CentOS 是一个基于Red Hat Linux 提供的可自由使用源代码的企业级Linux 发行版本。每个版本的CentOS都会获得十年的支持（通过安全更新方式）。新版本的CentOS 大约每两年发行一次，而每个版本的CentOS 会定期（大概每六个月）更新一次，以便支持新的硬件。这样，建立一个安全、低维护、稳定、高预测性、高重复性的Linux 环境。CentOS是Community Enterprise Operating System的缩写。CentOS 是RHEL（Red Hat Enterprise Linux）源代码再编译的产物，而且在RHEL的基础上修正了不少已知的Bug ，相对于其他Linux 发行版，其稳定性值得信赖。 软件下载： 本次实验所用的CentOS版本为CentOS7,可在CentOS官网上直接下载DVD ISO镜像文件。 下载链接： https://www.doczj.com/doc/7c19227786.html,/centos/7/isos/x86_64/CentOS-7-x86_64-DVD-1611.i so. 2.Tensorflow 软件介绍： TensorFlow是谷歌基于DistBelief进行研发的第二代人工智能学习系统，其命名来源于本身的运行原理。Tensor（张量）意味着N维数组，Flow（流）意味着基于数据流图的计算，TensorFlow为张量从流图的一端流动到另一端计算过程。TensorFlow是将复杂的数据结构传输至人工智能神经网中进行分析和处理过程的系统。TensorFlow可被用于语音识别或图像识别等多项机器深度学习领域，对2011年开发的深度学习基础架构DistBelief进行了各方面的改进，它可在小到一部智能手机、大到数千台数据中心服务器的各种设备上运行。TensorFlow将完全开源，任何人都可以用。 稀疏矩阵基本操作实验报告 一、实验内容 稀疏矩阵的压缩储存结构，以及稀疏矩阵的三元组表表示方法下的转置、相加、相 乘等算法 二、实验目的 1. 熟悉数组、矩阵的定义和基本操作 2. 熟悉稀疏矩阵的储存方式和基本运算 3. 理解稀疏矩阵的三元组表类型定义，掌握稀疏矩阵的输入、输出和转置算法 三、实验原理 1. 使用三元组储存矩阵中的非零元素（三元组分别储存非零元素的行下标，列下标和 元素值）。除了三元组表本身，储存一个稀疏矩阵还需要额外的三个变量，分别储 存矩阵的非零元个数，矩阵的行数和矩阵的列数。 2. 稀疏矩阵的创建算法： 第一步：根据矩阵创建一个二维数组，表示原始矩阵 第二步：取出二维数组中的元素（从第一个元素开始取），判断取出元素是否为非零元素，如果为非零元素，把该非零元素的数值以及行下标和列下表储存到三元数 组表里，否则取出下一个元素，重复该步骤。 第三步：重复第二步，知道二维数组中所有的元素已经取出。 3. 稀疏矩阵倒置算法： 第一步：判断进行倒置的矩阵是否为空矩阵，如果是，则直接返回错误信息。 第二步：计算要倒置的矩阵每列非零元素的数量，存入到num 数组（其中num[i] 代表矩阵中第i 列非零元素的个数）。以及倒置后矩阵每行首非零元的位置，存入cpot 数组中（其中cpot 表示倒置后矩阵每行非零元的位置，对应表示原矩阵每列中第 一个非零元的位置）。 第三步：确定倒置后矩阵的行数和列数。 第四步：取出表示要导致矩阵中三元组表元素{e, I, j} （第一次取出第一个，依次取出下一个元素），从第二步cpot 数组中确定该元素倒置后存放的位置（cpot[j] ），把该元素的行下标和列下标倒置以后放入新表的指定位置中。cpot[j] 变量加一。 第五步：重复第四步，直到三元组表中所有的元素都完成倒置。 第六步：把完成倒置运算的三元组表输出。 4. 稀疏矩阵加法算法： 第一步：检查相加两个矩阵的行数和列数是否相同，如果相同，则进入第二步，否 则输出错误信息。 第二步：定义变量i 和j，用于控制三元组表的遍历。 第三步：比较变量矩阵M 中第i 个元素和矩阵N 中第j 个元素，如果两个元素是同一行元素，如果不是则进入第四步，如果是，再继续比较两个元素是否为同一列元 素，如果是，把两个元素值相加，放到三元组表中；否则把列下表小的元素依次放 到三元组表中。进入第五步 第四步：如果矩阵M 中第i 个元素的行下标大于矩阵N 中第j 个元素的行下标，则把矩阵N 中第j 个元素所在行的所有非零元素添加到三元组表中；如果矩阵M 中第 shProfessional Matrix 矩阵切换器 用户手册 RGB矩阵切换器 VGA矩阵切换器 A V 矩阵切换器 数模高清混插矩阵在使用本系统前，请详细阅读本说明书.并请保管好该手册 目录 前言 (4) 一、清单、外形及安装说明 (5) 1、包装清单 (5) 2、普通矩阵前后面板 (6) 3、数模高清混插矩阵前面板 (7) 4、机架安装说明 (10) 二、功能特点及主要技术指标 (11) 一、普通矩阵 (11) 1、功能与用途 (11) 2、主要技术指标 (11) 二、数模高清混插矩阵 (12) 3、功能与用途 (12) 2、主要技术指标 (13) 三、系统连接图 (15) 四、矩阵的操作 (16) 1、指示灯及面板按键 (16) 2、遥控器的使用 (19) 3、显示屏及显示的画面 (20) 4、菜单总表及一般操作方法 (22) 5、各菜单说明 (24) 6、矩阵的切换 (33) 7、控制软件 (35) 五、注意事项及故障处理 (52) 1、注意事项 (52) 2、常见故障检修 (52) 附录A、串口控制协议 (53) 1、通信接口 (53) 2、控制命令 (54) 附录B、编程说明 (61) 1、用 VB 编程控制矩阵 (61) 2、用 VC 编程控制矩阵 (62) 3、用C# 编程控制矩阵 (64) 4、用 Delphi 编程控制矩阵 (66) 前言 感谢您使用本公司矩阵切换器，使用时请注意以下事项： 1．本产品所使用电源必须有电源保护地线，输入、输出设备的电源保护地线要为同一保护地线。确保设备的输入电源为AC 100～240V/50Hz。 2．使用计算机控制本产品时必须保证控制计算机与本产品的连接电源保护地线是同一个地线。 3．使用本产品时严禁带电插拔输入、输出信号线及RS232 通讯接口线。 4．严禁将本产品放在过热或过冷的地方工作，应保持工作环境通风良好。严禁将化学物品洒在本产品上。 5．严禁对本产品的机械和电路设计进行更改或增减任何部件，否则厂家对此产生的任何结果不负责任。 6．严禁擅自打开机箱外壳，机器内有交流220V 高压，以免发生触电危险。需要维修时应交厂家进行维修。 嵌入 本文档介绍了嵌入这一概念，并且举了一个简单的例子来说明如何在TensorFlow 中训练嵌入，此外还说明了如何使用TensorBoard Embedding Projector 查看嵌入（真实示例）。前两部分适合机器学习或TensorFlow 新手，而Embedding Projector 指南适合各个层次的用户。 有关这些概念的另一个教程，请参阅《机器学习速成课程》的“嵌入”部分。 嵌入是从离散对象（例如字词）到实数向量的映射。例如，英语字词的300 维嵌入可能包括： blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259) blues: (0.01396, 0.11887, -0.48963, ..., 0.033483, -0.10007, 0.1158) orange: (-0.24776, -0.12359, 0.20986, ..., 0.079717, 0.23865, -0.014213) oranges: (-0.35609, 0.21854, 0.080944, ..., -0.35413, 0.38511, -0.070976) 这些向量中的各个维度通常没有固有含义，机器学习所利用的是向量的位置和相互之间的距离这些整体模式。 嵌入对于机器学习的输入非常重要。分类器（更笼统地说是神经网络）适用于实数向量。它们训练密集向量时效果最佳，其中所有值都有助于定义对象。不过，机器学习的很多重要输入（例如文本的字词）没有自然的向量表示。嵌入函数是将此类离散输入对象转换为有用连续向量的标准和有效方法。 嵌入作为机器学习的输出也很有价值。由于嵌入将对象映射到向量，因此应用可以将向量空间中的相似性（例如欧几里德距离或向量之间的角度）用作一项强大而灵活的标准来衡量对象相似性。一个常见用途是找到最近的邻点。例如，下面是采用与上述相同的字词嵌入后，每个字词的三个最近邻点和相应角度： blue: (red, 47.6°), (yellow, 51.9°), (purple, 52.4°) blues: (jazz, 53.3°), (folk, 59.1°), (bluegrass, 60.6°) orange: (yellow, 53.5°), (colored, 58.0°), (bright, 59.9°) oranges: (apples, 45.3°), (lemons, 48.3°), (mangoes, 50.4°) 这样应用就会知道，在某种程度上，苹果和橙子（相距45.3°）的相似度高于柠檬和橙子（相距48.3°）。 第一章基础知识 Tensorflow交流qq千人群：328216239 1.1Tensors 目前在TensorFlow中的数据结构是tensor。一个tensor可以是任意维度的张量。一个tensor的等级就是它维度的数量。下面是一些tensor的例子： 3#a rank0tensor;a scalar with shape[] [1.,2.,3.]#a rank1tensor;a vector with shape[3] [[1.,2.,3.],[4.,5.,6.]]#a rank2tensor;a matrix with shape[2,3] [[[1.,2.,3.]],[[7.,8.,9.]]]#a rank3tensor with shape[2,1,3] 1.2The Computational Graph 你可以把Tensorflow的核心程序看成由2部分组成： 1.2.1建立计算图 1.2.2运行计算图 计算图是将一系列tensorflow的操作放到图的节点上。让我们建立一个简单的计算图。每个节点将0个或者更多的tensor作为输入，然后输出一个tensor。有一种节点的类型是常量。就像所有tensorflow中的常量一样，它不需要输入，输出一个内部储存的值。我们可以按照如下方法创造2个浮点类型的tensors节点node1和node2： node1=tf.constant(3.0,dtype=tf.float32) node2=tf.constant(4.0)#also tf.float32implicitly print(node1,node2) 最后的打印效果如下： Tensor("Const:0",shape=(),dtype=float32)Tensor("Const_1:0",shape=(), dtype=float32) 我们注意到这并没有像我们预期的意义输出值3.0和4.0。相反，他们输出了只有在evaluate的时候才会生成3.0和4.0的节点。为了evaluate这些节点，我VGA矩阵操作说明书V1.0
BP神经网络实验——【机器学习与算法分析 精品资源池】
c语言实现矩阵的相关操作
监控矩阵键盘说明书
数据挖掘常用资源及工具
数字矩阵(简要操作说明)
题库深度学习面试题型介绍及解析--第7期
矩阵键盘完整使用说明书
人工智能实践：Tensorflow笔记 北京大学 7 第七讲卷积网络基础 (7.3.1) 助教的Tenso
基本操作矩阵
矩阵操作说明书
人工智能实践：Tensorflow笔记 北京大学 4 第四讲神经网络优化 (4.6.1) 助教的Tenso
矩阵键盘操作说明
矩阵控制键盘操作说明
人工智能tensorflow实验报告
稀疏矩阵基本操作实验报告
矩阵切换器说明书
TensorFlow编程指南 嵌入
Tensorflow入门学习1
相关主题
文本预览