更新：黑客新闻这里讨论。

The TensorFlow Computation Graph

其中一个最惊人的组件TensorFlow架构是计算图可以使用被序列协议缓冲。此计算图遵循良好定义的格式（点击这里for the proto files) and describes the computation that you specify (it can be a Deep Learning model like a CNN, a simple Logistic Regression or even any computation you want). For instance, here is an example of a very simple TensorFlow computation graph that we will use in this tutorial (using TensorFlow Python API):

进口tensorflow与tf.Session（）作为编码扩频通信TF：input_placeholder = tf.placeholder（tf.int32，1，名称= “输入”）sub_op = tf.sub（input_placeholder，tf.constant（2，D型= tf.int32））add_op = tf.add（sub_op，tf.constant（5，D型细胞= tf.int32））输出= tf.add（add_op，tf.constant（100，D型细胞= tf.int32），名称= “输出”）tf.train.write_graph（sess.graph_def， “”， “graph.pb”，真）

正如你所看到的，这是一个非常简单的计算图表。亚洲金博宝首先，我们定义将一直保持输入张量的占位符，并且我们指定应该发生的使用该输入张量作为输入数据的计算后。在这里我们也可以看到，我们定义这个图的两个重要的节点，一个被称为“输入”（上述的占位符），而另一个被称为“产量“，将举行最后的计算结果。该曲线图是一样的下面的公式一个标量：，其中I有意添加的冗余操作，以在后面看到LLVM恒定传播。

在代码的最后一行，我们坚持这个计算图（包括常量值）成序列化的protobuf文件。最后真正参数是输出的文本表示来代替二进制，所以它会产生以下人类可读输出protobuf的文件（I为了简洁省略它的一部分）：

节点{名： “输入” OP “占位符” ATTR {键： “D型” 值{类型：DT_INT32}} ATTR {键： “形状” 值​​{形状{暗淡{大小：1}}}}}节点{名： “常量” 运算： “常量” ATTR {键： “D型” 值{类型：DT_INT32}} {ATTR键： “值” 的值{张量{D型细胞：DT_INT32 tensor_shape {} int_val：2}}}} --->（为简洁起见省略）<---节点{名： “输出” OP： “添加” 输入： “添加” 输入： “Const_2” ATTR {键： “T” 值{类型：DT_INT32}}} {版本生产者：9}

这是一个非常简单的图亚洲金博宝表，图表TensorFlow是其实从来没有这么简单，because TensorFlow models can easily contain more than 300 nodes depending on the model you’re specifying, specially for Deep Learning models.

我们将使用上图展示了如何我们可以为这个简单的图形使用JIT本机代码LLVM框架。

LLVM的前端，IR和后端

The LLVM framework is a really nice, modular and complete ecosystem for building compilers and toolchains. A very nice description of the LLVM architecture that is important for us is shown in the picture below:

（The picture above is just a small part of the LLVM architecture, for a comprehensive description of it, pleasesee the nice article由克里斯·拉特纳写的书AOSA）

