Chris_zhangrx
Chris_zhangrx

[Pytorch 源码阅读] ——torch.trace.jit 接口 C++ 源码阅读

文章目录

      • 前言
      • torch::jit::Type
      • ClassType
      • c10::ivalue::Object
      • torch::jit::Object
      • torch::jit::Module
      • 转化过程
      • 总结

前言

本文主要是从 torch.jit.trace 接口，打开 Pytorch JIT 的大门，介绍在正常 nn.module 经过 Trace 之后形成 scriptModule 的过程和涉及到的 C++ 类，因为涉及到的内容蛮多的，所以这里就从源码的角度介绍了一些相对比较重要，或者是可以帮助我们理解的类。

在开始学习之前，不知道大家有没有想过一个看似简单但是也未必那么好回答的问题。编译语言为什么要分数据类型？

其实查找的大概意思就是，在计算机内部，为了实现不同的功能，会有不同的计算电路，对于这些不同电路对应到上层就是不同的数据类型。所以接触变成语言最基本的就是要了解它的数据类型。

torch::jit::Type

首先最重要的是类型。所以在梳理 jit 代码中，最后开始就落到了 torch::jit::Type 这个类上，这个基类表示不同的类型，目前类型可以表示的类型共 33 种，也包含了 IValue 的 Tag 中的类型。

// torch/include/ATen/core/jit_type_base.h 
#define C10_FORALL_TYPES(_) \
  _(AnyType)                \
  _(EnumType)               \
  _(AnyEnumType)            \
  _(TensorType)             \
  _(StorageType)            \
  _(TupleType)              \
  _(ListType)               \
  _(DictType)               \
  _(NumberType)             \
  _(FloatType)              \
  _(ComplexType)      \
  _(FutureType)             \
  _(RRefType)               \
  _(IntType)                \
  _(NoneType)               \
  _(StringType)             \
  _(GeneratorType)          \
  _(QuantizerType)          \
  _(BoolType)               \
  _(OptionalType)           \
  _(VarType)                \
  _(DeviceObjType)          \
  _(StreamObjType)          \
  _(FunctionType)           \
  _(ClassType)              \
  _(PyObjectType)           \
  _(CapsuleType)            \
  _(InterfaceType)          \
  _(QSchemeType)            \
  _(LayoutType)             \
  _(ScalarTypeType)         \
  _(AnyListType)            \
  _(AnyTupleType)           \
  _(AnyClassType)

enum class TypeKind {
#define DEFINE_TYPE(T) T,
  C10_FORALL_TYPES(DEFINE_TYPE)
#undef DEFINE_TYPE
};

Type 类型主要是定义了上面可 TypeKind 枚举，然后可以查询到相关的打印 name，是否是 SubType，是否是 module ，各类 cast 函数，然后就是获取数组中的 Type。下面是部分源码：

struct TORCH_API Type : std::enable_shared_from_this {
 private:
  TypeKind kind_;
 protected:
  Type(TypeKind kind) : kind_(kind) {}
 public:
  virtual bool isSubtypeOfExt(const TypePtr& rhs, std::ostream* why_not) const;
   virtual std::string str() const = 0;
  template 
  std::shared_ptr cast() {
    if (T::Kind == kind()) {
      return std::static_pointer_cast(shared_from_this());
    }
    return nullptr;
  }
  
  virtual at::ArrayRef containedTypes() const {
    return {};
  }
};

ClassType

在 pytorch/pytorch/torch/include/ATen/core/jit_type.h 路径下，对 Type 的各种子类进行了实现，这里比较重要的就是 TensorType 和 ClassType，鉴于前面已经介绍了关于 Tensor 的内容，这里就先不展开说了，重点介绍一下 ClassType。

类中定义了一个辅助类 ClassAttribute，类属性 ClassAttribute 主要是围绕了：name，kind(AttributeKind)，Type(TypePtr)，所以有了下面的类定义：

struct TORCH_API ClassAttribute {
  public:
  ClassAttribute(AttributeKind kind,
  TypePtr attributeType,
  std::string attributeName) :
    kind_(kind),
    attributeType_(attributeType),
    attributeName_(std::move(attributeName)) {}

  AttributeKind getKind() const {
    return kind_;
  }

  TypePtr getType() const {
    return attributeType_;
  }

  const std::string& getName() const {
    return attributeName_;
  }

  private:
  AttributeKind kind_;
  TypePtr attributeType_;
  std::string attributeName_;
};

其中：

enum class AttributeKind {
  BUFFER,
  PARAMETER,
  REGULAR_ATTRIBUTE
};

classType 的类定义也很长，下面罗列出相关内容：

struct TORCH_API ClassType : public NamedType {
  // Create a class type with name `name` and its methods stored in `cu`.
  static ClassTypePtr create(
      c10::optional qualifiedName,
      std::weak_ptr cu,
      bool is_module = false,
      std::string doc_string = "",
      std::vector unresolved_class_attributes = {});
  
  const std::vector& methods() const;
  std::string str() const override
  bool isSubtypeOfExt(const TypePtr& rhs, std::ostream* why_not) const override;
  ...
  //—————————————————————— 属性的操作 ————————————————————————
  TypePtr findAttribute(const std::string& name) const;
  TypePtr getAttribute(const std::string& name) const;
  size_t numAttributes() const;
  size_t addOrCheckAttribute(
      const std::string& name,
      TypePtr ty,
      bool is_parameter = false,
      bool is_buffer = false) 
  ...
 //—————————————————————— 常量节点的操作 ————————————————————————
  size_t addConstant(const std::string& name, const IValue& value);
  IValue getConstant(const std::string& name) const;
  at::ArrayRef constantValues() const；
  ...
 //—————————————————————— 函数相关的操作 ————————————————————————
  void addForwardPreHook(torch::jit::Function* pre_hook_ptr);
  void addForwardHook(torch::jit::Function* hook_ptr);
  const std::vector& getForwardHooks() const;
  const std::vector& getForwardPreHooks() const;
  void addMethod(torch::jit::Function* method);
  torch::jit::Function* findMethod(const std::string& name) const;
  torch::jit::Function& getMethod(const std::string& name) const;
  torch::jit::Function* findHook(const std::string& name) const;
  private:
  std::vector constantNames_;
  std::vector constantValues_;
  
  std::vector attributes_;
  std::vector attributeTypes_;
  
  std::vector methods_;
  std::vector staticmethods_;
  
  std::vector forward_hooks_;
  std::vector forward_pre_hooks_;
  ...
};

