TorchScriptプロフィール

プログラミング 2020-01-27 08:48:19 訪問数: null

これはTorchScript、TorchScript PyTorchモデルである（とチュートリアル導入であるnn.Module中間体サブクラス）表現、高性能環境（例えば、C）で動作することができます。

このチュートリアルでは、カバーします：

  1. ライティングベースモデルPyTorch、を含みます：
    • モジュール
    • 事前定義された関数へ
    • モジュールモジュールの階層
  2. 具体的な方法TorchScript（当社の高性能ランタイム展開）のためPyTorchモジュールの変換
    • 既存のモジュールを追跡
    • 使用スクリプトを直接コンパイルされたモジュール
    • これらの2つの方法を組み合わせる方法
    • 保存とロードモジュールTorchScript

私たちは、このチュートリアルを完了した後、あなたが本当にC.からTorchScript例のモデルを呼び出す案内いたしますフォローアップチュートリアルを読み続けることを願っています

import torch  # 这是同时使用PyTorch和TorchScript所需的全部导入！
print(torch.__version__)

  • 出力 
1.3.0

1.PyTorchモデルの基礎

のは、モジュールの簡単な定義から始めましょう。PyTorchモジュールは、組成物中の基本単位です。それは含まれています：

  • コール準備モジュールのコンストラクタ
  • パラメータおよびサブモジュールのセット。これらのコンストラクタによって初期化、および通話中のモジュールによって使用されてもよいです。
  • フォワード機能。これは、モジュールを呼び出すときに実行されるコードです。
    小さな例で見てみましょう：
class MyCell(torch.nn.Module):
    def __init__(self):
        super(MyCell, self).__init__()

    def forward(self, x, h):
        new_h = torch.tanh(x   h)
        return new_h, new_h

my_cell = MyCell()
x = torch.rand(3, 4)
h = torch.rand(3, 4)
print(my_cell(x, h))

  • 出力 
(tensor([[0.5139, 0.6451, 0.3697, 0.7738],
        [0.7936, 0.5864, 0.8063, 0.9324],
        [0.6479, 0.8408, 0.8062, 0.7263]]), tensor([[0.5139, 0.6451, 0.3697, 0.7738],
        [0.7936, 0.5864, 0.8063, 0.9324],
        [0.6479, 0.8408, 0.8062, 0.7263]]))

したがって、我々は持っています：

  1. サブクラスの作成torch.nn.Moduleクラスを。
  2. コンストラクタを定義します。コンストラクタは、あまりにも多くのことを行う必要はありませんが、コンストラクタがスーパーと呼ばれています。
  3. これは、2つの入力と2つの出力のリターンを必要と正の機能を定義します。実際のコンテンツの前に機能にとって重要ではないが、それは偽造である、RNN部
    -すなわち、ループするように機能します。

私たちは、モジュールをインスタンス化し、生産xとy彼らはランダムな値のちょうど3×4行列です。その後、我々は使用my_cell（x，h）セルを呼び出すこと。これは、順番に私たちの転送を呼び出します。

のは、いくつかのより多くの面白いことをやってみましょう：

class MyCell(torch.nn.Module):
    def __init__(self):
        super(MyCell, self).__init__()
        self.linear = torch.nn.Linear(4, 4)

    def forward(self, x, h):
        new_h = torch.tanh(self.linear(x)   h)
        return new_h, new_h

my_cell = MyCell()
print(my_cell)
print(my_cell(x, h))

  • 出力 
MyCell(
  (linear): Linear(in_features=4, out_features=4, bias=True)
)
(tensor([[ 0.3941,  0.4160, -0.1086,  0.8432],
        [ 0.5604,  0.4003,  0.5009,  0.6842],
        [ 0.7084,  0.7147,  0.1818,  0.8296]], grad_fn=<TanhBackward>), tensor([[ 0.3941,  0.4160, -0.1086,  0.8432],
        [ 0.5604,  0.4003,  0.5009,  0.6842],
        [ 0.7084,  0.7147,  0.1818,  0.8296]], grad_fn=<TanhBackward>))