Looking in the image above, we can see that LLVM provides a lot of core functionality, in the left side you see that many languages can write code for their respective language frontends, after that it doesn’t matter in which language you wrote your code, everything is transformed into a very powerful language calledLLVM IR（LLVM中间表示) which is as you can imagine, a intermediate representation of the code just before the assembly code itself. In my opinion, the IR is the key component of what makes LLVM so amazing, because it doesn’t matter in which language you wrote your code (or even if it was a JIT’ed IR), everything ends in the same representation, and then here is where the magic happens, because the IR can take advantage of the LLVM optimizations (also known as变换和分析通行证）。

After this IR generation, you can feed it into any LLVM backend to generate native code for any architecture supported by LLVM (such as x86, ARM, PPC, etc) and then you can finally execute your code with the native performance and also after LLVM optimization passes.

在使用LLVM为了JIT代码，所有你需要的是编程建立IR，创建一个执行引擎转换（在执行时间）的IR为本地代码，获取你有JIT'ed，最后执行它的函数的指针。我会在这里使用的Python LLVM结合称为llvmlite，which is very Pythonic and easy to use.

JIT’ing TensorFlow Graph using Python and LLVM

现在，让我们使用LLVM和Python进行JIT的TensorFlow计算图表。这是绝不是全面贯彻实施，这是非常简单的亚洲金博宝方法，即假设某些事情过于简单化：一个整数闭合类型，只是一些TensorFlow操作，也是一个单个标量的支持，而不是高秩张量。

所以，让我们开始建立我们的JIT代码;首先，让我们来导入所需的包，初始化一些LLVM子系统，也定义了TensorFlow整数类型的LLVM各自类型：

从进口的ctypes CFUNCTYPE，c_int的进口tensorflow作为从tensorflow.core.framework进口graph_pb2 google.protobuf进口TEXT_FORMAT从tensorflow.core.framework进口types_pb2从tensorflow.python.framework进口OPS TF导入llvmlite.ir为L1进口llvmlite.binding如LLVM llvm.initialize（）llvm.initialize_native_target（）llvm.initialize_native_asmprinter（）TYPE_TF_LLVM = {types_pb2.DT_INT32：ll.IntType（32），}

在此之后，让我们来定义一个类来打开TensorFlow出口图形，也宣告一个方法来获得由名图的节点：

类TFGraph（对象）的：def __init __（个体，文件名= “graph.pb”，二进制=假）：self.graph_def = graph_pb2.GraphDef（）与打开（ “graph.pb”， “RB”）为f：如果二进制：self.graph_def.ParseFromString（f.read（））其他：text_format.Merge（f.read（），self.graph_def）高清get_node（个体经营，名）：为节点self.graph_def.node：如果节点。命名==名称：返回节点

让我们先来定义我们的主要功能将是代码的起点开始：

DEF run_main（）：图表= TFGraph（ “graph.pb”，假）input_node = graph.get_node（ “输入”）output_node = graph.get_node（ “输出”）INPUT_TYPE = TYPE_TF_LLVM [input_node.attr [ “D型”]。型] output_type = TYPE_TF_LLVM [output_node.attr [ “T”]。式]模块= ll.Module（）func_type = ll.FunctionType（output_type，[INPUT_TYPE]）FUNC = ll.Function（模块，func_type，名称='tensorflow_graph'）func.args [0]。名称= '输入' bb_entry = func.append_basic_block（' 条目'）ir_builder = ll.IRBuilder（bb_entry）

As you can see in the code above, we open the serialized protobuf graph and then get the input and output nodes of this graph. After that we also map the type of the both graph nodes (input/output) to the LLVM type (from TensorFlow integer to LLVM integer). We start then by defining a LLVM Module, which is the top level container for all IR objects. One module in LLVM can contain many different functions, here we will create just one function that will represent the graph, this function will receive as input argument the input data of the same type of the input node and then it will return a value with the same type of the output node.

在此之后，我们通过创建函数的入口块并使用该块我们实例IR生成器，这是一个对象，将提供给我们的构建块TensorFlow图形JIT'ing操作开始。

现在让我们来定义，会做转换TensorFlow节点成LLVM IR的实际工作中的作用：

DEF build_graph（ir_builder，图形，节点）：如果node.op == “添加”：left_op_node = graph.get_node（node.input [0]）= right_op_node graph.get_node（node.input [1]）= left_op build_graph（ir_builder，图形，left_op_node）right_op = build_graph（ir_builder，图形，right_op_node）返回ir_builder.add（left_op，right_op）如果node.op == “子”：left_op_node = graph.get_node（node.input [0]）= right_op_nodegraph.get_node（node.input [1]）= left_op build_graph（ir_builder，图形，left_op_node）right_op = build_graph（ir_builder，图形，right_op_node）返回ir_builder.sub（left_op，right_op）如果node.op == “占位”：function_args =在function_args为ARG ir_builder.function.args：如果arg.name == node.name：回报ARG提高RuntimeError（ “！输入[{}]未找到” 格式（node.name））如果node.op == “常量”：llvm_const_type = TYPE_TF_LLVM [node.attr [ “D型”]键入] const_value = node.attr [ “值”] tensor.int_val [0] = llvm_const_value llvm_const_type（const_value）返回llvm_const_value

在这个函数中，我们接收的参数IR生成器，我们之前创建的图形类和输出节点。该函数将递归通过IR生成器来构建LLVM IR。在这里你可以看到，我只能从TensorFlow图实施的加/减/占位符和const操作，只是为了能够支持我们先前定义的图表。

在那之后，我们只需要定义将采取LLVM模块，然后创建将做转换IR成原生x86代码的辛勤工作之前执行过LLVM IR的LLVM优化执行引擎的功能：

DEF create_engine（模块）：特征= llvm.get_host_cpu_features（）变平（）llvm_module = llvm.parse_assembly（STR（模块））目标= llvm.Target.from_default_triple（）target_machine = target.create_target_machine（优化= 3，设有=特征）发动机= llvm.create_mcjit_compiler（llvm_module，target_machine）engine.finalize_object（）打印target_machine.emit_assembly（llvm_module）返回发动机

在上面的代码，你可以看到，我们首先得到的CPU功能（SSE等）到一个列表，之后我们从模块解析LLVM IR，然后我们创建一个使用最大优化级别发动机（选择= 3，大致equivalent to the GCC -O3 parameter), we’re also printing the assembly code (in my case, the x86 assembly built by LLVM).

And here we just finish ourrun_main()功能：