其中 QualifiedName 类用来代表形如：foo.bar.baz 这种格式的名字。 CompilationUnit 类可以看做是带名字的函数的 List，里面存储了类的函数，并提供了相关接口去遍历和调用相关函数。可以看到一个 ClassType 提供的类似于真实的类，除了继承的 Type 类的共用方法，主要成员函数集中在 属性（ClassAttribute），类的方法（Method，hook，prehook），还有常量节点（constant）的相关操作，最后就是构造时需要有一个 compilation_unit。

c10::ivalue::Object

前面定义了表示类的类型 ClassType，有了类类型可以创建的对象了。首先要介绍的是定义在 ivalue_inl.h 中的 c10::ivalue::Object，不是很长，下面先贴出类定义：

// torch/include/ATen/core/ivalue_inl.h
struct C10_EXPORT ivalue::Object final : c10::intrusive_ptr_target {
 public:
  Object(StrongTypePtr type, size_t numSlots) : type_(std::move(type)) {
    slots_.resize(numSlots);
  }

  static c10::intrusive_ptr create(
      StrongTypePtr type,
      size_t numSlots) {
    return c10::make_intrusive(std::move(type), numSlots);
  }
  // slot 相关操作，就是 vector
  void setSlot(size_t slot, IValue v) {
    if (slot >= slots_.size()) {
      resizeObject(slot);
    }
    slots_[slot] = std::move(v);
  }
  
  const IValue& getSlot(size_t slot) const {
       return slots_[slot];
  }
  void unsafeRemoveSlot(size_t slot);
  // Attribute 也是一些 IValue，为了可以访问 module 的属性
  IValue getAttr(const std::string& name) const;
  void setAttr(const std::string& name, IValue v);
  void unsafeRemoveAttr(const std::string& name);

  std::string name() const;

  const std::vector& slots() const {
    return slots_;
  }
  std::shared_ptr type() const;
  // 深浅拷贝函数
  c10::intrusive_ptr copy() const;
  c10::intrusive_ptr deepcopy() const;

 private:
  void resizeObject(size_t slot);
  StrongTypePtr type_;
  std::vector slots_;
};

// 上述部分成员函数实现在： pytorch/pytorch/aten/src/ATen/core/ivalue.cpp, 感兴趣的读者可以自行阅读。
 
  
其中 StrongTypePtr 表示：
 
  
// torch/include/ATen/core/ivalue.h
struct TORCH_API StrongTypePtr {
  StrongTypePtr(
      std::shared_ptr cu,
      std::shared_ptr type);

  std::shared_ptr cu_;
  std::shared_ptr type_;
};

 
  
可以看到 ivalue::Object 类中主要是定义了一个 vector 的 slot_ 变量，用其来定义 module （或者说是 ClassType）的 Attribute，底层是 slot_，将 slot 包一层就是 attr。 然后外面 Module 添加 parameters 或者是 buffers 底层调用的都是 addAttribute，通过标志位来表示是否是 parameter / buffer / 其他属性。
 
  
然后就是torch::jit::Object 类了。
 
  
torch::jit::Object
 
  
// pytorch/pytorch/torch/csrc/jit/api/object.h

using ObjectPtr = c10::intrusive_ptr;

struct TORCH_API Object {
  Object() = default;
  Object(ObjectPtr _ivalue) : _ivalue_(std::move(_ivalue)) {}
  Object(std::shared_ptr cu, const c10::ClassTypePtr& type);
  Object(
      c10::QualifiedName,
      std::shared_ptr cu,
      bool shouldMangle = false);
  ObjectPtr _ivalue() const;

  c10::ClassTypePtr type() const {
    return _ivalue()->type();
  }
  
  void setattr(const std::string& name, c10::IValue v) {
    if (_ivalue()->type()->hasConstant(name)) {
      TORCH_CHECK(
          false,
          "Can't set constant '",
          name,
          "' which has value:",
          _ivalue()->type()->getConstant(name));
    } else if (auto slot = _ivalue()->type()->findAttributeSlot(name)) {
      const c10::TypePtr& expected = _ivalue()->type()->getAttribute(*slot);
      TORCH_CHECK(
          v.type()->isSubtypeOf(expected),
          "Expected a value of type '",
          expected->repr_str(),
          "' for field '",
          name,
          "', but found '",
          v.type()->repr_str(),
          "'");
      _ivalue()->setSlot(*slot, std::move(v));
    } else {
      TORCH_CHECK(false, "Module has no attribute '", name, "'");
    }
  }
  
  
c10::IValue attr(const std::string& name) const {
    if (auto r = _ivalue()->type()->findAttributeSlot(name)) {
      return _ivalue()->getSlot(*r);
    }
    if (auto r = _ivalue()->type()->findConstantSlot(name)) {
      return _ivalue()->type()->getConstant(*r);
    }
    std::stringstream err;
    err << _ivalue()->type()->repr_str() << " does not have a field with name '"
        << name.c_str() << "'";
    throw ObjectAttributeError(err.str());
  }

c10::IValue attr(const std::string& name, c10::IValue or_else) const {
    if (auto r = _ivalue()->type()->findAttributeSlot(name)) {
      return _ivalue()->getSlot(*r);
    }
    if (auto r = _ivalue()->type()->findConstantSlot(name)) {
      return _ivalue()->type()->getConstant(*r);
    }
    return or_else;
  }

bool hasattr(const std::string& name) const {
    return _ivalue()->type()->hasAttribute(name) ||
        _ivalue()->type()->hasConstant(name);
  }

  // 每一个 object 都有自己的 method
  Method get_method(const std::string& name) const {
    if (auto method = find_method(name)) {
      return *method;
    }
    AT_ERROR("Method '", name, "' is not defined.");
  }

  const std::vector get_methods() const {
    return c10::fmap(type()->methods(), [&](Function* func) {
      return Method(_ivalue(), func);
    });
  }
  
  c10::optional find_method(const std::string& basename) const;
  
  template 
  IValue run_method(const std::string& method_name, Types&&... args) {
    return get_method(method_name)({IValue(std::forward(args))...});
  }
  
  void define(const std::string& src, const ResolverPtr& resolver = nullptr);

  size_t num_slots() const {
    return _ivalue()->slots().size();
  }
  // 拷贝
  Object copy() const;
  Object deepcopy() const;
  
  private:
  mutable ObjectPtr _ivalue_;
};

 
  