私たちは、モジュールを再定義してきたMyCellが、今回は追加self.linearのプロパティを、事前にコール（フォワード）機能self.linear。

ここで何が起こったのか最終的には？torch.nn.LinearPyTorch標準ライブラリモジュールです。同様にMyCell、のような、あなたはそれを呼び出すための呼び出し構文を使用することができます。私たちは、モジュールの階層構造を構築しています。

モジュールに印刷すると、視覚的にサブクラスモジュールの階層を表します。この例では、我々は線形とそのパラメータサブクラスことがわかります。

このような組み合わせモジュールによって、我々はシンプルで読みやすいモデルが再利用可能なコンポーネントを持って書くことができます。

あなたは出力に気づいているかもしれませんgrad_fn。これはPyTorch自動判別方法（以下でautograd詳細情報）です。要するに、システムは、私たちは派生して、プログラムの潜在的な複雑さを計算することができます。この設計は、モデル作成のための大きな柔軟性を提供します。

それでは、その柔軟性を調べてみましょう：

class MyDecisionGate(torch.nn.Module):
    def forward(self, x):
        if x.sum() > 0:
            return x
        else:
            return -x

class MyCell(torch.nn.Module):
    def __init__(self):
        super(MyCell, self).__init__()
        self.dg = MyDecisionGate()
        self.linear = torch.nn.Linear(4, 4)

    def forward(self, x, h):
        new_h = torch.tanh(self.dg(self.linear(x))   h)
        return new_h, new_h

my_cell = MyCell()
print(my_cell)
print(my_cell(x, h))

  • 出力 
MyCell(
  (dg): MyDecisionGate()
  (linear): Linear(in_features=4, out_features=4, bias=True)
)
(tensor([[0.0850, 0.2812, 0.5188, 0.8523],
        [0.1233, 0.3948, 0.6615, 0.7466],
        [0.7072, 0.6103, 0.6953, 0.7047]], grad_fn=<TanhBackward>), tensor([[0.0850, 0.2812, 0.5188, 0.8523],
        [0.1233, 0.3948, 0.6615, 0.7466],
        [0.7072, 0.6103, 0.6953, 0.7047]], grad_fn=<TanhBackward>))

私たちはもう一度再定義MyCellクラスのが、ここでは定義されていますMyDecisionGate。制御モジュールの流れ。制御フローはループが含まれており、文のようなものであれば。

プログラムの完全な表現が与えられると、フレームワークのシンボルの数は、計算方法を導出しました。しかし、PyTorchに、我々は勾配ゾーンを使用しています。我々の操作は、記録動作中に発生し、デリバティブを計算する際に後方に再生します。このように、フレーム構造は、明示的に言語のすべての派生クラスを定義する必要はありません。

2.TorchScriptの基礎

今、私たちとしては、例えば、TorchScriptを適用する方法を確認するために、実行されてみましょう。

短い、でもPyTorch柔軟で動的な特性では、TorchScriptはまた、あなたのキャプチャモデル定義ツールを提供します。レッツ・スタートは、いわゆる勉強の追跡を。

2.1追跡（トレース）モジュール

class MyCell(torch.nn.Module):
    def __init__(self):
        super(MyCell, self).__init__()
        self.linear = torch.nn.Linear(4, 4)

    def forward(self, x, h):
        new_h = torch.tanh(self.linear(x)   h)
        return new_h, new_h

my_cell = MyCell()
x, h = torch.rand(3, 4), torch.rand(3, 4)
traced_cell = torch.jit.trace(my_cell, (x, h))
print(traced_cell)
traced_cell(x, h)

  • 出力 
TracedModule[MyCell](
  original_name=MyCell
  (linear): TracedModule[Linear](original_name=Linear)
)

私たちは少し後退され、選択したMyCellクラスの第二のバージョンを。前と同様に、我々はそれをインスタンス化しますが、この時間は、我々は呼んtorch.jit.traceで、Moduleこの例（モジュール）を通過し、例に見ることができる入力ネットワークを渡します。