RET = build_graph（ir_builder，图形，output_node）ir_builder.ret（RET）与打开（ “output.ir”， “W”）为f：f.write（STR（模块））发动机= create_engine（模块）func_ptr =发动机.get_function_address（ “tensorflow_graph”）cfunc = CFUNCTYPE（c_int的，c_int的）（func_ptr）RET = cfunc（10）打印 “执行输出：{}”。格式（RET）

正如你可以在上面的代码中看到，我们只是调用build_graph（）方法然后使用IR生成器添加的“RET” LLVM IR指令（RET =返程）返回刚刚创建基于所述TensorFlow图表的IR函数的输出。我们也在这里写IR输出到外部文件，我将在后面使用这个LLVM IR文件为其他不同的体系结构，如ARM架构创建本地组装。最后，只得到本机代码的函数地址，创建一个Python包装了这个功能，然后用参数“10”，这将是输入数据，然后输出生成的输出值调用它。

这就是它，当然，这仅仅是一个过于简单化，但现在我们知道有我们TensorFlow车型JIT的优势。

输出LLVM IR，优化和多个体系结构的优点（ARM，PPC，86等）

For instance, lets create the LLVM IR (using the code I shown above) of the following TensorFlow graph:

进口tensorflow与tf.Session（）作为编码扩频通信TF：input_placeholder = tf.placeholder（tf.int32，1，名称= “输入”）sub_op = tf.sub（input_placeholder，tf.constant（2，D型= tf.int32））add_op = tf.add（sub_op，tf.constant（5，D型细胞= tf.int32））输出= tf.add（add_op，tf.constant（100，D型细胞= tf.int32），名称= “输出”）tf.train.write_graph（sess.graph_def， “”， “graph.pb”，真）

产生的LLVM IR是下面这一个：

;的moduleId = “” 目标三重= “未知未知未知” 目标datalayout = “” 定义I32 @ “tensorflow_graph”（I32％ “输入”）{条目：” 3" （％）=子I32％ “输入”，2％“0.4" =加I32％” 3" ，5％ “5" =加I32％” 4" ，100保留123-132％”。5" }

正如你所看到的，LLVM IR看起来很像一个汇编代码，但这不是最后的汇编代码，这只是一个非优化的IR呢。刚生成的x86汇编代码之前，LLVM运行了很大的优化越过LLVM IR，它会做的事情，如死代码消除，常量传播，等等。这里是最后的原生x86汇编代码LLVM生成的所述TensorFlow图的上面LLVM IR：

的.text .file “<字符串>” .globl tensorflow_graph .align伪16，0×90 .TYPE tensorflow_graph，@功能tensorflow_graph：.cfi_startproc利尔103（％RDI），％eax中retq .Lfunc_end0：.size tensorflow_graph，.Lfunc_end0-tensorflow_graph .cfi_endproc.section伪 “.note.GNU栈”， “”，@ PROGBITS

正如你所看到的，优化的代码删除了很多冗余的操作，并最终只是做的103加法运算，这是我们在图中所定义的计算正确的简化。对于大图，你可以看到，这些优化可真厉害，因为我们重用Compiler optimizations that were developed for years在我们的机器学习模型计算。

您还可以使用所谓的“有限责任公司”一LLVM工具，可以采取一个LLVM IR文件和生成汇编为你需要的任何其他平台，例如，下面的命令行会为ARM架构的本机代码：

LLC -O3 out.ll -march =手臂-o sample.s

The outputsample.s文件是以下之一：

的.text .syntax统一.eabi_attribute 67， “2.09” @ Tag_conformance .eabi_attribute 6,1 @ Tag_CPU_arch .eabi_attribute 8,1 @ Tag_ARM_ISA_use .eabi_attribute 17，1 @ Tag_ABI_PCS_GOT_use .eabi_attribute 20,1 @ Tag_ABI_FP_denormal .eabi_attribute 21，1 @ Tag_ABI_FP_exceptions。eabi_attribute 23，3 @ Tag_ABI_FP_number_model .eabi_attribute 34，1 @ Tag_CPU_unaligned_access .eabi_attribute 24，1 @ Tag_ABI_align_needed .eabi_attribute 25,1 @ Tag_ABI_align_preserved .eabi_attribute 38，1 @ Tag_ABI_FP_16bit_format .eabi_attribute 14，0 @ Tag_ABI_PCS_R9_use .file “out.ll” .globltensorflow_graph .align伪2 .TYPE tensorflow_graph，％功能tensorflow_graph：@ @tensorflow_graph .fnstart @ BB＃0：@％条目添加R0，R0，＃103 MOV PC，LR .Lfunc_end0：.size tensorflow_graph，.Lfunc_end0-tensorflow_graph .fnend。部 “.note.GNU堆叠”， “”，％PROGBITS