torch::jit::Object 类是在 c10::ivalue::object 的基础上拓展的，例如相关拷贝实现就是直接调用的 c10::ivalue::object 实现。
 
  
可以看到这里的 torch::jit::Object 类的构造函数，其主要是由 ClassType 中指针构建出来的，cu 和 ClassTypePtr，从上面类的定义可以看出，torch::jit::Object 类主要来自 c10::ivalue::object 实现，相关操作主要来自 c10::ivalue::object 中包含的 ClassType 类接口。 _ivalue()->type() 。进行基本的 attr 和 method 的操作。
 
  
继承关系：ClassType::NamedType::Type，综上，其实 torch::jit::Object 类，主要就是通过 ivalue::Object + ClassType 来进行一些属性操作 和 Method 操作。包括对 Object 对象的深浅拷贝。 其中有一个 CompilationUnit 类型的 cu 指针，是创建对象的时候就有的，其实一个包含 Funciton 的 list。
 
  
torch::jit::Module
 
  
首先要明确一下的概念：
 
  
“模块”是对某些函数或算法实现的抽象，一个 Module 类主要有以下几个属性：
 
  
     
   
  • Buffers: 主要是不记录梯度的 tensor，一般在前向传播中会进行更新，例如 BatchNorm 算子的 mean 和 variance，这类的运行统计数据。
    •  
   
  • Parameters: 会记录梯度的 tensor，例如通常会在反向传播中会更新的权重。
    •  
   
  • 其他状态：不一定是 tensor 类型，但是在 Module 实现或者配置中需要用到的状态量。
    •  
  
 
  
与 ClassType 中的 AttributeKind 是对应的，注意当 Module clone 的时候将会深拷贝。Module 提供了 register_parameter 和 register_buffer 来分别注册两种不同的 Tensor。
 
  
Module 类是可以嵌套的，即一个 Module 可以有 submodule。
 
  
基于上面的了解，下面就进入到 torch::jit::Module 的类，来探索相关操作。
 
  
// pytorch/pytorch/torch/csrc/jit/api/module.h
struct TORCH_API Module : public Object {
  // 一堆初始化函数，这里初始化函数基本包含了 Object 的初始化样式
  explicit Module(c10::QualifiedName class_name);
  Module(std::shared_ptr cu, const c10::ClassTypePtr& type);
  Module() = default;
  Module(
      c10::QualifiedName,
      std::shared_ptr cu,
      bool shouldMangle = false);
  Module(ModulePtr module_value) : Object(std::move(module_value)) {}
  ~Module() = default;

  // 主要的 forward 函数
  IValue forward(std::vector inputs) {
    return get_method("forward")(std::move(inputs));
  }
  
  // 相关 Module 重要元素注册
 void register_buffer(const std::string& name, at::Tensor v) {
    bool is_param = false;
    bool is_buffer = true;
    type()->addOrCheckAttribute(name, TensorType::get(), is_param, is_buffer);
    _ivalue()->setAttr(name, std::move(v));
  }

  void register_parameter(
      const std::string& name,
      at::Tensor v,
      bool is_buffer) {
    type()->addOrCheckAttribute(name, TensorType::get(), !is_buffer, is_buffer);
    _ivalue()->setAttr(name, std::move(v));
  }
  
  // 递归应用相关 fn
  void apply(const std::function& fn);
  ...

  // 相关实际内容获取
  buffer_list buffers(bool recurse = true) const;
  named_buffer_list named_buffers(bool recurse = true) const;

  module_list children() const; // direct modules
  named_module_list named_children() const;
  module_list modules() const; // all modules, including this one, recursively
  named_module_list named_modules() const;

  // all tensors involved in gradient optimization
  parameter_list parameters(bool recurse = true) const;
  named_parameter_list named_parameters(bool recurse = true) const;

  // all members of the object, similar to iterating over dir(obj) in python
  attribute_list attributes(bool recurse = true) const;
  named_attribute_list named_attributes(bool recurse = true) const;
  
  // dump 函数
  void dump(
      bool print_method_bodies,
      bool print_attr_values,
      bool print_param_values) const;
   ...
     
  // 还包含其他的 to(), save()，copy()，deepcopy(),clone()，clone_method() 等成员函数，这里就不展开介绍了。
};

 
  
这里当我们向 torch.jit.trace 里面传入一个 nn.module，中间 .py 中会转成 script module，函数定义为：
 
  
class TestArangeModel(torch.nn.Module):
    def __init__(self):
        super(TestArangeModel, self).__init__()
        self.conv1 = torch.nn.Conv2d(3, 3, 3, stride=(1, 1), padding=(1, 1),bias=False)
        self.conv2 = torch.nn.Conv2d(3, 3, 3, stride=(1, 1), padding=(1, 1))

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        return x

m = TestArangeModel()
input = torch.randn(1,3,5,5)
traced = torch.jit.trace(m,input)

 
  
使用 dump 接口打印出来的传入 jit::Module 大概长这样：
 
  
module __torch__.TestArangeModel {
  parameters {
  }
  attributes {
    training = True
    _is_full_backward_hook = None
    conv1 = <__torch__.torch.nn.modules.conv.Conv2d object at 0x557569c9f300>
    conv2 = <__torch__.torch.nn.modules.conv.___torch_mangle_0.Conv2d object at 0x557569cb4080>
  }
  methods {
  }
  submodules {
    module __torch__.torch.nn.modules.conv.Conv2d {
      parameters {
        weight = ...
      }
      attributes {
        weight = ...
        training = True
        _is_full_backward_hook = None
      }
      methods {
      }
      submodules {
      }
    } // 下面的 QualifiedName 就是： __torch__.torch.nn.modules.conv.___torch_mangle_0.Conv2d
    module __torch__.torch.nn.modules.conv.___torch_mangle_0.Conv2d {
      parameters {
        weight = ...  // parameter 和 buffer 都在 parameters 中，底层会有表示
        bias = ...
      }
      attributes {
        weight = ... // 注册的时候parameter 和 buffer也会同事加入到 attr 中，同其他属性一起
        bias = ...
        training = True
        _is_full_backward_hook = None
      }
      methods {   // method
      }
      submodules { // module 本身是可嵌套的
      }
    }
  }
}

 
  