最後にこれは何をするのですか？これは、モジュールが実行されたときに何が起こるかを記録し、モジュールと呼ばれ、作成されたtorch.jit.ScriptModuleインスタンスは（TracedModule例です）

中央で定義されTorchScript記録（またはIR）を表し、学習パターンの深さは一般に呼ばれます。私たちはしてチェックすることができ.graph、チャートの属性：

print(traced_cell.graph)

  • 出力 
graph(%self : ClassType<MyCell>,
      %input : Float(3, 4),
      %h : Float(3, 4)):
  %1 : ClassType<Linear> = prim::GetAttr[name="linear"](%self)
  %weight : Tensor = prim::GetAttr[name="weight"](%1)
  %bias : Tensor = prim::GetAttr[name="bias"](%1)
  %6 : Float(4, 4) = aten::t(%weight), scope: MyCell/Linear[linear] # /opt/conda/lib/python3.6/site-packages/torch/nn/functional.py:1370:0
  %7 : int = prim::Constant[value=1](), scope: MyCell/Linear[linear] # /opt/conda/lib/python3.6/site-packages/torch/nn/functional.py:1370:0
  %8 : int = prim::Constant[value=1](), scope: MyCell/Linear[linear] # /opt/conda/lib/python3.6/site-packages/torch/nn/functional.py:1370:0
  %9 : Float(3, 4) = aten::addmm(%bias, %input, %6, %7, %8), scope: MyCell/Linear[linear] # /opt/conda/lib/python3.6/site-packages/torch/nn/functional.py:1370:0
   : int = prim::Constant[value=1](), scope: MyCell # /var/lib/jenkins/workspace/beginner_source/Intro_to_TorchScript_tutorial.py:188:0
   : Float(3, 4) = aten::add(%9, %h, ), scope: MyCell # /var/lib/jenkins/workspace/beginner_source/Intro_to_TorchScript_tutorial.py:188:0
   : Float(3, 4) = aten::tanh(), scope: MyCell # /var/lib/jenkins/workspace/beginner_source/Intro_to_TorchScript_tutorial.py:188:0
   : (Float(3, 4), Float(3, 4)) = prim::TupleConstruct(, )
  return ()

しかし、これは情報のほとんどが無駄にエンドユーザーのために、図に含まれ、非常に低レベルの表現です。代わりに、我々は使用することができます.codePythonの構文の説明のコードを与えるプロパティを：

print(traced_cell.code)

  • 出力 
import __torch__
import __torch__.torch.nn.modules.linear
def forward(self,
    input: Tensor,
    h: Tensor) -> Tuple[Tensor, Tensor]:
  _0 = self.linear
  weight = _0.weight
  bias = _0.bias
  _1 = torch.addmm(bias, input, torch.t(weight), beta=1, alpha=1)
  _2 = torch.tanh(torch.add(_1, h, alpha=1))
  return (_2, _2)

では、なぜ私たちは、このすべてを行うのですか？いくつかの理由があります。

  1. 独自のインタプリタで呼び出すことができますTorchScriptコードは、インタプリタは、実質的にPythonインタプリタを制限されています。インタプリタは同じにすることができ、グローバルインタプリタロックはない
    要求の例の数に同時に処理します。
  2. このフォーマットは、Pythonのサーバー以外の言語で書かれたのように、ディスクにモデル全体を保存し、別の環境にロードするために私達を許可します
  3. TorchScriptは、より効果的な実装を提供するために最適化されている私たちは、コードをコンパイルすることができている私たちのために表現を提供し、
  4. TorchScriptは、我々はより広範なビューこれらのプログラムを実行するために、複数の単一のオペレータよりも必要な、私たちは多くのバックエンド/機器操作とインタフェースすることができます。

私たちは、その呼び出し見ることができtraced_cell、同じ農産物の結果とPythonモジュールを：

print(my_cell(x, h))
print(traced_cell(x, h))

  • 出力 