As you can see above, the ARM assembly code is also just a “add” assembly instruction followed by a return instruction.

这是非常好的，因为我们可以采取LLVM架构的天然优势。举例来说，今天的ARM刚刚宣布的ARMv8-A具有可伸缩矢量扩展（SVE）that will support2048位矢量，他们是已经工作上补丁LLVM。在未来，一个非常好的除了LLVM将LLVM开发通行证进行分析和改造，将考虑到的机器学习模型的性质。

就是这样，我希望你喜欢的文章！是真的真棒，你可以使用Python，LLVM和TensorFlow几行做什么。

更新2016年8月22日乔什克朗茨只是指出他酷的项目Called Likely on黑客新闻的讨论。

更新2016年8月22日：TensorFlow团队实际上是工作的一个JIT（如果他们使用LLVM我不知道，但似乎最合理的方式在我看来去）。在他们的论文，也有对未来的工作，我在这里举一个非亚洲金博宝常重要的声明：

“我们也有一些具体的方向，提高TensorFlow的性能。这样的一个方向，是我们在刚刚即时编译器，可以采取一个TensorFlow执行的子图，也许关于张量的典型尺寸和形状的一些运行时分析信息，并可以生成此子优化的常规前期工作。这个编译器会明白执行多个优化，如环融合的，阻断和平铺为局部性，专业化为特定的形状和大小等的语义”-TensorFlow白皮书

Full code

从进口的ctypes CFUNCTYPE，c_int的进口tensorflow作为从tensorflow.core.framework进口graph_pb2 google.protobuf进口TEXT_FORMAT从tensorflow.core.framework进口types_pb2从tensorflow.python.framework进口OPS TF导入llvmlite.ir为L1进口llvmlite.binding如LLVM llvm.initialize（）llvm.initialize_native_target（）llvm.initialize_native_asmprinter（）TYPE_TF_LLVM = {types_pb2.DT_INT32：ll.IntType（32），}类TFGraph（对象）的：def __init __（个体，文件名= “graph.pb”，二进制=假）：self.graph_def = graph_pb2.GraphDef（）与打开（ “graph.pb”， “RB”）为f：如果二进制：self.graph_def.ParseFromString（f.read（））其他：text_format.Merge（f.read（），self.graph_def）高清get_node（个体经营，名）：为节点self.graph_def.node：如果节点。命名==名称：返回节点DEF build_graph（ir_builder，图形，节点）：如果node.op == “添加”：left_op_node = graph.get_node（node.input [0]）= right_op_node graph.get_node（node.input [1]）= left_op build_graph（ir_builder，图形，left_op_node）right_op = build_graph（ir_builder，图形，right_op_node）返回ir_builder.add（left_op，right_op）如果node.op == “子”：left_op_node = graph.get_node（node.input [0]）= right_op_nodegraph.get_node（node.input [1]）= left_op build_graph（ir_builder，图形，left_op_node）right_op = build_graph（ir_builder，图形，right_op_node）返回ir_builder.sub（left_op，right_op）如果node.op == “占位”：function_args =在function_args为ARG ir_builder.function.args：如果arg.name == node.name：回报ARG提高RuntimeError（ “！输入[{}]未找到” 格式（node.name））如果node.op == “常量”：llvm_const_type = TYPE_TF_LLVM [node.attr [ “D型”]键入] const_value = node.attr [ “值”] tensor.int_val [0] = llvm_const_value llvm_const_type（const_value）返回llvm_const_valueDEF create_engine（模块）：特征= llvm.get_host_cpu_features（）变平（）llvm_module = llvm.parse_assembly（STR（模块））目标= llvm.Target.from_default_triple（）target_machine = target.create_target_machine（优化= 3，设有=特征）发动机= llvm.create_mcjit_compiler（llvm_module，target_machine）engine.finalize_object（）打印target_machine.emit_assembly（llvm_module）返回发动机 def run_main(): graph = TFGraph("graph.pb", False) input_node = graph.get_node("input") output_node = graph.get_node("output") input_type = TYPE_TF_LLVM[input_node.attr["dtype"].type] output_type = TYPE_TF_LLVM[output_node.attr["T"].type] module = ll.Module() func_type = ll.FunctionType(output_type, [input_type]) func = ll.Function(module, func_type, name='tensorflow_graph') func.args[0].name = 'input' bb_entry = func.append_basic_block('entry') ir_builder = ll.IRBuilder(bb_entry) ret = build_graph(ir_builder, graph, output_node) ir_builder.ret(ret) with open("output.ir", "w") as f: f.write(str(module)) engine = create_engine(module) func_ptr = engine.get_function_address("tensorflow_graph") cfunc = CFUNCTYPE(c_int, c_int)(func_ptr) ret = cfunc(10) print "Execution output: {}".format(ret) if __name__ == "__main__": run_main()