torch.jit.trace 主要就是通过将 torch::jit::Module 转成 torch::jit::Graph 的这样一个过程，重点就是转成 Graph 结构之后对图做的一系列变换，通过中间一个名为 TracingState 的类来追踪中间的状态，最后返回一个转换后的 torch::jit::Graph。
 
  
转化过程
 
  
上面对涉及到的类进行了一些介绍，有了上面的内容，我们在本部分主要说明一下 jit.trace 接口在 C++ 部分工作的大概流程。
 
  
由上面可以看到初始的时候 Module 里面是没有 methods 的，（可能是因为是从 nn.Module 转过来的，本身类定义 nn.Module 就没有 method 相关的内容）。接下来就一步步探究如何构建成图的，包括最后 Module 会长啥样。
 
  
     
   
  1. 首先会递归的将 module 对象的所有 attribute 还有输入输出依次用节点表示出来。
    2.  
  
 
  
graph(%self : __torch__.___torch_mangle_3.TestArangeModel,
      %x : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
  %1 : bool = prim::TracedAttr[scope="__module.training"]()
  %2 : NoneType = prim::TracedAttr[scope="__module._is_full_backward_hook"]()
  %3 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d = prim::TracedAttr[scope="__module.conv1"]()
  %4 : Float(3, 3, 3, 3, strides=[27, 9, 3, 1], requires_grad=1, device=cpu) = prim::TracedAttr[scope="__module.conv1.weight"]()
  %5 : bool = prim::TracedAttr[scope="__module.conv1.training"]()
  %6 : NoneType = prim::TracedAttr[scope="__module.conv1._is_full_backward_hook"]()
  %7 : __torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d = prim::TracedAttr[scope="__module.conv2"]()
  %8 : Float(3, 3, 3, 3, strides=[27, 9, 3, 1], requires_grad=1, device=cpu) = prim::TracedAttr[scope="__module.conv2.weight"]()
  %9 : Float(3, strides=[1], requires_grad=1, device=cpu) = prim::TracedAttr[scope="__module.conv2.bias"]()
  %10 : bool = prim::TracedAttr[scope="__module.conv2.training"]()
  %11 : NoneType = prim::TracedAttr[scope="__module.conv2._is_full_backward_hook"]()
  return ()

 
  
上述 Module 转化成 Graph 之后就是这个效果。
 
  
经过传入的 traced 函数之后，会得到：
 
  
graph(%self : __torch__.TestArangeModel,
      %x : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
  %1 : bool = prim::TracedAttr[scope="__module.training"]()
  %2 : NoneType = prim::TracedAttr[scope="__module._is_full_backward_hook"]()
  %3 : __torch__.torch.nn.modules.conv.Conv2d = prim::TracedAttr[scope="__module.conv1"]()
  %weight.1 : Float(3, 3, 3, 3, strides=[27, 9, 3, 1], requires_grad=1, device=cpu) = prim::TracedAttr[scope="__module.conv1.weight"]()
  %5 : bool = prim::TracedAttr[scope="__module.conv1.training"]()
  %6 : NoneType = prim::TracedAttr[scope="__module.conv1._is_full_backward_hook"]()
  %7 : __torch__.torch.nn.modules.conv.___torch_mangle_0.Conv2d = prim::TracedAttr[scope="__module.conv2"]()
  %weight : Float(3, 3, 3, 3, strides=[27, 9, 3, 1], requires_grad=1, device=cpu) = prim::TracedAttr[scope="__module.conv2.weight"]()
  %bias : Float(3, strides=[1], requires_grad=1, device=cpu) = prim::TracedAttr[scope="__module.conv2.bias"]()
  %10 : bool = prim::TracedAttr[scope="__module.conv2.training"]()
  %11 : NoneType = prim::TracedAttr[scope="__module.conv2._is_full_backward_hook"]()
   = prim::TracedModuleForward[scope="__module.conv1"](), scope: __module.conv1
    block0():
      %13 : NoneType = prim::Constant(), scope: __module.conv1
      %14 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %15 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %16 : int[] = prim::ListConstruct(%14, %15), scope: __module.conv1
      %17 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %18 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %19 : int[] = prim::ListConstruct(%17, %18), scope: __module.conv1
      %20 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %21 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %22 : int[] = prim::ListConstruct(%20, %21), scope: __module.conv1
      %23 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %24 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %25 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %26 : int[] = prim::ListConstruct(%24, %25), scope: __module.conv1
      %27 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %28 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %29 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %30 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %31 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %input : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=1, device=cpu) = aten::_convolution(%x, %weight.1, %13, %16, %19, %22, %23, %26, %27, %28, %29, %30, %31), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      -> ()
   = prim::TracedModuleForward[scope="__module.conv2"](), scope: __module.conv2
    block0():
      %33 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %34 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %35 : int[] = prim::ListConstruct(%33, %34), scope: __module.conv2
      %36 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %37 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %38 : int[] = prim::ListConstruct(%36, %37), scope: __module.conv2
      %39 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %40 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %41 : int[] = prim::ListConstruct(%39, %40), scope: __module.conv2
      %42 : bool = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %43 : int = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %44 : int = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %45 : int[] = prim::ListConstruct(%43, %44), scope: __module.conv2
      %46 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %47 : bool = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %48 : bool = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %49 : bool = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %50 : bool = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      %51 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=1, device=cpu) = aten::_convolution(%input, %weight, %bias, %35, %38, %41, %42, %45, %46, %47, %48, %49, %50), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
      -> ()
  return (%51)

 
  
接下来就是要经过各种 pass 来对当前这个 graph 做进一步的处理。要进入 pytorch/pytorch/torch/csrc/jit/passes/fixup_trace_scope_blocks.cpp 中的相关优化 pass 函数：
 
  
void FixupTraceScopeBlocks(std::shared_ptr& graph, Module* self) {
  if (self) {
    ConvertTracedAttrReferences().run(graph);
  } else {
    for (Node* n : graph->nodes()) {
      TORCH_INTERNAL_ASSERT(n->kind() != prim::TracedAttr);
    }
  }
  MakeDefsDominateUses().run(graph->block());
  convertReturnsToTuples(graph->block());
  if (!self) {
    // We have no Module, so we're just going to inline everything.
    // This should give us a totally flat graph.
    inlineScopeBlocks(graph->block());
    // For TracedFork nodes
    lambdaLiftBlocksAndConvertToGraph(graph->block());
    runCleanupPasses(graph);
  } else {
    lambdaLiftBlocksAndConvertToGraph(graph->block());
    createMethodCalls(graph);
    runCleanupPasses(self);
    // `graph` isn't referenced in `self` yet, so we need to run
    // this separately
    runCleanupPasses(graph);
  }
}

 
  