(tensor([[-0.3983,  0.5954,  0.2587, -0.3748],
        [-0.5033,  0.4471,  0.8264,  0.2135],
        [ 0.3430,  0.5561,  0.6794, -0.2273]], grad_fn=<TanhBackward>), tensor([[-0.3983,  0.5954,  0.2587, -0.3748],
        [-0.5033,  0.4471,  0.8264,  0.2135],
        [ 0.3430,  0.5561,  0.6794, -0.2273]], grad_fn=<TanhBackward>))
(tensor([[-0.3983,  0.5954,  0.2587, -0.3748],
        [-0.5033,  0.4471,  0.8264,  0.2135],
        [ 0.3430,  0.5561,  0.6794, -0.2273]],
       grad_fn=<DifferentiableGraphBackward>), tensor([[-0.3983,  0.5954,  0.2587, -0.3748],
        [-0.5033,  0.4471,  0.8264,  0.2135],
        [ 0.3430,  0.5561,  0.6794, -0.2273]],
       grad_fn=<DifferentiableGraphBackward>))

3.スクリプトコンバータモジュール

我々は代わりに、制御フローの多くのサブモジュールを使用するのでは、モジュールの第二版を使用する理由があります。今度は、調べてみましょう：

class MyDecisionGate(torch.nn.Module):
    def forward(self, x):
        if x.sum() > 0:
            return x
        else:
            return -x

class MyCell(torch.nn.Module):
    def __init__(self, dg):
        super(MyCell, self).__init__()
        self.dg = dg
        self.linear = torch.nn.Linear(4, 4)

    def forward(self, x, h):
        new_h = torch.tanh(self.dg(self.linear(x))   h)
        return new_h, new_h

my_cell = MyCell(MyDecisionGate())
traced_cell = torch.jit.trace(my_cell, (x, h))
print(traced_cell.code)

  • 出力 
import __torch__.___torch_mangle_0
import __torch__
import __torch__.torch.nn.modules.linear.___torch_mangle_1
def forward(self,
    input: Tensor,
    h: Tensor) -> Tuple[Tensor, Tensor]:
  _0 = self.linear
  weight = _0.weight
  bias = _0.bias
  x = torch.addmm(bias, input, torch.t(weight), beta=1, alpha=1)
  _1 = torch.tanh(torch.add(x, h, alpha=1))
  return (_1, _1)

表示.code出力は、我々はどこ見つけるために見つけることができないif-elseブランチを！なぜ？私たちが言ったように、正確にトラッキング：実行コードは、記録動作が発生し、それを行うことができます構築しますScriptModule。残念ながら、このような消去されるような制御フローとの事。

どのように我々は忠実にTorchScriptにこのモジュールを表していますか？我々は提供したスクリプトコンパイラを直接TorchScriptに変換するために、あなたのPythonのソースコードを分析することができます。のは、スクリプトコンパイラの変換を使用してみましょうMyDecisionGate：

scripted_gate = torch.jit.script(MyDecisionGate())

my_cell = MyCell(scripted_gate)
traced_cell = torch.jit.script(my_cell)
print(traced_cell.code)

  • 出力 
import __torch__.___torch_mangle_3
import __torch__.___torch_mangle_2
import __torch__.torch.nn.modules.linear.___torch_mangle_4
def forward(self,
    x: Tensor,
    h: Tensor) -> Tuple[Tensor, Tensor]:
  _0 = self.linear
  _1 = _0.weight
  _2 = _0.bias
  if torch.eq(torch.dim(x), 2):
    _3 = torch.__isnot__(_2, None)
  else:
    _3 = False
  if _3:
    bias = ops.prim.unchecked_unwrap_optional(_2)
    ret = torch.addmm(bias, x, torch.t(_1), beta=1, alpha=1)
  else:
    output = torch.matmul(x, torch.t(_1))
    if torch.__isnot__(_2, None):
      bias0 = ops.prim.unchecked_unwrap_optional(_2)
      output0 = torch.add_(output, bias0, alpha=1)
    else:
      output0 = output
    ret = output0
  _4 = torch.gt(torch.sum(ret, dtype=None), 0)
  if bool(_4):
    _5 = ret
  else:
    _5 = torch.neg(ret)
  new_h = torch.tanh(torch.add(_5, h, alpha=1))
  return (new_h, new_h)

