d42b53c070
* Added Torchscript Backend * First commit for backend with Torch FX Decoder * Merging changes from Torch FX branch * Torch FX initial fixes (Temporary) * Fixed type/shape issues in Torch FX decoder * Added translation for built-in getitem * MaxPool update & Output shape fix (Torch FX) * Torch FX graph outputs fix * Torch FX support for sigmoid and slu_ * Torch FX graph module caching * Torch Fx partitioner cache removed * Torch FX initial getitem replacer added * Index check for torch fx getitem replacer * Debug print removed from partitioner * Added environment variables for pytorch tracing mode and openvino device * FX translation fix for getitem & getitem replacer removed * Added checks for PyTorch tracing mode environment variable * Adding compile mode for fallback * Added more ops for resnet18 * Added a check for environment variable * Generalized addmm to work with torchscript and torchfx * Added the missing batch_norm.default translation * fx_backend: include get_attr ops to the partitions * AddeTODO note t to improvget_attr algorithm * created function for adding get_attr nodes * fx_backend: added aten.mul.Tensor, re-enabled aten.empty.memory_format * fx_backend: Additional op support/improvement for Inception V3 * Added comment for fix 64-bit to 32-bit max int conversion * fx_backend: Update for avg_poolnd to support 3 inputs * Fixed erorr in decoder.py * TorchFX caching fix * Torch backend, op support for Stable Diff. & BERT * Arranged ops in order and added torch tensor mapping * Added support for more ops for super glue * TorchFX: Initial permanent fallback * TorchFX: New ops for improved TorchVision support * TorchFX backend optimizations for partitioning and tmp fallback * working operator updates for superglue * Updates to operators for superglue * Removed max.dim and stack * Cleanup * Cleanup * Fixed a couple of syntax issues * Fixed a couple of syntax issues * Added missing method to TorchFX Decoder * Added missing method to TorchFX Decoder * Removed redundant code for transpose * TorchFX: Initial StableDiffusion support * PyTorch decoder ovtype to ctype fix for int64 * Added ops for distilbert * Fixed few unnecessary include statements * Seperated TorchFX and TorchScript decoders * Modified import statements to reflect two decoders * f64 fix for TorchFX * Import fix for PyTorch backend modules * TorchFX serialize graph for debugging (Temporary) * Serialize and load back feature enabled for TorchFX * Temporary optimization to remove Broadcast * Temporary SoftmaxRehapeElimination pass is added * TorchFX custom model cache directory * PyTorch bitwise translation, conversion checks enabled * Naming fix in make_list_construct * TorchFX: Added comments to Softmax and Slice translations * translate_chunk temporarily removed for TS backend * Fixed linter issues * Addressed clang formatting issues * Fixed few more clang and linter issues * Fixed tests to use ts_decoder * Fixed naming convention issues * Added missing import * Added inlined_inputs to TorchScriptDecoder * Added tests for torch fx backend * Removed magic numbers in PyTorch decoder utils * TorchFX decoder data type fix * Added cast from size_t to int * TorchFX output handling code cleanup * TorchFX: Use detached input tensor * Added missing cast from size_t to int * Added static cast in group_norm * Fixed casting issue in split --------- Co-authored-by: ynimmaga <yamini.nimmagadda@intel.com> Co-authored-by: Cavus Mustafa <mustafa.cavus@intel.com>
222 lines
10 KiB
Python
222 lines
10 KiB
Python
# Copyright (C) 2018-2023 Intel Corporation
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
import pytest
|
|
from openvino.frontend import FrontEndManager
|
|
from openvino.frontend.pytorch.ts_decoder import TorchScriptPythonDecoder
|
|
from pytorch_layer_test_class import PytorchLayerTest
|
|
|
|
|
|
class TestConv2D(PytorchLayerTest):
|
|
def _prepare_input(self):
|
|
import numpy as np
|
|
return (np.random.randn(2, 3, 25, 25).astype(np.float32),)
|
|
|
|
def create_model(self, weights_shape, strides, pads, dilations, groups, bias):
|
|
import torch
|
|
import torch.nn.functional as F
|
|
|
|
class aten_conv2d(torch.nn.Module):
|
|
def __init__(self):
|
|
super(aten_conv2d, self).__init__()
|
|
self.weight = torch.randn(weights_shape)
|
|
self.bias = None
|
|
if bias:
|
|
self.bias = torch.randn(weights_shape[0])
|
|
self.strides = strides
|
|
self.pads = pads
|
|
self.dilations = dilations
|
|
self.groups = groups
|
|
|
|
def forward(self, x):
|
|
return F.conv2d(x, self.weight, self.bias, self.strides, self.pads, self.dilations, self.groups)
|
|
|
|
ref_net = None
|
|
|
|
return aten_conv2d(), ref_net, "aten::conv2d"
|
|
|
|
@pytest.mark.parametrize("params",
|
|
[{'weights_shape': [1, 3, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3], 'strides': 2, 'pads': 0, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3], 'strides': 1, 'pads': 1, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 2, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3], 'strides': 1, 'pads': [0, 1], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3], 'strides': 1, 'pads': [1, 0], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3], 'strides': 1, 'pads': 'same', 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3], 'strides': 1, 'pads': 'valid', 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [3, 1, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 1, 'groups': 3},
|
|
])
|
|
@pytest.mark.parametrize("bias", [True, False])
|
|
@pytest.mark.nightly
|
|
@pytest.mark.precommit
|
|
def test_conv2d(self, params, bias, ie_device, precision, ir_version):
|
|
self._test(*self.create_model(**params, bias=bias),
|
|
ie_device, precision, ir_version)
|
|
|
|
|
|
class TestConv1D(PytorchLayerTest):
|
|
def _prepare_input(self):
|
|
import numpy as np
|
|
return (np.random.randn(2, 3, 25).astype(np.float32),)
|
|
|
|
def create_model(self, weights_shape, strides, pads, dilations, groups, bias):
|
|
import torch
|
|
import torch.nn.functional as F
|
|
|
|
class aten_conv1d(torch.nn.Module):
|
|
def __init__(self):
|
|
super(aten_conv1d, self).__init__()
|
|
self.weight = torch.randn(weights_shape)
|
|
self.bias = None
|
|
if bias:
|
|
self.bias = torch.randn(weights_shape[0])
|
|
self.strides = strides
|
|
self.pads = pads
|
|
self.dilations = dilations
|
|
self.groups = groups
|
|
|
|
def forward(self, x):
|
|
return F.conv1d(x, self.weight, self.bias, self.strides, self.pads, self.dilations, self.groups)
|
|
|
|
ref_net = None
|
|
|
|
return aten_conv1d(), ref_net, "aten::conv1d"
|
|
|
|
@pytest.mark.parametrize("params",
|
|
[{'weights_shape': [3, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [3, 3, 3], 'strides': 2, 'pads': 0, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [3, 3, 3], 'strides': 1, 'pads': 1, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [3, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 2, 'groups': 1},
|
|
{'weights_shape': [3, 3, 3], 'strides': 1, 'pads': 'same', 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [3, 3, 3], 'strides': 1, 'pads': 'valid', 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [3, 1, 3], 'strides': 1, 'pads': 0, 'dilations': 1, 'groups': 3},
|
|
])
|
|
@pytest.mark.parametrize("bias", [True, False])
|
|
@pytest.mark.nightly
|
|
@pytest.mark.precommit
|
|
def test_conv1d(self, params, bias, ie_device, precision, ir_version):
|
|
self._test(*self.create_model(**params, bias=bias),
|
|
ie_device, precision, ir_version)
|
|
|
|
|
|
class TestConv3D(PytorchLayerTest):
|
|
def _prepare_input(self):
|
|
import numpy as np
|
|
return (np.random.randn(2, 3, 25, 25, 25).astype(np.float32),)
|
|
|
|
def create_model(self, weights_shape, strides, pads, dilations, groups, bias):
|
|
import torch
|
|
import torch.nn.functional as F
|
|
|
|
class aten_conv3d(torch.nn.Module):
|
|
def __init__(self):
|
|
super(aten_conv3d, self).__init__()
|
|
self.weight = torch.randn(weights_shape)
|
|
self.bias = None
|
|
if bias:
|
|
self.bias = torch.randn(weights_shape[0])
|
|
self.strides = strides
|
|
self.pads = pads
|
|
self.dilations = dilations
|
|
self.groups = groups
|
|
|
|
def forward(self, x):
|
|
return F.conv3d(x, self.weight, self.bias, self.strides, self.pads, self.dilations, self.groups)
|
|
|
|
ref_net = None
|
|
|
|
return aten_conv3d(), ref_net, "aten::conv3d"
|
|
|
|
@pytest.mark.parametrize("params",
|
|
[{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 2, 'pads': 0, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': 1, 'dilations': 1, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 2, 'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': [0, 1, 0], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': [1, 0, 0], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': [0, 0, 1], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': [1, 1, 0], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': [0, 1, 1], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': [1, 0, 1], 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': 'same', 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [1, 3, 3, 3, 3], 'strides': 1, 'pads': 'valid', 'dilations': 1,
|
|
'groups': 1},
|
|
{'weights_shape': [3, 1, 3, 3, 3], 'strides': 1, 'pads': 0, 'dilations': 1, 'groups': 3},
|
|
])
|
|
@pytest.mark.parametrize("bias", [True, False])
|
|
@pytest.mark.nightly
|
|
@pytest.mark.precommit
|
|
def test_conv3d(self, params, bias, ie_device, precision, ir_version):
|
|
self._test(*self.create_model(**params, bias=bias),
|
|
ie_device, precision, ir_version)
|
|
|
|
class TestConv2DInSubgraph(PytorchLayerTest):
|
|
def _prepare_input(self):
|
|
import numpy as np
|
|
return (np.random.randn(2, 3, 25, 25).astype(np.float32), np.array([1], dtype=np.int32))
|
|
|
|
def convert_directly_via_frontend(self, model, example_input, trace_model, dynamic_shapes, ov_inputs, freeze_model):
|
|
# Overload function to allow reproduction of issue caused by additional freeze.
|
|
import torch
|
|
|
|
fe_manager = FrontEndManager()
|
|
fe = fe_manager.load_by_framework('pytorch')
|
|
|
|
model.eval()
|
|
with torch.no_grad():
|
|
if trace_model:
|
|
model = torch.jit.trace(model, example_input)
|
|
else:
|
|
model = torch.jit.script(model)
|
|
model = torch.jit.freeze(model)
|
|
print(model.inlined_graph)
|
|
decoder = TorchScriptPythonDecoder(model)
|
|
im = fe.load(decoder)
|
|
om = fe.convert(im)
|
|
self._resolve_input_shape_dtype(om, ov_inputs, dynamic_shapes)
|
|
return model, om
|
|
|
|
|
|
def create_model(self):
|
|
import torch
|
|
from torchvision.ops import Conv2dNormActivation
|
|
|
|
class aten_conv2d(torch.nn.Module):
|
|
def __init__(self):
|
|
super().__init__()
|
|
convs = []
|
|
conv_depth=2
|
|
for _ in range(conv_depth):
|
|
convs.append(Conv2dNormActivation(3, 3, 3, norm_layer=None))
|
|
self.convs = torch.nn.Sequential(*convs)
|
|
for layer in self.modules():
|
|
if isinstance(layer, torch.nn.Conv2d):
|
|
torch.nn.init.normal_(layer.weight) # type: ignore[arg-type]
|
|
torch.nn.init.constant_(layer.bias, 0) # type: ignore[arg-type]
|
|
|
|
def forward(self, x, y):
|
|
acc = self.convs(x)
|
|
if y:
|
|
acc += self.convs(x)
|
|
return acc
|
|
ref_net = None
|
|
|
|
return aten_conv2d(), ref_net, "aten::conv2d"
|
|
|
|
@pytest.mark.nightly
|
|
@pytest.mark.precommit
|
|
def test_conv2d(self, ie_device, precision, ir_version):
|
|
self._test(*self.create_model(),
|
|
ie_device, precision, ir_version, freeze_model=True, dynamic_shapes=False)
|