上面函数主要思路还是处理图中节点的关系，然后再处理 prim::Tracedxxx 类型的节点，大概做了以下几个步骤：
 
  
     
   
  1.  
    首先递归的找到 prim::TracedModuleForward 类型节点，然后找到带有同样 scope 的 prim::TracedAttr 从输入的 module 中获得相关子 module 的节点，然后作为参数传入 prim::TracedModuleForward 类型，并且添加 block0 的输入信息。
     
    2.  
   
  2.  
    然后添加必要的 prim::GetAttr 来替换有实际作用的 prim::TracedAttr 节点，并替换对应的输出
     
    3.  
   
  3.  
    删除没用的 prim::TracedAttr 节点
     
    4.  
   
  4.  
    给 TracedModuleForward 直接 = 号的形式，加输入输出名字 type等信息
     
    5.  
   
  5.  
    处理多输出到一个 tuple
     
    6.  
   
  6.  
    将 TracedModuleForward 的 block 拿来构建一个新的子图，然后将这个子图转成 node 的 Subgraph 属性：
     
    类似于将图从：
     
    7.  
  
 
  
%59 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = prim::TracedModuleForward[scope="__module.conv1"](%conv1), scope: __module.conv1
  block0(%self.3 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d):
    %weight.5 : Tensor = prim::GetAttr[name="weight"](%self.3)
    %13 : NoneType = prim::Constant(), scope: __module.conv1
    %14 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %15 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %16 : int[] = prim::ListConstruct(%14, %15), scope: __module.conv1
    %17 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %18 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %19 : int[] = prim::ListConstruct(%17, %18), scope: __module.conv1
    %20 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %21 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %22 : int[] = prim::ListConstruct(%20, %21), scope: __module.conv1
    %23 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %24 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %25 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %26 : int[] = prim::ListConstruct(%24, %25), scope: __module.conv1
    %27 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %28 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %29 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %30 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %31 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %input : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = aten::_convolution(%x, %weight.5, %13, %16, %19, %22, %23, %26, %27, %28, %29, %30, %31), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    -> (%input)

 
  
变成了：
 
  
%59 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = prim::TracedModuleForward[scope="__module.conv1", Subgraph=](%conv1, %x), scope: __module.conv1
  block0(%self.3 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d):
    %weight.5 : Tensor = prim::GetAttr[name="weight"](%self.3)
    %13 : NoneType = prim::Constant(), scope: __module.conv1
    %14 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %15 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %16 : int[] = prim::ListConstruct(%14, %15), scope: __module.conv1
    %17 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %18 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %19 : int[] = prim::ListConstruct(%17, %18), scope: __module.conv1
    %20 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %21 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %22 : int[] = prim::ListConstruct(%20, %21), scope: __module.conv1
    %23 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %24 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %25 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %26 : int[] = prim::ListConstruct(%24, %25), scope: __module.conv1
    %27 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %28 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %29 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %30 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %31 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    %input : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = aten::_convolution(%x, %weight.5, %13, %16, %19, %22, %23, %26, %27, %28, %29, %30, %31), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
    -> (%input)

 
  
block 已经作为属性传入 prim::TracedModuleForward 这个 node 了，这里就可以删除了：
 
  
%59 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = prim::TracedModuleForward[scope="__module.conv1", Subgraph=](%conv1, %x), scope: __module.conv1

 
  
最后将 prim::TracedModuleForward 转换成 prim::CallMethod 节点，并用 n->output()->replaceAllUsesWith(retval); 将新节点替换老节点：
 
  
%61 : Tensor = prim::CallMethod[name="forward"](%conv1, %x)

 
  