今、私たちは忠実にプログラムにTorchScriptで私たちの行動をキャプチャしています。それでは、プログラムを実行してみましょう：

# New inputs
x, h = torch.rand(3, 4), torch.rand(3, 4)
traced_cell(x, h)

3.1混合スクリプト（スクリプト）とトラック（トレース）

いくつかのケースでは、代わりにトラッキングスクリプトを使用する（例えば、モジュールはTorchScriptが製でPythonの値は表示されません私たちの定数の希望に基づいており、多くの建築の決定を持っています）。この場合、スクリプトは、トラッキングによって書くことができる：torch.jit.scriptインラインコードモジュールを追跡する、トラッキングコードとインラインスクリプトモジュール。

  • 最初の場合の例： 
class MyRNNLoop(torch.nn.Module):
    def __init__(self):
        super(MyRNNLoop, self).__init__()
        self.cell = torch.jit.trace(MyCell(scripted_gate), (x, h))

    def forward(self, xs):
        h, y = torch.zeros(3, 4), torch.zeros(3, 4)
        for i in range(xs.size(0)):
            y, h = self.cell(xs[i], h)
        return y, h

rnn_loop = torch.jit.script(MyRNNLoop())
print(rnn_loop.code)

  • 出力 
import __torch__
import __torch__.___torch_mangle_5
import __torch__.___torch_mangle_2
import __torch__.torch.nn.modules.linear.___torch_mangle_6
def forward(self,
    xs: Tensor) -> Tuple[Tensor, Tensor]:
  h = torch.zeros([3, 4], dtype=None, layout=None, device=None, pin_memory=None)
  y = torch.zeros([3, 4], dtype=None, layout=None, device=None, pin_memory=None)
  y0 = y
  h0 = h
  for i in range(torch.size(xs, 0)):
    _0 = self.cell
    _1 = torch.select(xs, 0, i)
    _2 = _0.linear
    weight = _2.weight
    bias = _2.bias
    _3 = torch.addmm(bias, _1, torch.t(weight), beta=1, alpha=1)
    _4 = torch.gt(torch.sum(_3, dtype=None), 0)
    if bool(_4):
      _5 = _3
    else:
      _5 = torch.neg(_3)
    _6 = torch.tanh(torch.add(_5, h0, alpha=1))
    y0, h0 = _6, _6
  return (y0, h0)

  • 後者の場合の例： 
class WrapRNN(torch.nn.Module):
    def __init__(self):
        super(WrapRNN, self).__init__()
        self.loop = torch.jit.script(MyRNNLoop())

    def forward(self, xs):
        y, h = self.loop(xs)
        return torch.relu(y)

traced = torch.jit.trace(WrapRNN(), (torch.rand(10, 3, 4)))
print(traced.code)

  • 出力 
import __torch__
import __torch__.___torch_mangle_9
import __torch__.___torch_mangle_7
import __torch__.___torch_mangle_2
import __torch__.torch.nn.modules.linear.___torch_mangle_8
def forward(self,
    argument_1: Tensor) -> Tensor:
  _0 = self.loop
  h = torch.zeros([3, 4], dtype=None, layout=None, device=None, pin_memory=None)
  h0 = h
  for i in range(torch.size(argument_1, 0)):
    _1 = _0.cell
    _2 = torch.select(argument_1, 0, i)
    _3 = _1.linear
    weight = _3.weight
    bias = _3.bias
    _4 = torch.addmm(bias, _2, torch.t(weight), beta=1, alpha=1)
    _5 = torch.gt(torch.sum(_4, dtype=None), 0)
    if bool(_5):
      _6 = _4
    else:
      _6 = torch.neg(_4)
    h0 = torch.tanh(torch.add(_6, h0, alpha=1))
  return torch.relu(h0)