最后图的改变就是：
 
  
graph(%self.1 : __torch__.___torch_mangle_3.TestArangeModel,
      %x : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
  %conv2 : __torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d = prim::GetAttr[name="conv2"](%self.1)
  %conv1 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d = prim::GetAttr[name="conv1"](%self.1)
  %61 : Tensor = prim::CallMethod[name="forward"](%conv1, %x)
  %59 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = prim::TracedModuleForward_0[scope="__module.conv1"](%conv1, %x), scope: __module.conv1
  %60 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = prim::TracedModuleForward_1[scope="__module.conv2"](%conv2, %61), scope: __module.conv2
  return (%60)

 
  
最后就是删除不用节点：
 
  
graph(%self.1 : __torch__.___torch_mangle_3.TestArangeModel,
      %x : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
  %conv2 : __torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d = prim::GetAttr[name="conv2"](%self.1)
  %conv1 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d = prim::GetAttr[name="conv1"](%self.1)
  %61 : Tensor = prim::CallMethod[name="forward"](%conv1, %x)
  %60 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = prim::TracedModuleForward_0[scope="__module.conv2"](%conv2, %61), scope: __module.conv2
  return (%60)

 
  
总结来说优化 Pass 主要是做了下面几件事：
 
  
     
   
  • 用prim::GetAttr来替换 prim::TracedAttr，并删除多余的 prim::TracedAttr 节点。（多余是没有使用者）
    •  
   
  • 处理 prim::TracedModuleForward 节点，主要是先梳理好输入输出信息，然后将 block 转换为算子的 Subgraph 属性， 最后用 prim::CallMethod 节点来替换prim::TracedModuleForward 节点。
    •  
  
 
  
在使用 prim::CallMethod 节点替换prim::TracedModuleForward 节点时，会同时将 block 转换为算子的 Subgraph 中的结果插入到 Submodule 的 methods 中，这样传入的 Module 也在改变。
 
  
重复上面步骤，最后我们 trace 出来的图也就是下面的样子了：
 
  
graph(%self.1 : __torch__.___torch_mangle_3.TestArangeModel,
      %x : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
  %conv2 : __torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d = prim::GetAttr[name="conv2"](%self.1)
  %conv1 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d = prim::GetAttr[name="conv1"](%self.1)
  %61 : Tensor = prim::CallMethod[name="forward"](%conv1, %x)
  %62 : Tensor = prim::CallMethod[name="forward"](%conv2, %61)
  return (%62)

 
  
最后再看一下转化后的 module：
 
  
module __torch__.___torch_mangle_3.TestArangeModel {
  parameters {
  }
  attributes {
    training = True
    _is_full_backward_hook = None
    conv1 = <__torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d object at 0x559c691cd470>
    conv2 = <__torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d object at 0x559c691cdcb0>
  }
  methods {
    method forward {
      graph(%self.1 : __torch__.___torch_mangle_3.TestArangeModel,
            %x : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
        %conv2 : __torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d = prim::GetAttr[name="conv2"](%self.1)
        %conv1 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d = prim::GetAttr[name="conv1"](%self.1)
        %61 : Tensor = prim::CallMethod[name="forward"](%conv1, %x)
        %62 : Tensor = prim::CallMethod[name="forward"](%conv2, %61)
        return (%62)
  
    }
  }
  submodules {
    module __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d {
      parameters {
        weight = ...
      }
      attributes {
        weight = ...
        training = True
        _is_full_backward_hook = None
      }
      methods {
        method forward {
          graph(%self.3 : __torch__.torch.nn.modules.conv.___torch_mangle_1.Conv2d,
                %x : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
            %weight.5 : Tensor = prim::GetAttr[name="weight"](%self.3)
            %2 : NoneType = prim::Constant(), scope: __module.conv1
            %3 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %4 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %5 : int[] = prim::ListConstruct(%3, %4), scope: __module.conv1
            %6 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %7 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %8 : int[] = prim::ListConstruct(%6, %7), scope: __module.conv1
            %9 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %10 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %11 : int[] = prim::ListConstruct(%9, %10), scope: __module.conv1
            %12 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %13 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %14 : int = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %15 : int[] = prim::ListConstruct(%13, %14), scope: __module.conv1
            %16 : int = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %17 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %18 : bool = prim::Constant[value=0](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %19 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %20 : bool = prim::Constant[value=1](), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %input : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = aten::_convolution(%x, %weight.5, %2, %5, %8, %11, %12, %15, %16, %17, %18, %19, %20), scope: __module.conv1 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            return (%input)
      
        }
      }
      submodules {
      }
    }
    module __torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d {
      parameters {
        weight = ...
        bias = ...
      }
      attributes {
        weight = ...
        bias = ...
        training = True
        _is_full_backward_hook = None
      }
      methods {
        method forward {
          graph(%self : __torch__.torch.nn.modules.conv.___torch_mangle_2.Conv2d,
                %22 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu)):
            %bias : Tensor = prim::GetAttr[name="bias"](%self)
            %weight : Tensor = prim::GetAttr[name="weight"](%self)
            %3 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %4 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %5 : int[] = prim::ListConstruct(%3, %4), scope: __module.conv2
            %6 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %7 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %8 : int[] = prim::ListConstruct(%6, %7), scope: __module.conv2
            %9 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %10 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %11 : int[] = prim::ListConstruct(%9, %10), scope: __module.conv2
            %12 : bool = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %13 : int = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %14 : int = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %15 : int[] = prim::ListConstruct(%13, %14), scope: __module.conv2
            %16 : int = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %17 : bool = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %18 : bool = prim::Constant[value=0](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %19 : bool = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %20 : bool = prim::Constant[value=1](), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            %21 : Float(1, 3, 5, 5, strides=[75, 25, 5, 1], requires_grad=0, device=cpu) = aten::_convolution(%22, %weight, %bias, %5, %8, %11, %12, %15, %16, %17, %18, %19, %20), scope: __module.conv2 # /home2/anaconda3/lib/python3.7/site-packages/torch/nn/modules/conv.py:443:0
            return (%21)
        }
      }
      submodules {
      }
    }
  }
}

 
  
总结
 
  
torch.jit.trace 就是一个将 module 转化成 jit graph 的一个过程，上面介绍了这个过程：
 
  
     
   
  • 递归处理 Module 的属性和子图，以此来生成 Graph 的节点
    •  
   
  • 再对这些中间 Graph 的节点进行转化，处理和优化，最后得到一个我们可以打印出来的 torch.jit.Graph
    •  
  
 
  
其中大量的工作都是对 Graph 中的节点进行操作，有需要的同学可以沿着上面介绍的内容，进一步深入源码阅读更多自己需要的内容。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(源码阅读,C++,深度学习)

        

            

                
    
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 【JS】执行时长(100分) |思路参考+代码解析（C++）
                        l939035548
JS算法数据结构c++
                        
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • C++ | Leetcode C++题解之第409题最长回文串
                        Ddddddd_158
经验分享C++Leetcode题解
                        
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
    
                    
    • 
                    
  • C++菜鸟教程 - 从入门到精通 第二节
                        DreamByte
c++
                        
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • C++ lambda闭包消除类成员变量
                        barbyQAQ
c++c++java算法
                        
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
    
                    
    • 
                    
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码）
                        mmz1207
c++csp
                        
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧
                        Lenyiin
C++修炼全景指南技术指南c++算法stl
                        
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
    
                    
    • 
                    
  • 20个新手学习c++必会的程序 输出*三角形、杨辉三角等（附代码）
                        X_StarX
c++学习算法大学生开发语言数据结构
                        
    示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
    
                    
    • 
                    
  • C++八股
                        Petrichorzncu
八股总结c++开发语言
                        
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
    
                    
    • 
                    
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】
                        汉子萌萌哒
CCFnoi算法数据结构c++
                        
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现
                        Lenyiin
C++修炼全景指南技术指南c++数据结构stl
                        
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • c++ opencv4.3 sift匹配
                        图像处理大大大大大牛啊
图像处理opencv实战代码讲解opencvsiftc++opencv4特征点
                        
    c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
    
                    
    • 
                    
  • 推荐3家毕业AI论文可五分钟一键生成！文末附免费教程！
                        小猪包333
写论文人工智能AI写作深度学习计算机视觉
                        
    在当前的学术研究和写作领域，AI论文生成器已经成为许多研究人员和学生的重要工具。这些工具不仅能够帮助用户快速生成高质量的论文内容，还能进行内容优化、查重和排版等操作。以下是三款值得推荐的AI论文生成器：千笔-AIPassPaper、懒人论文以及AIPaperPass。千笔-AIPassPaper千笔-AIPassPaper是一款基于深度学习和自然语言处理技术的AI写作助手，旨在帮助用户快速生成高质
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
                        Lenyiin
技术指南C++修炼全景指南c++list链表stl
                        
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    
                    
    • 
                    
  • AI大模型的架构演进与最新发展
                        季风泯灭的季节
AI大模型应用技术二人工智能架构
                        
    随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
    
                    
    • 
                    
  • c++ 内存处理函数
                        heeheeai
c++开发语言
                        
    在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
    
                    
    • 
                    
  • 【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】
                        XWWW668899
C++基本概念c++c语言开发语言青少年编程
                        
    文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
    
                    
    • 
                    
  • [实践应用] 深度学习之模型性能评估指标
                        YuanDaima2048
深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
                        
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
    
                    
    • 
                    
  • [实践应用] 深度学习之优化器
                        YuanDaima2048
深度学习工具使用pytorch深度学习人工智能机器学习python优化器
                        
    文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
    
                    
    • 
                    
  • C++常见知识掌握
                        nfgo
c++开发语言
                        
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
    
                    
    • 
                    
  • 生成式地图制图
                        Bwywb_3
深度学习机器学习深度学习生成对抗网络
                        
    生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
    
                    
    • 
                    
  • metaRTC5.0 API编程指南(一)
                        metaRTC
metaRTCc++c语言webrtc
                        
    概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
    
                    
    • 
                    
  • sublime个人设置
                        bawangtianzun
sublimetext编辑器
                        
    如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
    
                    
    • 
                    
  • Rust是否会取代C/C++？Rust与C/C++的较量
                        AI与编程之窗
源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
                        
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
    
                    
    • 
                    
  • 吴恩达深度学习笔记(30)-正则化的解释
                        极客Array

                        
    正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
    
                    
    • 
                                
  • eclipse maven
                                    IXHONG
eclipse
                                    
    eclipse中使用maven插件的时候，运行run as maven build的时候报错 
-Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match. 
  
可以设一个环境变量M2_HOME指
    
                                
    • 
                                
  • timer cancel方法的一个小实例
                                    alleni123
多线程timer
                                    
    package com.lj.timer;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class MyTimer extends TimerTask
{

	private int a;
	
	private Timer timer;
	
	pub
    
                                
    • 
                                
  • MySQL数据库在Linux下的安装
                                    ducklsl
mysql
                                    
    1.建好一个专门放置MySQL的目录 
/mysql/db数据库目录 
/mysql/data数据库数据文件目录 
 
2.配置用户，添加专门的MySQL管理用户 
 
>groupadd mysql ----添加用户组
>useradd -g mysql mysql ----在mysql用户组中添加一个mysql用户 
3.配置，生成并安装MySQL 
 
>cmake -D
    
                                
    • 
                                
  • spring------>>cvc-elt.1: Cannot find the declaration of element
                                    Array_06
springbean
                                    
    将-------- 
 
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3
    
                                
    • 
                                
  • maven发布第三方jar的一些问题
                                    cugfy
maven
                                    
    maven中发布 第三方jar到nexus仓库使用的是 deploy:deploy-file命令 
 
有许多参数，具体可查看 
 
http://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html 
 
以下是一个例子： 
 
mvn  deploy:deploy-file -DgroupId=xpp3 
    
                                
    • 
                                
  • MYSQL下载及安装
                                    357029540
mysql
                                    
        好久没有去安装过MYSQL，今天自己在安装完MYSQL过后用navicat for mysql去厕测试链接的时候出现了10061的问题，因为的的MYSQL是最新版本为5.6.24，所以下载的文件夹里没有my.ini文件，所以在网上找了很多方法还是没有找到怎么解决问题，最后看到了一篇百度经验里有这个的介绍，按照其步骤也完成了安装，在这里给大家分享下这个链接的地址
    
                                
    • 
                                
  • ios TableView cell的布局
                                    张亚雄
tableview
                                    
      cell.imageView.image = [UIImage imageNamed:[imageArray objectAtIndex:[indexPath row]]]; 
    
  
    CGSize itemSize = CGSizeMake(60, 50); 
 
  &nbs
    
                                
    • 
                                
  • Java编码转义
                                    adminjun
java编码转义
                                    
        import java.io.UnsupportedEncodingException;

    /**
    * 转换字符串的编码
    */
    public class ChangeCharset {
    /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */
    public static final Strin
    
                                
    • 
                                
  • Tomcat 配置和spring
                                    aijuans
spring
                                    
    简介 
Tomcat启动时，先找系统变量CATALINA_BASE，如果没有，则找CATALINA_HOME。然后找这个变量所指的目录下的conf文件夹，从中读取配置文件。最重要的配置文件：server.xml 。要配置tomcat，基本上了解server.xml，context.xml和web.xml。 
 
 Server.xml --  tomcat主
    
                                
    • 
                                
  • Java打印当前目录下的所有子目录和文件
                                    ayaoxinchao
递归File
                                    
    其实这个没啥技术含量，大湿们不要操笑哦，只是做一个简单的记录，简单用了一下递归算法。 
  
import java.io.File;

/**
 * @author Perlin
 * @date 2014-6-30
 */
public class PrintDirectory {
	
	public static void printDirectory(File f
    
                                
    • 
                                
  • linux安装mysql出现libs报冲突解决
                                    BigBird2012
linux
                                    
    linux安装mysql出现libs报冲突解决 
安装mysql出现 
file /usr/share/mysql/ukrainian/errmsg.sys from install of MySQL-server-5.5.33-1.linux2.6.i386 conflicts with file from package mysql-libs-5.1.61-4.el6.i686 
 
    
                                
    • 
                                
  • jedis连接池使用实例
                                    bijian1013
redisjedis连接池jedis
                                    
    实例代码： 
package com.bijian.study;

import java.util.ArrayList;
import java.util.List;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoo
    
                                
    • 
                                
  • 关于朋友
                                    bingyingao
朋友兴趣爱好维持
                                    
      成为朋友的必要条件： 
   志相同，道不合，可以成为朋友。譬如马云、周星驰一个是商人，一个是影星，可谓道不同，但都很有梦想，都要在各自领域里做到最好，当他们遇到一起，互相欣赏，可以畅谈两个小时。   
  志不同，道相合，也可以成为朋友。譬如有时候看到两个一个成绩很好每次考试争做第一，一个成绩很差的同学是好朋友。他们志向不相同，但他
    
                                
    • 
                                
  • 【Spark七十九】Spark RDD API一
                                    bit1129
spark
                                    
    aggregate 
package spark.examples.rddapi

import org.apache.spark.{SparkConf, SparkContext}

//测试RDD的aggregate方法
object AggregateTest {
  def main(args: Array[String]) {
    val conf = new Spar
    
                                
    • 
                                
  • ktap 0.1 released
                                    bookjovi
kerneltracing
                                    
    Dear,

I'm pleased to announce that ktap release v0.1, this is the first official
release of ktap project, it is expected that this release is not fully
functional or very stable and we welcome bu
    
                                
    • 
                                
  • 能保存Properties文件注释的Properties工具类
                                    BrokenDreams
properties
                                    
            今天遇到一个小需求：由于java.util.Properties读取属性文件时会忽略注释，当写回去的时候，注释都没了。恰好一个项目中的配置文件会在部署后被某个Java程序修改一下，但修改了之后注释全没了，可能会给以后的参数调整带来困难。所以要解决这个问题。 
    &nb
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-外观模式-Facade
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/*
 * 百度百科的定义：
 * Facade（外观）模式为子系统中的各类（或结构与方法）提供一个简明一致的界面，
 * 隐藏子系统的复杂性，使子系统更加容易使用。他是为子系统中的一组接口所提供的一个一致的界面
 * 
 * 可简单地
    
                                
    • 
                                
  • After Effects教程收集
                                    cherishLC
After Effects
                                    
    1、中文入门 
 
http://study.163.com/course/courseMain.htm?courseId=730009 
 
 2、videocopilot英文入门教程（中文字幕） 
 
http://www.youku.com/playlist_show/id_17893193.html 
英文原址： 
http://www.videocopilot.net/basic/ 
素
    
                                
    • 
                                
  • Linux Apache 安装过程
                                    crabdave
apache
                                    
    Linux Apache 安装过程 
  
下载新版本： 
apr-1.4.2.tar.gz（下载网站：http://apr.apache.org/download.cgi） 
apr-util-1.3.9.tar.gz（下载网站：http://apr.apache.org/download.cgi） 
httpd-2.2.15.tar.gz（下载网站：http://httpd.apac
    
                                
    • 
                                
  • Shell学习 之 变量赋值和引用
                                    daizj
shell变量引用赋值
                                    
    本文转自：http://www.cnblogs.com/papam/articles/1548679.html 
 
Shell编程中，使用变量无需事先声明，同时变量名的命名须遵循如下规则： 
 
首个字符必须为字母（a-z，A-Z） 
中间不能有空格，可以使用下划线（_） 
不能使用标点符号 
不能使用bash里的关键字（可用help命令查看保留关键字） 
需要给变量赋值时，可以这么写： 
 

    
                                
    • 
                                
  • Java SE 第一讲（Java SE入门、JDK的下载与安装、第一个Java程序、Java程序的编译与执行）
                                    dcj3sjt126com
javajdk
                                    
    Java SE 第一讲： 
 
Java SE：Java Standard Edition 
Java ME: Java Mobile Edition 
Java EE：Java Enterprise Edition 
 
Java是由Sun公司推出的（今年初被Oracle公司收购）。 
 
收购价格：74亿美金 
 
J2SE、J2ME、J2EE 
 
JDK：Java Development 
    
                                
    • 
                                
  • YII给用户登录加上验证码
                                    dcj3sjt126com
yii
                                    
    1、在SiteController中添加如下代码： 
    /**
     * Declares class-based actions.
     */
    public function actions() {
        return array(
            // captcha action renders the CAPTCHA image displ
    
                                
    • 
                                
  • Lucene使用说明
                                    dyy_gusi
Lucenesearch分词器
                                    
    Lucene使用说明 
1、lucene简介 
1.1、什么是lucene 
    Lucene是一个全文搜索框架，而不是应用产品。因此它并不像baidu或者googleDesktop那种拿来就能用，它只是提供了一种工具让你能实现这些产品和功能。 
1.2、lucene能做什么 
    要回答这个问题，先要了解lucene的本质。实际
    
                                
    • 
                                
  • 学习编程并不难,做到以下几点即可!
                                    gcq511120594
数据结构编程算法
                                    
    不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各 异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发 各种神奇的软件啦。 
1、确定目标 
学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
    
                                
    • 
                                
  • Java面试十问之三：Java与C++内存回收机制的差别
                                    HNUlanwei
javaC++finalize()堆栈内存回收
                                    
    大家知道， Java 除了那 8 种基本类型以外，其他都是对象类型（又称为引用类型）的数据。 JVM 会把程序创建的对象存放在堆空间中，那什么又是堆空间呢？其实，堆（ Heap）是一个运行时的数据存储区，从它可以分配大小各异的空间。一般，运行时的数据存储区有堆（ Heap）和堆栈（ Stack），所以要先看它们里面可以分配哪些类型的对象实体，然后才知道如何均衡使用这两种存储区。一般来说，栈中存放的
    
                                
    • 
                                
  • 第二章 Nginx+Lua开发入门
                                    jinnianshilongnian
nginxlua
                                    
    Nginx入门 
本文目的是学习Nginx+Lua开发，对于Nginx基本知识可以参考如下文章： 
nginx启动、关闭、重启 
http://www.cnblogs.com/derekchen/archive/2011/02/17/1957209.html 
agentzh 的 Nginx 教程 
http://openresty.org/download/agentzh-nginx-tutor
    
                                
    • 
                                
  • MongoDB windows安装 基本命令
                                    liyonghui160com

                                    
      
windows安装 
  
 安装目录： 
  
D:\MongoDB\ 
  
新建目录 
  
D:\MongoDB\data\db 
  
4.启动进城： 
  
cd D:\MongoDB\bin 
  
mongod -dbpath D:\MongoDB\data\db 
  
&n
    
                                
    • 
                                
  • Linux下通过源码编译安装程序
                                    pda158
linux
                                    
    一、程序的组成部分   　　Linux下程序大都是由以下几部分组成：   　　二进制文件：也就是可以运行的程序文件   　　库文件：就是通常我们见到的lib目录下的文件   　　配置文件：这个不必多说，都知道   　　帮助文档：通常是我们在linux下用man命令查看的命令的文档   　　 
二、linux下程序的存放目录   　　linux程序的存放目录大致有三个地方：   　　/etc, /b
    
                                
    • 
                                
  • WEB开发编程的职业生涯４个阶段
                                    shw3588
编程Web工作生活
                                    
    觉得自己什么都会 
2007年从学校毕业，凭借自己原创的ASP毕业设计，以为自己很厉害似的，信心满满去东莞找工作，找面试成功率确实很高，只是工资不高，但依旧无法磨灭那过分的自信，那时候什么考勤系统、什么OA系统、什么ERP，什么都觉得有信心，这样的生涯大概持续了约一年。 
 
根本不是自己想的那样 
2008年开始接触很多工作相关的东西，发现太多东西自己根本不会，都需要去学，不管是asp还是js，
    
                                
    • 
                                
  • 遭遇jsonp同域下变作post请求的坑
                                    vb2005xu
jsonp同域post
                                    
    今天迁移一个站点时遇到一个坑爹问题,同一个jsonp接口在跨域时都能调用成功,但是在同域下调用虽然成功,但是数据却有问题. 此处贴出我的后端代码片段 
$mi_id = htmlspecialchars(trim($_GET['mi_id ']));
$mi_cv = htmlspecialchars(trim($_GET['mi_cv '])); 
 贴出我前端代码片段: 
$.aj
    
                                
    •