このように、状況がそれを必要とするとき、あなたはスクリプトを使用して一緒に追跡するために、それらを使用することができます。

4.保存して負荷モデル

私たちは、TorchScriptモジュールをロードするために、ディスクまたはディスクからアーカイブ形式TorchScriptモジュールを保存するために、APIを提供しています。このフォーマットは、コード、パラメータ、特性およびデバッグ情報、アーカイブが完全に別のプロセスにロードすることができるモデルの独立した表現であることを意味を含みます。私たちは、保存しようと、パッケージのロードRNNモジュールを：

traced.save('wrapped_rnn.zip')

loaded = torch.jit.load('wrapped_rnn.zip')

print(loaded)
print(loaded.code)

  • 出力 
ScriptModule(
  original_name=WrapRNN
  (loop): ScriptModule(
    original_name=MyRNNLoop
    (cell): ScriptModule(
      original_name=MyCell
      (dg): ScriptModule(original_name=MyDecisionGate)
      (linear): ScriptModule(original_name=Linear)
    )
  )
)
import __torch__
import __torch__.___torch_mangle_9
import __torch__.___torch_mangle_7
import __torch__.___torch_mangle_2
import __torch__.torch.nn.modules.linear.___torch_mangle_8
def forward(self,
    argument_1: Tensor) -> Tensor:
  _0 = self.loop
  h = torch.zeros([3, 4], dtype=None, layout=None, device=None, pin_memory=None)
  h0 = h
  for i in range(torch.size(argument_1, 0)):
    _1 = _0.cell
    _2 = torch.select(argument_1, 0, i)
    _3 = _1.linear
    weight = _3.weight
    bias = _3.bias
    _4 = torch.addmm(bias, _2, torch.t(weight), beta=1, alpha=1)
    _5 = torch.gt(torch.sum(_4, dtype=None), 0)
    if bool(_5):
      _6 = _4
    else:
      _6 = torch.neg(_4)
    h0 = torch.tanh(torch.add(_6, h0, alpha=1))
  return torch.relu(h0)

あなたが見ることができるように、直列化モジュールは、階層と我々が研究されてきたコードを保持します。例えば、モデルは、Pythonの実装に依存しないCにロードされるように実装されてもよいです。

深い読み

私たちは、チュートリアルを完了しました！関係より、プレゼンテーションのために、TorchScript変換機械翻訳モデルを使用するデモNeurIPSをチェックアウトします。https：//colab.research.google.com/drive/1HiICg6jRkBnr5hvK2-VnMi88Vi9pUzEJ

スクリプトの実行時間の合計：（0分0.247秒）

ようこそ注意パンチョンのブログのリソースの概要駅：http://docs.panchuang.net/

ようこそ懸念PyTorch中国の公式チュートリアルの駅：http://pytorch.panchuang.net/

OpenCVの中国の公式文書：http://woshicver.com/

パンチョンAIの ブログの専門家
公開された328元の記事 ・ ウォンの賞賛903 ・ ビュー520 000 +
彼のメッセージボードの 懸念

おすすめ

転載: blog.csdn.net/fendouaini/article/details/104090061
おすすめ
ランキング
SLAM 14 講義 - ch3 演習
bootstrap4在庫スタイルリスト（見つけるために）
件名インターネット
スレッドのタイムアウト
LinuxのLinuxのコマンド必見マスター初心者注3。
コンピュータネットワークのネットワークアプリケーションの00 05基本原則
「10の花」
Classic topic: the maximum value of the sliding window + the first K high-frequency elements
fastjson の脆弱性のさまざまなバージョンのペイロード テスト
PythonクローラーBaidu広告フィルタリングシステム
アーカイブ
もっと
2024-04-25(31)
2024-04-24(30)
2024-04-23(31)
2024-04-22(5)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(31)
2024-04-16(23)

コードワールド

© 2018 codetd.com