diff --git a/.gitattributes b/.gitattributes index 73afd1bf77e684d42c9abc06f7e0d974054fb569..dd143f1f0670619eb733500655b79445e6843429 100644 --- a/.gitattributes +++ b/.gitattributes @@ -66,3 +66,4 @@ runtime/Lib/site-packages/lxml/objectify.cp39-win_amd64.pyd filter=lfs diff=lfs runtime/Lib/site-packages/numpy/.libs/libopenblas.FB5AE2TYXYH2IJRDKGDGQ3XBKLKTF43H.gfortran-win_amd64.dll filter=lfs diff=lfs merge=lfs -text runtime/Lib/site-packages/numpy/core/_multiarray_umath.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text runtime/Lib/site-packages/numpy/core/_simd.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text +runtime/Lib/site-packages/onnx/onnx_cpp2py_export.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text diff --git a/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/INSTALLER b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/LICENSE b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..eb208dada03bbd9975633d6f42eb036c09e33125 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/LICENSE @@ -0,0 +1,29 @@ +BSD 3-Clause License + +Copyright (c) 2018, Omry Yadan +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/METADATA b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..6d3ab67e16a7dfc446c5e7f878569d4fa7e79d6e --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/METADATA @@ -0,0 +1,64 @@ +Metadata-Version: 2.1 +Name: omegaconf +Version: 2.3.0 +Summary: A flexible configuration library +Home-page: https://github.com/omry/omegaconf +Author: Omry Yadan +Author-email: omry@yadan.net +Keywords: yaml configuration config +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: antlr4-python3-runtime (==4.9.*) +Requires-Dist: PyYAML (>=5.1.0) +Requires-Dist: dataclasses ; python_version == "3.6" + +# OmegaConf +| | Description | +| --- | --- | +| Project | [![PyPI version](https://badge.fury.io/py/omegaconf.svg)](https://badge.fury.io/py/omegaconf)[![Downloads](https://pepy.tech/badge/omegaconf/month)](https://pepy.tech/project/omegaconf?versions=1.4.*&versions=2.0.*&versions=2.1.*)![PyPI - Python Version](https://img.shields.io/pypi/pyversions/omegaconf.svg) | +| Code quality| [![CircleCI](https://img.shields.io/circleci/build/github/omry/omegaconf?logo=s&token=5de2f8dc2a0dd78438520575431aa533150806e3)](https://circleci.com/gh/omry/omegaconf)[![Coverage Status](https://coveralls.io/repos/github/omry/omegaconf/badge.svg)](https://coveralls.io/github/omry/omegaconf)[![Total alerts](https://img.shields.io/lgtm/alerts/g/omry/omegaconf.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/omry/omegaconf/alerts/)[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/omry/omegaconf.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/omry/omegaconf/context:python)| +| Docs and support |[![Documentation Status](https://readthedocs.org/projects/omegaconf/badge/?version=2.0_branch)](https://omegaconf.readthedocs.io/en/2.1_branch/)[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/omry/omegaconf/master?filepath=docs%2Fnotebook%2FTutorial.ipynb)| + + +OmegaConf is a hierarchical configuration system, with support for merging configurations from multiple sources (YAML config files, dataclasses/objects and CLI arguments) +providing a consistent API regardless of how the configuration was created. + +## Releases + +### Stable (2.2) +OmegaConf 2.2 is the current stable version. +* [What's new](https://github.com/omry/omegaconf/releases/tag/v2.2.1) +* [Documentation](https://omegaconf.readthedocs.io/en/2.2_branch/) +* [Source code](https://github.com/omry/omegaconf/tree/2.2_branch) + +Install with `pip install --upgrade omegaconf` + +### Previous release (2.1) +OmegaConf 2.1 is the current stable version. +* [What's new](https://github.com/omry/omegaconf/releases/tag/v2.1.1) +* [Documentation](https://omegaconf.readthedocs.io/en/2.1_branch/) +* [Slides](https://docs.google.com/presentation/d/e/2PACX-1vT_UIV7hCnquIbLUm4NnkUpXvPEh33IKiUEvPRF850WKA8opOlZOszjKdZ3tPmf8u7hGNP6HpqS-NT5/pub?start=false&loop=false&delayms=3000) +* [Source code](https://github.com/omry/omegaconf/tree/2.1_branch) + +Install with `pip install omegaconf==2.1` + +### Previous release (2.0) + +* [What's new](https://github.com/omry/omegaconf/releases/tag/v2.0.0) +* [Documentation](https://omegaconf.readthedocs.io/en/2.0_branch/) +* [Slides](https://docs.google.com/presentation/d/e/2PACX-1vT_UIV7hCnquIbLUm4NnkUpXvPEh33IKiUEvPRF850WKA8opOlZOszjKdZ3tPmf8u7hGNP6HpqS-NT5/pub?start=false&loop=false&delayms=3000) +* [Source code](https://github.com/omry/omegaconf/tree/2.0_branch) + +Install with `pip install omegaconf==2.0.6` + +## Live tutorial +Run the live tutorial: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/omry/omegaconf/master?filepath=docs%2Fnotebook%2FTutorial.ipynb) diff --git a/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/RECORD b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..75e980d3a840c83ea9f1426d1beefb1a5fce27d3 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/RECORD @@ -0,0 +1,57 @@ +omegaconf-2.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +omegaconf-2.3.0.dist-info/LICENSE,sha256=sxN17V1cvn7C0MTBTfivp6jlUBu-JfcLbLxGFoX0uRo,1518 +omegaconf-2.3.0.dist-info/METADATA,sha256=qy3L8OPnDMddyh2JT4lT596LZR3C3CjwjzUL-leHuts,3865 +omegaconf-2.3.0.dist-info/RECORD,, +omegaconf-2.3.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92 +omegaconf-2.3.0.dist-info/top_level.txt,sha256=gKo5sjlMnML5r9-l1eLYBTS1xZ-xAr67mlBSgL9yvSA,25 +omegaconf/__init__.py,sha256=lynwiDHEFBIHMqrBN3HRh0KJevzIap6MyULFNkMmlBc,1170 +omegaconf/__pycache__/__init__.cpython-39.pyc,, +omegaconf/__pycache__/_impl.cpython-39.pyc,, +omegaconf/__pycache__/_utils.cpython-39.pyc,, +omegaconf/__pycache__/base.cpython-39.pyc,, +omegaconf/__pycache__/basecontainer.cpython-39.pyc,, +omegaconf/__pycache__/dictconfig.cpython-39.pyc,, +omegaconf/__pycache__/errors.cpython-39.pyc,, +omegaconf/__pycache__/grammar_parser.cpython-39.pyc,, +omegaconf/__pycache__/grammar_visitor.cpython-39.pyc,, +omegaconf/__pycache__/listconfig.cpython-39.pyc,, +omegaconf/__pycache__/nodes.cpython-39.pyc,, +omegaconf/__pycache__/omegaconf.cpython-39.pyc,, +omegaconf/__pycache__/version.cpython-39.pyc,, +omegaconf/_impl.py,sha256=CJfcRt8K20BiMMW5u3q8wuQ9hAeAmuYlFxctzPgTIgQ,2877 +omegaconf/_utils.py,sha256=bw8Jpra0B8YkHFrwODrBcKPvgQTyU0pEpskLl7CDBRg,32564 +omegaconf/base.py,sha256=rHWuLw8Iiew_SNJIUkLZy4EfyRb60hyS9X9Hl4OuBvs,32462 +omegaconf/basecontainer.py,sha256=FWL2PZWRb7wP-AGpeN651l_uVnNhZvzzLjaUdDlJiB8,33318 +omegaconf/dictconfig.py,sha256=IPtUPHoak025Q-gvDVqMdS497Xb6tjcsawrHXv4iQ2Y,27855 +omegaconf/errors.py,sha256=ectbX8Kd-5FCJMTBIh6jshqvCnCiXMFGfFQJYGIereQ,3595 +omegaconf/grammar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +omegaconf/grammar/__pycache__/__init__.cpython-39.pyc,, +omegaconf/grammar/gen/OmegaConfGrammarLexer.py,sha256=eoog1aofOltw-u61QFeCWZ3A9oa6vK2tjTaX4wmJY14,21689 +omegaconf/grammar/gen/OmegaConfGrammarParser.py,sha256=X0uJc0OieVB_f9yKRZw4OfwRBPOGoiyDMjhz8OKPvZ4,63429 +omegaconf/grammar/gen/OmegaConfGrammarParserListener.py,sha256=ncibh-Nhg68pdJPdMaqeFTP876wvo0lpJqPXhaOmjZU,5843 +omegaconf/grammar/gen/OmegaConfGrammarParserVisitor.py,sha256=Amvi244RtYFebNSJCbOwsqdvQW-QgdDKTku0rXnkD5Y,3617 +omegaconf/grammar/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +omegaconf/grammar/gen/__pycache__/OmegaConfGrammarLexer.cpython-39.pyc,, +omegaconf/grammar/gen/__pycache__/OmegaConfGrammarParser.cpython-39.pyc,, +omegaconf/grammar/gen/__pycache__/OmegaConfGrammarParserListener.cpython-39.pyc,, +omegaconf/grammar/gen/__pycache__/OmegaConfGrammarParserVisitor.cpython-39.pyc,, +omegaconf/grammar/gen/__pycache__/__init__.cpython-39.pyc,, +omegaconf/grammar_parser.py,sha256=7gvIGsqtsgl5e0XOWhI3Ur58FoIk3iBaX_M8JdyzpYM,5511 +omegaconf/grammar_visitor.py,sha256=L6LOomG24GcPA1-aYzNOmKLup5kYirHTuyp857V7T7A,16055 +omegaconf/listconfig.py,sha256=LyNRrn84BqNiz-TpwrDILat8HhlVwwM6zFmYCTUAdIo,24671 +omegaconf/nodes.py,sha256=1XRIC8sfEoaV4PT_Vm7Z75JMsIc30kKTuJHGyZ2aM0w,17479 +omegaconf/omegaconf.py,sha256=hFeVL0k6PNRqGE7ZUpI2p6sSGPkc9IEvsqr3MNdgU_s,39048 +omegaconf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +omegaconf/resolvers/__init__.py,sha256=zE-8WJwipGC2cXPq12CGAz49m82F1D1cKMwuV3EoT7k,60 +omegaconf/resolvers/__pycache__/__init__.cpython-39.pyc,, +omegaconf/resolvers/oc/__init__.py,sha256=gLniKaouCmkm1ZTQOzS1F5jFlCMw7eL-ae6PhaMxNjg,3548 +omegaconf/resolvers/oc/__pycache__/__init__.cpython-39.pyc,, +omegaconf/resolvers/oc/__pycache__/dict.cpython-39.pyc,, +omegaconf/resolvers/oc/dict.py,sha256=OL7iZ_aBIt7kYXxhMiFxSyskiX-xXBvGI_DnBbdxqVs,2324 +omegaconf/version.py,sha256=9OuwPWmsrNRBQYmeipe5XnywKY4jw-ZQBrjbo5C5Md4,442 +pydevd_plugins/__init__.py,sha256=byyA3PmxQsWCnqpQzFy44heJq59wOqHr5bSt6knm5vY,180 +pydevd_plugins/__pycache__/__init__.cpython-39.pyc,, +pydevd_plugins/extensions/__init__.py,sha256=byyA3PmxQsWCnqpQzFy44heJq59wOqHr5bSt6knm5vY,180 +pydevd_plugins/extensions/__pycache__/__init__.cpython-39.pyc,, +pydevd_plugins/extensions/__pycache__/pydevd_plugin_omegaconf.cpython-39.pyc,, +pydevd_plugins/extensions/pydevd_plugin_omegaconf.py,sha256=Ac1SCniO-22CsRsMAXhFyyoVSN2R-MUWsOujm-601Ak,4251 diff --git a/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/WHEEL b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..57e3d840d59a650ac5bccbad5baeec47d155f0ad --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.38.4) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/top_level.txt b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..fcd2b36b800878631de7b82d0218569415c6a323 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf-2.3.0.dist-info/top_level.txt @@ -0,0 +1,2 @@ +omegaconf +pydevd_plugins diff --git a/runtime/Lib/site-packages/omegaconf/__init__.py b/runtime/Lib/site-packages/omegaconf/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1670cf08fa977560c2ad1ef2d98910824c1bdc9b --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/__init__.py @@ -0,0 +1,65 @@ +from .base import Container, DictKeyType, Node, SCMode, UnionNode +from .dictconfig import DictConfig +from .errors import ( + KeyValidationError, + MissingMandatoryValue, + ReadonlyConfigError, + UnsupportedValueType, + ValidationError, +) +from .listconfig import ListConfig +from .nodes import ( + AnyNode, + BooleanNode, + BytesNode, + EnumNode, + FloatNode, + IntegerNode, + PathNode, + StringNode, + ValueNode, +) +from .omegaconf import ( + II, + MISSING, + SI, + OmegaConf, + Resolver, + flag_override, + open_dict, + read_write, +) +from .version import __version__ + +__all__ = [ + "__version__", + "MissingMandatoryValue", + "ValidationError", + "ReadonlyConfigError", + "UnsupportedValueType", + "KeyValidationError", + "Container", + "UnionNode", + "ListConfig", + "DictConfig", + "DictKeyType", + "OmegaConf", + "Resolver", + "SCMode", + "flag_override", + "read_write", + "open_dict", + "Node", + "ValueNode", + "AnyNode", + "IntegerNode", + "StringNode", + "BytesNode", + "PathNode", + "BooleanNode", + "EnumNode", + "FloatNode", + "MISSING", + "SI", + "II", +] diff --git a/runtime/Lib/site-packages/omegaconf/_impl.py b/runtime/Lib/site-packages/omegaconf/_impl.py new file mode 100644 index 0000000000000000000000000000000000000000..0c30ef6a239e65302c484b361773a00f85c70909 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/_impl.py @@ -0,0 +1,101 @@ +from typing import Any + +from omegaconf import MISSING, Container, DictConfig, ListConfig, Node, ValueNode +from omegaconf.errors import ConfigTypeError, InterpolationToMissingValueError + +from ._utils import _DEFAULT_MARKER_, _get_value + + +def _resolve_container_value(cfg: Container, key: Any) -> None: + node = cfg._get_child(key) + assert isinstance(node, Node) + if node._is_interpolation(): + try: + resolved = node._dereference_node() + except InterpolationToMissingValueError: + node._set_value(MISSING) + else: + if isinstance(resolved, Container): + _resolve(resolved) + if isinstance(resolved, Container) and isinstance(node, ValueNode): + cfg[key] = resolved + else: + node._set_value(_get_value(resolved)) + else: + _resolve(node) + + +def _resolve(cfg: Node) -> Node: + assert isinstance(cfg, Node) + if cfg._is_interpolation(): + try: + resolved = cfg._dereference_node() + except InterpolationToMissingValueError: + cfg._set_value(MISSING) + else: + cfg._set_value(resolved._value()) + + if isinstance(cfg, DictConfig): + for k in cfg.keys(): + _resolve_container_value(cfg, k) + + elif isinstance(cfg, ListConfig): + for i in range(len(cfg)): + _resolve_container_value(cfg, i) + + return cfg + + +def select_value( + cfg: Container, + key: str, + *, + default: Any = _DEFAULT_MARKER_, + throw_on_resolution_failure: bool = True, + throw_on_missing: bool = False, + absolute_key: bool = False, +) -> Any: + node = select_node( + cfg=cfg, + key=key, + throw_on_resolution_failure=throw_on_resolution_failure, + throw_on_missing=throw_on_missing, + absolute_key=absolute_key, + ) + + node_not_found = node is None + if node_not_found or node._is_missing(): + if default is not _DEFAULT_MARKER_: + return default + else: + return None + + return _get_value(node) + + +def select_node( + cfg: Container, + key: str, + *, + throw_on_resolution_failure: bool = True, + throw_on_missing: bool = False, + absolute_key: bool = False, +) -> Any: + try: + # for non relative keys, the interpretation can be: + # 1. relative to cfg + # 2. relative to the config root + # This is controlled by the absolute_key flag. By default, such keys are relative to cfg. + if not absolute_key and not key.startswith("."): + key = f".{key}" + + cfg, key = cfg._resolve_key_and_root(key) + _root, _last_key, node = cfg._select_impl( + key, + throw_on_missing=throw_on_missing, + throw_on_resolution_failure=throw_on_resolution_failure, + ) + except ConfigTypeError: + return None + + return node diff --git a/runtime/Lib/site-packages/omegaconf/_utils.py b/runtime/Lib/site-packages/omegaconf/_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ffec246a38d278831bce26c6f7c233b72f34c1fe --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/_utils.py @@ -0,0 +1,1039 @@ +import copy +import os +import pathlib +import re +import string +import sys +import types +import warnings +from contextlib import contextmanager +from enum import Enum +from textwrap import dedent +from typing import ( + Any, + Dict, + Iterator, + List, + Optional, + Tuple, + Type, + Union, + get_type_hints, +) + +import yaml + +from .errors import ( + ConfigIndexError, + ConfigTypeError, + ConfigValueError, + GrammarParseError, + OmegaConfBaseException, + ValidationError, +) +from .grammar_parser import SIMPLE_INTERPOLATION_PATTERN, parse + +try: + import dataclasses + +except ImportError: # pragma: no cover + dataclasses = None # type: ignore # pragma: no cover + +try: + import attr + +except ImportError: # pragma: no cover + attr = None # type: ignore # pragma: no cover + +NoneType: Type[None] = type(None) + +BUILTIN_VALUE_TYPES: Tuple[Type[Any], ...] = ( + int, + float, + bool, + str, + bytes, + NoneType, +) + +# Regexprs to match key paths like: a.b, a[b], ..a[c].d, etc. +# We begin by matching the head (in these examples: a, a, ..a). +# This can be read as "dots followed by any character but `.` or `[`" +# Note that a key starting with brackets, like [a], is purposedly *not* +# matched here and will instead be handled in the next regex below (this +# is to keep this regex simple). +KEY_PATH_HEAD = re.compile(r"(\.)*[^.[]*") +# Then we match other keys. The following expression matches one key and can +# be read as a choice between two syntaxes: +# - `.` followed by anything except `.` or `[` (ex: .b, .d) +# - `[` followed by anything then `]` (ex: [b], [c]) +KEY_PATH_OTHER = re.compile(r"\.([^.[]*)|\[(.*?)\]") + + +# source: https://yaml.org/type/bool.html +YAML_BOOL_TYPES = [ + "y", + "Y", + "yes", + "Yes", + "YES", + "n", + "N", + "no", + "No", + "NO", + "true", + "True", + "TRUE", + "false", + "False", + "FALSE", + "on", + "On", + "ON", + "off", + "Off", + "OFF", +] + + +class Marker: + def __init__(self, desc: str): + self.desc = desc + + def __repr__(self) -> str: + return self.desc + + +# To be used as default value when `None` is not an option. +_DEFAULT_MARKER_: Any = Marker("_DEFAULT_MARKER_") + + +class OmegaConfDumper(yaml.Dumper): # type: ignore + str_representer_added = False + + @staticmethod + def str_representer(dumper: yaml.Dumper, data: str) -> yaml.ScalarNode: + with_quotes = yaml_is_bool(data) or is_int(data) or is_float(data) + return dumper.represent_scalar( + yaml.resolver.BaseResolver.DEFAULT_SCALAR_TAG, + data, + style=("'" if with_quotes else None), + ) + + +def get_omega_conf_dumper() -> Type[OmegaConfDumper]: + if not OmegaConfDumper.str_representer_added: + OmegaConfDumper.add_representer(str, OmegaConfDumper.str_representer) + OmegaConfDumper.str_representer_added = True + return OmegaConfDumper + + +def yaml_is_bool(b: str) -> bool: + return b in YAML_BOOL_TYPES + + +def get_yaml_loader() -> Any: + class OmegaConfLoader(yaml.SafeLoader): # type: ignore + def construct_mapping(self, node: yaml.Node, deep: bool = False) -> Any: + keys = set() + for key_node, value_node in node.value: + if key_node.tag != yaml.resolver.BaseResolver.DEFAULT_SCALAR_TAG: + continue + if key_node.value in keys: + raise yaml.constructor.ConstructorError( + "while constructing a mapping", + node.start_mark, + f"found duplicate key {key_node.value}", + key_node.start_mark, + ) + keys.add(key_node.value) + return super().construct_mapping(node, deep=deep) + + loader = OmegaConfLoader + loader.add_implicit_resolver( + "tag:yaml.org,2002:float", + re.compile( + """^(?: + [-+]?[0-9]+(?:_[0-9]+)*\\.[0-9_]*(?:[eE][-+]?[0-9]+)? + |[-+]?[0-9]+(?:_[0-9]+)*(?:[eE][-+]?[0-9]+) + |\\.[0-9]+(?:_[0-9]+)*(?:[eE][-+][0-9]+)? + |[-+]?[0-9]+(?:_[0-9]+)*(?::[0-5]?[0-9])+\\.[0-9_]* + |[-+]?\\.(?:inf|Inf|INF) + |\\.(?:nan|NaN|NAN))$""", + re.X, + ), + list("-+0123456789."), + ) + loader.yaml_implicit_resolvers = { + key: [ + (tag, regexp) + for tag, regexp in resolvers + if tag != "tag:yaml.org,2002:timestamp" + ] + for key, resolvers in loader.yaml_implicit_resolvers.items() + } + + loader.add_constructor( + "tag:yaml.org,2002:python/object/apply:pathlib.Path", + lambda loader, node: pathlib.Path(*loader.construct_sequence(node)), + ) + loader.add_constructor( + "tag:yaml.org,2002:python/object/apply:pathlib.PosixPath", + lambda loader, node: pathlib.PosixPath(*loader.construct_sequence(node)), + ) + loader.add_constructor( + "tag:yaml.org,2002:python/object/apply:pathlib.WindowsPath", + lambda loader, node: pathlib.WindowsPath(*loader.construct_sequence(node)), + ) + + return loader + + +def _get_class(path: str) -> type: + from importlib import import_module + + module_path, _, class_name = path.rpartition(".") + mod = import_module(module_path) + try: + klass: type = getattr(mod, class_name) + except AttributeError: + raise ImportError(f"Class {class_name} is not in module {module_path}") + return klass + + +def is_union_annotation(type_: Any) -> bool: + if sys.version_info >= (3, 10): # pragma: no cover + if isinstance(type_, types.UnionType): + return True + return getattr(type_, "__origin__", None) is Union + + +def _resolve_optional(type_: Any) -> Tuple[bool, Any]: + """Check whether `type_` is equivalent to `typing.Optional[T]` for some T.""" + if is_union_annotation(type_): + args = type_.__args__ + if NoneType in args: + optional = True + args = tuple(a for a in args if a is not NoneType) + else: + optional = False + if len(args) == 1: + return optional, args[0] + elif len(args) >= 2: + return optional, Union[args] + else: + assert False + + if type_ is Any: + return True, Any + + if type_ in (None, NoneType): + return True, NoneType + + return False, type_ + + +def _is_optional(obj: Any, key: Optional[Union[int, str]] = None) -> bool: + """Check `obj` metadata to see if the given node is optional.""" + from .base import Container, Node + + if key is not None: + assert isinstance(obj, Container) + obj = obj._get_node(key) + assert isinstance(obj, Node) + return obj._is_optional() + + +def _resolve_forward(type_: Type[Any], module: str) -> Type[Any]: + import typing # lgtm [py/import-and-import-from] + + forward = typing.ForwardRef if hasattr(typing, "ForwardRef") else typing._ForwardRef # type: ignore + if type(type_) is forward: + return _get_class(f"{module}.{type_.__forward_arg__}") + else: + if is_dict_annotation(type_): + kt, vt = get_dict_key_value_types(type_) + if kt is not None: + kt = _resolve_forward(kt, module=module) + if vt is not None: + vt = _resolve_forward(vt, module=module) + return Dict[kt, vt] # type: ignore + if is_list_annotation(type_): + et = get_list_element_type(type_) + if et is not None: + et = _resolve_forward(et, module=module) + return List[et] # type: ignore + if is_tuple_annotation(type_): + its = get_tuple_item_types(type_) + its = tuple(_resolve_forward(it, module=module) for it in its) + return Tuple[its] # type: ignore + + return type_ + + +def extract_dict_subclass_data(obj: Any, parent: Any) -> Optional[Dict[str, Any]]: + """Check if obj is an instance of a subclass of Dict. If so, extract the Dict keys/values.""" + from omegaconf.omegaconf import _maybe_wrap + + is_type = isinstance(obj, type) + obj_type = obj if is_type else type(obj) + subclasses_dict = is_dict_subclass(obj_type) + + if subclasses_dict: + warnings.warn( + f"Class `{obj_type.__name__}` subclasses `Dict`." + + " Subclassing `Dict` in Structured Config classes is deprecated," + + " see github.com/omry/omegaconf/issues/663", + UserWarning, + stacklevel=9, + ) + + if is_type: + return None + elif subclasses_dict: + dict_subclass_data = {} + key_type, element_type = get_dict_key_value_types(obj_type) + for name, value in obj.items(): + is_optional, type_ = _resolve_optional(element_type) + type_ = _resolve_forward(type_, obj.__module__) + try: + dict_subclass_data[name] = _maybe_wrap( + ref_type=type_, + is_optional=is_optional, + key=name, + value=value, + parent=parent, + ) + except ValidationError as ex: + format_and_raise( + node=None, key=name, value=value, cause=ex, msg=str(ex) + ) + return dict_subclass_data + else: + return None + + +def get_attr_class_fields(obj: Any) -> List["attr.Attribute[Any]"]: + is_type = isinstance(obj, type) + obj_type = obj if is_type else type(obj) + fields = attr.fields_dict(obj_type).values() + return [f for f in fields if f.metadata.get("omegaconf_ignore") is not True] + + +def get_attr_data(obj: Any, allow_objects: Optional[bool] = None) -> Dict[str, Any]: + from omegaconf.omegaconf import OmegaConf, _maybe_wrap + + flags = {"allow_objects": allow_objects} if allow_objects is not None else {} + + from omegaconf import MISSING + + d = {} + is_type = isinstance(obj, type) + obj_type = obj if is_type else type(obj) + dummy_parent = OmegaConf.create({}, flags=flags) + dummy_parent._metadata.object_type = obj_type + resolved_hints = get_type_hints(obj_type) + + for attrib in get_attr_class_fields(obj): + name = attrib.name + is_optional, type_ = _resolve_optional(resolved_hints[name]) + type_ = _resolve_forward(type_, obj.__module__) + if not is_type: + value = getattr(obj, name) + else: + value = attrib.default + if value == attr.NOTHING: + value = MISSING + if is_union_annotation(type_) and not is_supported_union_annotation(type_): + e = ConfigValueError( + f"Unions of containers are not supported:\n{name}: {type_str(type_)}" + ) + format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e)) + + try: + d[name] = _maybe_wrap( + ref_type=type_, + is_optional=is_optional, + key=name, + value=value, + parent=dummy_parent, + ) + except (ValidationError, GrammarParseError) as ex: + format_and_raise( + node=dummy_parent, key=name, value=value, cause=ex, msg=str(ex) + ) + d[name]._set_parent(None) + dict_subclass_data = extract_dict_subclass_data(obj=obj, parent=dummy_parent) + if dict_subclass_data is not None: + d.update(dict_subclass_data) + return d + + +def get_dataclass_fields(obj: Any) -> List["dataclasses.Field[Any]"]: + fields = dataclasses.fields(obj) + return [f for f in fields if f.metadata.get("omegaconf_ignore") is not True] + + +def get_dataclass_data( + obj: Any, allow_objects: Optional[bool] = None +) -> Dict[str, Any]: + from omegaconf.omegaconf import MISSING, OmegaConf, _maybe_wrap + + flags = {"allow_objects": allow_objects} if allow_objects is not None else {} + d = {} + is_type = isinstance(obj, type) + obj_type = get_type_of(obj) + dummy_parent = OmegaConf.create({}, flags=flags) + dummy_parent._metadata.object_type = obj_type + resolved_hints = get_type_hints(obj_type) + for field in get_dataclass_fields(obj): + name = field.name + is_optional, type_ = _resolve_optional(resolved_hints[field.name]) + type_ = _resolve_forward(type_, obj.__module__) + has_default = field.default != dataclasses.MISSING + has_default_factory = field.default_factory != dataclasses.MISSING + + if not is_type: + value = getattr(obj, name) + else: + if has_default: + value = field.default + elif has_default_factory: + value = field.default_factory() # type: ignore + else: + value = MISSING + + if is_union_annotation(type_) and not is_supported_union_annotation(type_): + e = ConfigValueError( + f"Unions of containers are not supported:\n{name}: {type_str(type_)}" + ) + format_and_raise(node=None, key=None, value=value, cause=e, msg=str(e)) + try: + d[name] = _maybe_wrap( + ref_type=type_, + is_optional=is_optional, + key=name, + value=value, + parent=dummy_parent, + ) + except (ValidationError, GrammarParseError) as ex: + format_and_raise( + node=dummy_parent, key=name, value=value, cause=ex, msg=str(ex) + ) + d[name]._set_parent(None) + dict_subclass_data = extract_dict_subclass_data(obj=obj, parent=dummy_parent) + if dict_subclass_data is not None: + d.update(dict_subclass_data) + return d + + +def is_dataclass(obj: Any) -> bool: + from omegaconf.base import Node + + if dataclasses is None or isinstance(obj, Node): + return False + return dataclasses.is_dataclass(obj) + + +def is_attr_class(obj: Any) -> bool: + from omegaconf.base import Node + + if attr is None or isinstance(obj, Node): + return False + return attr.has(obj) + + +def is_structured_config(obj: Any) -> bool: + return is_attr_class(obj) or is_dataclass(obj) + + +def is_dataclass_frozen(type_: Any) -> bool: + return type_.__dataclass_params__.frozen # type: ignore + + +def is_attr_frozen(type_: type) -> bool: + # This is very hacky and probably fragile as well. + # Unfortunately currently there isn't an official API in attr that can detect that. + # noinspection PyProtectedMember + return type_.__setattr__ == attr._make._frozen_setattrs # type: ignore + + +def get_type_of(class_or_object: Any) -> Type[Any]: + type_ = class_or_object + if not isinstance(type_, type): + type_ = type(class_or_object) + assert isinstance(type_, type) + return type_ + + +def is_structured_config_frozen(obj: Any) -> bool: + type_ = get_type_of(obj) + + if is_dataclass(type_): + return is_dataclass_frozen(type_) + if is_attr_class(type_): + return is_attr_frozen(type_) + return False + + +def get_structured_config_init_field_names(obj: Any) -> List[str]: + fields: Union[List["dataclasses.Field[Any]"], List["attr.Attribute[Any]"]] + if is_dataclass(obj): + fields = get_dataclass_fields(obj) + elif is_attr_class(obj): + fields = get_attr_class_fields(obj) + else: + raise ValueError(f"Unsupported type: {type(obj).__name__}") + return [f.name for f in fields if f.init] + + +def get_structured_config_data( + obj: Any, allow_objects: Optional[bool] = None +) -> Dict[str, Any]: + if is_dataclass(obj): + return get_dataclass_data(obj, allow_objects=allow_objects) + elif is_attr_class(obj): + return get_attr_data(obj, allow_objects=allow_objects) + else: + raise ValueError(f"Unsupported type: {type(obj).__name__}") + + +class ValueKind(Enum): + VALUE = 0 + MANDATORY_MISSING = 1 + INTERPOLATION = 2 + + +def _is_missing_value(value: Any) -> bool: + from omegaconf import Node + + if isinstance(value, Node): + value = value._value() + return _is_missing_literal(value) + + +def _is_missing_literal(value: Any) -> bool: + # Uses literal '???' instead of the MISSING const for performance reasons. + return isinstance(value, str) and value == "???" + + +def _is_none( + value: Any, resolve: bool = False, throw_on_resolution_failure: bool = True +) -> bool: + from omegaconf import Node + + if not isinstance(value, Node): + return value is None + + if resolve: + value = value._maybe_dereference_node( + throw_on_resolution_failure=throw_on_resolution_failure + ) + if not throw_on_resolution_failure and value is None: + # Resolution failure: consider that it is *not* None. + return False + assert isinstance(value, Node) + + return value._is_none() + + +def get_value_kind( + value: Any, strict_interpolation_validation: bool = False +) -> ValueKind: + """ + Determine the kind of a value + Examples: + VALUE: "10", "20", True + MANDATORY_MISSING: "???" + INTERPOLATION: "${foo.bar}", "${foo.${bar}}", "${foo:bar}", "[${foo}, ${bar}]", + "ftp://${host}/path", "${foo:${bar}, [true], {'baz': ${baz}}}" + + :param value: Input to classify. + :param strict_interpolation_validation: If `True`, then when `value` is a string + containing "${", it is parsed to validate the interpolation syntax. If `False`, + this parsing step is skipped: this is more efficient, but will not detect errors. + """ + + if _is_missing_value(value): + return ValueKind.MANDATORY_MISSING + + if _is_interpolation(value, strict_interpolation_validation): + return ValueKind.INTERPOLATION + + return ValueKind.VALUE + + +def _is_interpolation(v: Any, strict_interpolation_validation: bool = False) -> bool: + from omegaconf import Node + + if isinstance(v, Node): + v = v._value() + + if isinstance(v, str) and _is_interpolation_string( + v, strict_interpolation_validation + ): + return True + return False + + +def _is_interpolation_string(value: str, strict_interpolation_validation: bool) -> bool: + # We identify potential interpolations by the presence of "${" in the string. + # Note that escaped interpolations (ex: "esc: \${bar}") are identified as + # interpolations: this is intended, since they must be processed as interpolations + # for the string to be properly un-escaped. + # Keep in mind that invalid interpolations will only be detected when + # `strict_interpolation_validation` is True. + if "${" in value: + if strict_interpolation_validation: + # First try the cheap regex matching that detects common interpolations. + if SIMPLE_INTERPOLATION_PATTERN.match(value) is None: + # If no match, do the more expensive grammar parsing to detect errors. + parse(value) + return True + return False + + +def _is_special(value: Any) -> bool: + """Special values are None, MISSING, and interpolation.""" + return _is_none(value) or get_value_kind(value) in ( + ValueKind.MANDATORY_MISSING, + ValueKind.INTERPOLATION, + ) + + +def is_float(st: str) -> bool: + try: + float(st) + return True + except ValueError: + return False + + +def is_int(st: str) -> bool: + try: + int(st) + return True + except ValueError: + return False + + +def is_primitive_list(obj: Any) -> bool: + return isinstance(obj, (list, tuple)) + + +def is_primitive_dict(obj: Any) -> bool: + t = get_type_of(obj) + return t is dict + + +def is_dict_annotation(type_: Any) -> bool: + if type_ in (dict, Dict): + return True + origin = getattr(type_, "__origin__", None) + # type_dict is a bit hard to detect. + # this support is tentative, if it eventually causes issues in other areas it may be dropped. + if sys.version_info < (3, 7, 0): # pragma: no cover + typed_dict = hasattr(type_, "__base__") and type_.__base__ == Dict + return origin is Dict or type_ is Dict or typed_dict + else: # pragma: no cover + typed_dict = hasattr(type_, "__base__") and type_.__base__ == dict + return origin is dict or typed_dict + + +def is_list_annotation(type_: Any) -> bool: + if type_ in (list, List): + return True + origin = getattr(type_, "__origin__", None) + if sys.version_info < (3, 7, 0): + return origin is List or type_ is List # pragma: no cover + else: + return origin is list # pragma: no cover + + +def is_tuple_annotation(type_: Any) -> bool: + if type_ in (tuple, Tuple): + return True + origin = getattr(type_, "__origin__", None) + if sys.version_info < (3, 7, 0): + return origin is Tuple or type_ is Tuple # pragma: no cover + else: + return origin is tuple # pragma: no cover + + +def is_supported_union_annotation(obj: Any) -> bool: + """Currently only primitive types are supported in Unions, e.g. Union[int, str]""" + if not is_union_annotation(obj): + return False + args = obj.__args__ + return all(is_primitive_type_annotation(arg) for arg in args) + + +def is_dict_subclass(type_: Any) -> bool: + return type_ is not None and isinstance(type_, type) and issubclass(type_, Dict) + + +def is_dict(obj: Any) -> bool: + return is_primitive_dict(obj) or is_dict_annotation(obj) or is_dict_subclass(obj) + + +def is_primitive_container(obj: Any) -> bool: + return is_primitive_list(obj) or is_primitive_dict(obj) + + +def get_list_element_type(ref_type: Optional[Type[Any]]) -> Any: + args = getattr(ref_type, "__args__", None) + if ref_type is not List and args is not None and args[0]: + element_type = args[0] + else: + element_type = Any + return element_type + + +def get_tuple_item_types(ref_type: Type[Any]) -> Tuple[Any, ...]: + args = getattr(ref_type, "__args__", None) + if args in (None, ()): + args = (Any, ...) + assert isinstance(args, tuple) + return args + + +def get_dict_key_value_types(ref_type: Any) -> Tuple[Any, Any]: + args = getattr(ref_type, "__args__", None) + if args is None: + bases = getattr(ref_type, "__orig_bases__", None) + if bases is not None and len(bases) > 0: + args = getattr(bases[0], "__args__", None) + + key_type: Any + element_type: Any + if ref_type is None or ref_type == Dict: + key_type = Any + element_type = Any + else: + if args is not None: + key_type = args[0] + element_type = args[1] + else: + key_type = Any + element_type = Any + + return key_type, element_type + + +def is_valid_value_annotation(type_: Any) -> bool: + _, type_ = _resolve_optional(type_) + return ( + type_ is Any + or is_primitive_type_annotation(type_) + or is_structured_config(type_) + or is_container_annotation(type_) + or is_supported_union_annotation(type_) + ) + + +def _valid_dict_key_annotation_type(type_: Any) -> bool: + from omegaconf import DictKeyType + + return type_ is None or type_ is Any or issubclass(type_, DictKeyType.__args__) # type: ignore + + +def is_primitive_type_annotation(type_: Any) -> bool: + type_ = get_type_of(type_) + return issubclass(type_, (Enum, pathlib.Path)) or type_ in BUILTIN_VALUE_TYPES + + +def _get_value(value: Any) -> Any: + from .base import Container, UnionNode + from .nodes import ValueNode + + if isinstance(value, ValueNode): + return value._value() + elif isinstance(value, Container): + boxed = value._value() + if boxed is None or _is_missing_literal(boxed) or _is_interpolation(boxed): + return boxed + elif isinstance(value, UnionNode): + boxed = value._value() + if boxed is None or _is_missing_literal(boxed) or _is_interpolation(boxed): + return boxed + else: + return _get_value(boxed) # pass through value of boxed node + + # return primitives and regular OmegaConf Containers as is + return value + + +def get_type_hint(obj: Any, key: Any = None) -> Optional[Type[Any]]: + from omegaconf import Container, Node + + if isinstance(obj, Container): + if key is not None: + obj = obj._get_node(key) + else: + if key is not None: + raise ValueError("Key must only be provided when obj is a container") + + if isinstance(obj, Node): + ref_type = obj._metadata.ref_type + if obj._is_optional() and ref_type is not Any: + return Optional[ref_type] # type: ignore + else: + return ref_type + else: + return Any # type: ignore + + +def _raise(ex: Exception, cause: Exception) -> None: + # Set the environment variable OC_CAUSE=1 to get a stacktrace that includes the + # causing exception. + env_var = os.environ["OC_CAUSE"] if "OC_CAUSE" in os.environ else None + debugging = sys.gettrace() is not None + full_backtrace = (debugging and not env_var == "0") or (env_var == "1") + if full_backtrace: + ex.__cause__ = cause + else: + ex.__cause__ = None + raise ex.with_traceback(sys.exc_info()[2]) # set env var OC_CAUSE=1 for full trace + + +def format_and_raise( + node: Any, + key: Any, + value: Any, + msg: str, + cause: Exception, + type_override: Any = None, +) -> None: + from omegaconf import OmegaConf + from omegaconf.base import Node + + if isinstance(cause, AssertionError): + raise + + if isinstance(cause, OmegaConfBaseException) and cause._initialized: + ex = cause + if type_override is not None: + ex = type_override(str(cause)) + ex.__dict__ = copy.deepcopy(cause.__dict__) + _raise(ex, cause) + + object_type: Optional[Type[Any]] + object_type_str: Optional[str] = None + ref_type: Optional[Type[Any]] + ref_type_str: Optional[str] + + child_node: Optional[Node] = None + if node is None: + full_key = key if key is not None else "" + object_type = None + ref_type = None + ref_type_str = None + else: + if key is not None and not node._is_none(): + child_node = node._get_node(key, validate_access=False) + + try: + full_key = node._get_full_key(key=key) + except Exception as exc: + # Since we are handling an exception, raising a different one here would + # be misleading. Instead, we display it in the key. + full_key = f"" + + object_type = OmegaConf.get_type(node) + object_type_str = type_str(object_type) + + ref_type = get_type_hint(node) + ref_type_str = type_str(ref_type) + + msg = string.Template(msg).safe_substitute( + REF_TYPE=ref_type_str, + OBJECT_TYPE=object_type_str, + KEY=key, + FULL_KEY=full_key, + VALUE=value, + VALUE_TYPE=type_str(type(value), include_module_name=True), + KEY_TYPE=f"{type(key).__name__}", + ) + + if ref_type not in (None, Any): + template = dedent( + """\ + $MSG + full_key: $FULL_KEY + reference_type=$REF_TYPE + object_type=$OBJECT_TYPE""" + ) + else: + template = dedent( + """\ + $MSG + full_key: $FULL_KEY + object_type=$OBJECT_TYPE""" + ) + s = string.Template(template=template) + + message = s.substitute( + REF_TYPE=ref_type_str, OBJECT_TYPE=object_type_str, MSG=msg, FULL_KEY=full_key + ) + exception_type = type(cause) if type_override is None else type_override + if exception_type == TypeError: + exception_type = ConfigTypeError + elif exception_type == IndexError: + exception_type = ConfigIndexError + + ex = exception_type(f"{message}") + if issubclass(exception_type, OmegaConfBaseException): + ex._initialized = True + ex.msg = message + ex.parent_node = node + ex.child_node = child_node + ex.key = key + ex.full_key = full_key + ex.value = value + ex.object_type = object_type + ex.object_type_str = object_type_str + ex.ref_type = ref_type + ex.ref_type_str = ref_type_str + + _raise(ex, cause) + + +def type_str(t: Any, include_module_name: bool = False) -> str: + is_optional, t = _resolve_optional(t) + if t is NoneType: + return str(t.__name__) + if t is Any: + return "Any" + if t is ...: + return "..." + + if hasattr(t, "__name__"): + name = str(t.__name__) + elif getattr(t, "_name", None) is not None: # pragma: no cover + name = str(t._name) + elif getattr(t, "__origin__", None) is not None: # pragma: no cover + name = type_str(t.__origin__) + else: + name = str(t) + if name.startswith("typing."): # pragma: no cover + name = name[len("typing.") :] + + args = getattr(t, "__args__", None) + if args is not None: + args = ", ".join( + [type_str(t, include_module_name=include_module_name) for t in t.__args__] + ) + ret = f"{name}[{args}]" + else: + ret = name + if include_module_name: + if ( + hasattr(t, "__module__") + and t.__module__ != "builtins" + and t.__module__ != "typing" + and not t.__module__.startswith("omegaconf.") + ): + module_prefix = str(t.__module__) + "." + else: + module_prefix = "" + ret = module_prefix + ret + if is_optional: + return f"Optional[{ret}]" + else: + return ret + + +def _ensure_container(target: Any, flags: Optional[Dict[str, bool]] = None) -> Any: + from omegaconf import OmegaConf + + if is_primitive_container(target): + assert isinstance(target, (list, dict)) + target = OmegaConf.create(target, flags=flags) + elif is_structured_config(target): + target = OmegaConf.structured(target, flags=flags) + elif not OmegaConf.is_config(target): + raise ValueError( + "Invalid input. Supports one of " + + "[dict,list,DictConfig,ListConfig,dataclass,dataclass instance,attr class,attr class instance]" + ) + + return target + + +def is_generic_list(type_: Any) -> bool: + """ + Checks if a type is a generic list, for example: + list returns False + typing.List returns False + typing.List[T] returns True + + :param type_: variable type + :return: bool + """ + return is_list_annotation(type_) and get_list_element_type(type_) is not None + + +def is_generic_dict(type_: Any) -> bool: + """ + Checks if a type is a generic dict, for example: + list returns False + typing.List returns False + typing.List[T] returns True + + :param type_: variable type + :return: bool + """ + return is_dict_annotation(type_) and len(get_dict_key_value_types(type_)) > 0 + + +def is_container_annotation(type_: Any) -> bool: + return is_list_annotation(type_) or is_dict_annotation(type_) + + +def split_key(key: str) -> List[str]: + """ + Split a full key path into its individual components. + + This is similar to `key.split(".")` but also works with the getitem syntax: + "a.b" -> ["a", "b"] + "a[b]" -> ["a", "b"] + ".a.b[c].d" -> ["", "a", "b", "c", "d"] + "[a].b" -> ["a", "b"] + """ + # Obtain the first part of the key (in docstring examples: a, a, .a, '') + first = KEY_PATH_HEAD.match(key) + assert first is not None + first_stop = first.span()[1] + + # `tokens` will contain all elements composing the key. + tokens = key[0:first_stop].split(".") + + # Optimization in case `key` has no other component: we are done. + if first_stop == len(key): + return tokens + + if key[first_stop] == "[" and not tokens[-1]: + # This is a special case where the first key starts with brackets, e.g. + # [a] or ..[a]. In that case there is an extra "" in `tokens` that we + # need to get rid of: + # [a] -> tokens = [""] but we would like [] + # ..[a] -> tokens = ["", "", ""] but we would like ["", ""] + tokens.pop() + + # Identify other key elements (in docstring examples: b, b, b/c/d, b) + others = KEY_PATH_OTHER.findall(key[first_stop:]) + + # There are two groups in the `KEY_PATH_OTHER` regex: one for keys starting + # with a dot (.b, .d) and one for keys starting with a bracket ([b], [c]). + # Only one group can be non-empty. + tokens += [dot_key if dot_key else bracket_key for dot_key, bracket_key in others] + + return tokens + + +# Similar to Python 3.7+'s `contextlib.nullcontext` (which should be used instead, +# once support for Python 3.6 is dropped). +@contextmanager +def nullcontext(enter_result: Any = None) -> Iterator[Any]: + yield enter_result diff --git a/runtime/Lib/site-packages/omegaconf/base.py b/runtime/Lib/site-packages/omegaconf/base.py new file mode 100644 index 0000000000000000000000000000000000000000..8b013d1d9fac789cc28e8ea0a23e586610a32f43 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/base.py @@ -0,0 +1,962 @@ +import copy +import sys +from abc import ABC, abstractmethod +from collections import defaultdict +from dataclasses import dataclass, field +from enum import Enum +from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Type, Union + +from antlr4 import ParserRuleContext + +from ._utils import ( + _DEFAULT_MARKER_, + NoneType, + ValueKind, + _get_value, + _is_interpolation, + _is_missing_value, + _is_special, + format_and_raise, + get_value_kind, + is_union_annotation, + is_valid_value_annotation, + split_key, + type_str, +) +from .errors import ( + ConfigKeyError, + ConfigTypeError, + InterpolationKeyError, + InterpolationResolutionError, + InterpolationToMissingValueError, + InterpolationValidationError, + MissingMandatoryValue, + UnsupportedInterpolationType, + ValidationError, +) +from .grammar.gen.OmegaConfGrammarParser import OmegaConfGrammarParser +from .grammar_parser import parse +from .grammar_visitor import GrammarVisitor + +DictKeyType = Union[str, bytes, int, Enum, float, bool] + + +@dataclass +class Metadata: + + ref_type: Union[Type[Any], Any] + + object_type: Union[Type[Any], Any] + + optional: bool + + key: Any + + # Flags have 3 modes: + # unset : inherit from parent (None if no parent specifies) + # set to true: flag is true + # set to false: flag is false + flags: Optional[Dict[str, bool]] = None + + # If True, when checking the value of a flag, if the flag is not set None is returned + # otherwise, the parent node is queried. + flags_root: bool = False + + resolver_cache: Dict[str, Any] = field(default_factory=lambda: defaultdict(dict)) + + def __post_init__(self) -> None: + if self.flags is None: + self.flags = {} + + @property + def type_hint(self) -> Union[Type[Any], Any]: + """Compute `type_hint` from `self.optional` and `self.ref_type`""" + # For compatibility with pickled OmegaConf objects created using older + # versions of OmegaConf, we store `ref_type` and `object_type` + # separately (rather than storing `type_hint` directly). + if self.optional: + return Optional[self.ref_type] + else: + return self.ref_type + + +@dataclass +class ContainerMetadata(Metadata): + key_type: Any = None + element_type: Any = None + + def __post_init__(self) -> None: + if self.ref_type is None: + self.ref_type = Any + assert self.key_type is Any or isinstance(self.key_type, type) + if self.element_type is not None: + if not is_valid_value_annotation(self.element_type): + raise ValidationError( + f"Unsupported value type: '{type_str(self.element_type, include_module_name=True)}'" + ) + + if self.flags is None: + self.flags = {} + + +class Node(ABC): + _metadata: Metadata + + _parent: Optional["Box"] + _flags_cache: Optional[Dict[str, Optional[bool]]] + + def __init__(self, parent: Optional["Box"], metadata: Metadata): + self.__dict__["_metadata"] = metadata + self.__dict__["_parent"] = parent + self.__dict__["_flags_cache"] = None + + def __getstate__(self) -> Dict[str, Any]: + # Overridden to ensure that the flags cache is cleared on serialization. + state_dict = copy.copy(self.__dict__) + del state_dict["_flags_cache"] + return state_dict + + def __setstate__(self, state_dict: Dict[str, Any]) -> None: + self.__dict__.update(state_dict) + self.__dict__["_flags_cache"] = None + + def _set_parent(self, parent: Optional["Box"]) -> None: + assert parent is None or isinstance(parent, Box) + self.__dict__["_parent"] = parent + self._invalidate_flags_cache() + + def _invalidate_flags_cache(self) -> None: + self.__dict__["_flags_cache"] = None + + def _get_parent(self) -> Optional["Box"]: + parent = self.__dict__["_parent"] + assert parent is None or isinstance(parent, Box) + return parent + + def _get_parent_container(self) -> Optional["Container"]: + """ + Like _get_parent, but returns the grandparent + in the case where `self` is wrapped by a UnionNode. + """ + parent = self.__dict__["_parent"] + assert parent is None or isinstance(parent, Box) + + if isinstance(parent, UnionNode): + grandparent = parent.__dict__["_parent"] + assert grandparent is None or isinstance(grandparent, Container) + return grandparent + else: + assert parent is None or isinstance(parent, Container) + return parent + + def _set_flag( + self, + flags: Union[List[str], str], + values: Union[List[Optional[bool]], Optional[bool]], + ) -> "Node": + if isinstance(flags, str): + flags = [flags] + + if values is None or isinstance(values, bool): + values = [values] + + if len(values) == 1: + values = len(flags) * values + + if len(flags) != len(values): + raise ValueError("Inconsistent lengths of input flag names and values") + + for idx, flag in enumerate(flags): + value = values[idx] + if value is None: + assert self._metadata.flags is not None + if flag in self._metadata.flags: + del self._metadata.flags[flag] + else: + assert self._metadata.flags is not None + self._metadata.flags[flag] = value + self._invalidate_flags_cache() + return self + + def _get_node_flag(self, flag: str) -> Optional[bool]: + """ + :param flag: flag to inspect + :return: the state of the flag on this node. + """ + assert self._metadata.flags is not None + return self._metadata.flags.get(flag) + + def _get_flag(self, flag: str) -> Optional[bool]: + cache = self.__dict__["_flags_cache"] + if cache is None: + cache = self.__dict__["_flags_cache"] = {} + + ret = cache.get(flag, _DEFAULT_MARKER_) + if ret is _DEFAULT_MARKER_: + ret = self._get_flag_no_cache(flag) + cache[flag] = ret + assert ret is None or isinstance(ret, bool) + return ret + + def _get_flag_no_cache(self, flag: str) -> Optional[bool]: + """ + Returns True if this config node flag is set + A flag is set if node.set_flag(True) was called + or one if it's parents is flag is set + :return: + """ + flags = self._metadata.flags + assert flags is not None + if flag in flags and flags[flag] is not None: + return flags[flag] + + if self._is_flags_root(): + return None + + parent = self._get_parent() + if parent is None: + return None + else: + # noinspection PyProtectedMember + return parent._get_flag(flag) + + def _format_and_raise( + self, + key: Any, + value: Any, + cause: Exception, + msg: Optional[str] = None, + type_override: Any = None, + ) -> None: + format_and_raise( + node=self, + key=key, + value=value, + msg=str(cause) if msg is None else msg, + cause=cause, + type_override=type_override, + ) + assert False + + @abstractmethod + def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str: + ... + + def _dereference_node(self) -> "Node": + node = self._dereference_node_impl(throw_on_resolution_failure=True) + assert node is not None + return node + + def _maybe_dereference_node( + self, + throw_on_resolution_failure: bool = False, + memo: Optional[Set[int]] = None, + ) -> Optional["Node"]: + return self._dereference_node_impl( + throw_on_resolution_failure=throw_on_resolution_failure, + memo=memo, + ) + + def _dereference_node_impl( + self, + throw_on_resolution_failure: bool, + memo: Optional[Set[int]] = None, + ) -> Optional["Node"]: + if not self._is_interpolation(): + return self + + parent = self._get_parent_container() + if parent is None: + if throw_on_resolution_failure: + raise InterpolationResolutionError( + "Cannot resolve interpolation for a node without a parent" + ) + return None + assert parent is not None + key = self._key() + return parent._resolve_interpolation_from_parse_tree( + parent=parent, + key=key, + value=self, + parse_tree=parse(_get_value(self)), + throw_on_resolution_failure=throw_on_resolution_failure, + memo=memo, + ) + + def _get_root(self) -> "Container": + root: Optional[Box] = self._get_parent() + if root is None: + assert isinstance(self, Container) + return self + assert root is not None and isinstance(root, Box) + while root._get_parent() is not None: + root = root._get_parent() + assert root is not None and isinstance(root, Box) + assert root is not None and isinstance(root, Container) + return root + + def _is_missing(self) -> bool: + """ + Check if the node's value is `???` (does *not* resolve interpolations). + """ + return _is_missing_value(self) + + def _is_none(self) -> bool: + """ + Check if the node's value is `None` (does *not* resolve interpolations). + """ + return self._value() is None + + @abstractmethod + def __eq__(self, other: Any) -> bool: + ... + + @abstractmethod + def __ne__(self, other: Any) -> bool: + ... + + @abstractmethod + def __hash__(self) -> int: + ... + + @abstractmethod + def _value(self) -> Any: + ... + + @abstractmethod + def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None: + ... + + @abstractmethod + def _is_optional(self) -> bool: + ... + + @abstractmethod + def _is_interpolation(self) -> bool: + ... + + def _key(self) -> Any: + return self._metadata.key + + def _set_key(self, key: Any) -> None: + self._metadata.key = key + + def _is_flags_root(self) -> bool: + return self._metadata.flags_root + + def _set_flags_root(self, flags_root: bool) -> None: + if self._metadata.flags_root != flags_root: + self._metadata.flags_root = flags_root + self._invalidate_flags_cache() + + def _has_ref_type(self) -> bool: + return self._metadata.ref_type is not Any + + +class Box(Node): + """ + Base class for nodes that can contain other nodes. + Concrete subclasses include DictConfig, ListConfig, and UnionNode. + """ + + _content: Any + + def __init__(self, parent: Optional["Box"], metadata: Metadata): + super().__init__(parent=parent, metadata=metadata) + self.__dict__["_content"] = None + + def __copy__(self) -> Any: + # real shallow copy is impossible because of the reference to the parent. + return copy.deepcopy(self) + + def _re_parent(self) -> None: + from .dictconfig import DictConfig + from .listconfig import ListConfig + + # update parents of first level Config nodes to self + + if isinstance(self, DictConfig): + content = self.__dict__["_content"] + if isinstance(content, dict): + for _key, value in self.__dict__["_content"].items(): + if value is not None: + value._set_parent(self) + if isinstance(value, Box): + value._re_parent() + elif isinstance(self, ListConfig): + content = self.__dict__["_content"] + if isinstance(content, list): + for item in self.__dict__["_content"]: + if item is not None: + item._set_parent(self) + if isinstance(item, Box): + item._re_parent() + elif isinstance(self, UnionNode): + content = self.__dict__["_content"] + if isinstance(content, Node): + content._set_parent(self) + if isinstance(content, Box): # pragma: no cover + # No coverage here as support for containers inside + # UnionNode is not yet implemented + content._re_parent() + + +class Container(Box): + """ + Container tagging interface + """ + + _metadata: ContainerMetadata + + @abstractmethod + def _get_child( + self, + key: Any, + validate_access: bool = True, + validate_key: bool = True, + throw_on_missing_value: bool = False, + throw_on_missing_key: bool = False, + ) -> Union[Optional[Node], List[Optional[Node]]]: + ... + + @abstractmethod + def _get_node( + self, + key: Any, + validate_access: bool = True, + validate_key: bool = True, + throw_on_missing_value: bool = False, + throw_on_missing_key: bool = False, + ) -> Union[Optional[Node], List[Optional[Node]]]: + ... + + @abstractmethod + def __delitem__(self, key: Any) -> None: + ... + + @abstractmethod + def __setitem__(self, key: Any, value: Any) -> None: + ... + + @abstractmethod + def __iter__(self) -> Iterator[Any]: + ... + + @abstractmethod + def __getitem__(self, key_or_index: Any) -> Any: + ... + + def _resolve_key_and_root(self, key: str) -> Tuple["Container", str]: + orig = key + if not key.startswith("."): + return self._get_root(), key + else: + root: Optional[Container] = self + assert key.startswith(".") + while True: + assert root is not None + key = key[1:] + if not key.startswith("."): + break + root = root._get_parent_container() + if root is None: + raise ConfigKeyError(f"Error resolving key '{orig}'") + + return root, key + + def _select_impl( + self, + key: str, + throw_on_missing: bool, + throw_on_resolution_failure: bool, + memo: Optional[Set[int]] = None, + ) -> Tuple[Optional["Container"], Optional[str], Optional[Node]]: + """ + Select a value using dot separated key sequence + """ + from .omegaconf import _select_one + + if key == "": + return self, "", self + + split = split_key(key) + root: Optional[Container] = self + for i in range(len(split) - 1): + if root is None: + break + + k = split[i] + ret, _ = _select_one( + c=root, + key=k, + throw_on_missing=throw_on_missing, + throw_on_type_error=throw_on_resolution_failure, + ) + if isinstance(ret, Node): + ret = ret._maybe_dereference_node( + throw_on_resolution_failure=throw_on_resolution_failure, + memo=memo, + ) + + if ret is not None and not isinstance(ret, Container): + parent_key = ".".join(split[0 : i + 1]) + child_key = split[i + 1] + raise ConfigTypeError( + f"Error trying to access {key}: node `{parent_key}` " + f"is not a container and thus cannot contain `{child_key}`" + ) + root = ret + + if root is None: + return None, None, None + + last_key = split[-1] + value, _ = _select_one( + c=root, + key=last_key, + throw_on_missing=throw_on_missing, + throw_on_type_error=throw_on_resolution_failure, + ) + if value is None: + return root, last_key, None + + if memo is not None: + vid = id(value) + if vid in memo: + raise InterpolationResolutionError("Recursive interpolation detected") + # push to memo "stack" + memo.add(vid) + + try: + value = root._maybe_resolve_interpolation( + parent=root, + key=last_key, + value=value, + throw_on_resolution_failure=throw_on_resolution_failure, + memo=memo, + ) + finally: + if memo is not None: + # pop from memo "stack" + memo.remove(vid) + + return root, last_key, value + + def _resolve_interpolation_from_parse_tree( + self, + parent: Optional["Container"], + value: "Node", + key: Any, + parse_tree: OmegaConfGrammarParser.ConfigValueContext, + throw_on_resolution_failure: bool, + memo: Optional[Set[int]], + ) -> Optional["Node"]: + """ + Resolve an interpolation. + + This happens in two steps: + 1. The parse tree is visited, which outputs either a `Node` (e.g., + for node interpolations "${foo}"), a string (e.g., for string + interpolations "hello ${name}", or any other arbitrary value + (e.g., or custom interpolations "${foo:bar}"). + 2. This output is potentially validated and converted when the node + being resolved (`value`) is typed. + + If an error occurs in one of the above steps, an `InterpolationResolutionError` + (or a subclass of it) is raised, *unless* `throw_on_resolution_failure` is set + to `False` (in which case the return value is `None`). + + :param parent: Parent of the node being resolved. + :param value: Node being resolved. + :param key: The associated key in the parent. + :param parse_tree: The parse tree as obtained from `grammar_parser.parse()`. + :param throw_on_resolution_failure: If `False`, then exceptions raised during + the resolution of the interpolation are silenced, and instead `None` is + returned. + + :return: A `Node` that contains the interpolation result. This may be an existing + node in the config (in the case of a node interpolation "${foo}"), or a new + node that is created to wrap the interpolated value. It is `None` if and only if + `throw_on_resolution_failure` is `False` and an error occurs during resolution. + """ + + try: + resolved = self.resolve_parse_tree( + parse_tree=parse_tree, node=value, key=key, memo=memo + ) + except InterpolationResolutionError: + if throw_on_resolution_failure: + raise + return None + + return self._validate_and_convert_interpolation_result( + parent=parent, + value=value, + key=key, + resolved=resolved, + throw_on_resolution_failure=throw_on_resolution_failure, + ) + + def _validate_and_convert_interpolation_result( + self, + parent: Optional["Container"], + value: "Node", + key: Any, + resolved: Any, + throw_on_resolution_failure: bool, + ) -> Optional["Node"]: + from .nodes import AnyNode, InterpolationResultNode, ValueNode + + # If the output is not a Node already (e.g., because it is the output of a + # custom resolver), then we will need to wrap it within a Node. + must_wrap = not isinstance(resolved, Node) + + # If the node is typed, validate (and possibly convert) the result. + if isinstance(value, ValueNode) and not isinstance(value, AnyNode): + res_value = _get_value(resolved) + try: + conv_value = value.validate_and_convert(res_value) + except ValidationError as e: + if throw_on_resolution_failure: + self._format_and_raise( + key=key, + value=res_value, + cause=e, + msg=f"While dereferencing interpolation '{value}': {e}", + type_override=InterpolationValidationError, + ) + return None + + # If the converted value is of the same type, it means that no conversion + # was actually needed. As a result, we can keep the original `resolved` + # (and otherwise, the converted value must be wrapped into a new node). + if type(conv_value) != type(res_value): + must_wrap = True + resolved = conv_value + + if must_wrap: + return InterpolationResultNode(value=resolved, key=key, parent=parent) + else: + assert isinstance(resolved, Node) + return resolved + + def _validate_not_dereferencing_to_parent(self, node: Node, target: Node) -> None: + parent: Optional[Node] = node + while parent is not None: + if parent is target: + raise InterpolationResolutionError( + "Interpolation to parent node detected" + ) + parent = parent._get_parent() + + def _resolve_node_interpolation( + self, inter_key: str, memo: Optional[Set[int]] + ) -> "Node": + """A node interpolation is of the form `${foo.bar}`""" + try: + root_node, inter_key = self._resolve_key_and_root(inter_key) + except ConfigKeyError as exc: + raise InterpolationKeyError( + f"ConfigKeyError while resolving interpolation: {exc}" + ).with_traceback(sys.exc_info()[2]) + + try: + parent, last_key, value = root_node._select_impl( + inter_key, + throw_on_missing=True, + throw_on_resolution_failure=True, + memo=memo, + ) + except MissingMandatoryValue as exc: + raise InterpolationToMissingValueError( + f"MissingMandatoryValue while resolving interpolation: {exc}" + ).with_traceback(sys.exc_info()[2]) + + if parent is None or value is None: + raise InterpolationKeyError(f"Interpolation key '{inter_key}' not found") + else: + self._validate_not_dereferencing_to_parent(node=self, target=value) + return value + + def _evaluate_custom_resolver( + self, + key: Any, + node: Node, + inter_type: str, + inter_args: Tuple[Any, ...], + inter_args_str: Tuple[str, ...], + ) -> Any: + from omegaconf import OmegaConf + + resolver = OmegaConf._get_resolver(inter_type) + if resolver is not None: + root_node = self._get_root() + return resolver( + root_node, + self, + node, + inter_args, + inter_args_str, + ) + else: + raise UnsupportedInterpolationType( + f"Unsupported interpolation type {inter_type}" + ) + + def _maybe_resolve_interpolation( + self, + parent: Optional["Container"], + key: Any, + value: Node, + throw_on_resolution_failure: bool, + memo: Optional[Set[int]] = None, + ) -> Optional[Node]: + value_kind = get_value_kind(value) + if value_kind != ValueKind.INTERPOLATION: + return value + + parse_tree = parse(_get_value(value)) + return self._resolve_interpolation_from_parse_tree( + parent=parent, + value=value, + key=key, + parse_tree=parse_tree, + throw_on_resolution_failure=throw_on_resolution_failure, + memo=memo if memo is not None else set(), + ) + + def resolve_parse_tree( + self, + parse_tree: ParserRuleContext, + node: Node, + memo: Optional[Set[int]] = None, + key: Optional[Any] = None, + ) -> Any: + """ + Resolve a given parse tree into its value. + + We make no assumption here on the type of the tree's root, so that the + return value may be of any type. + """ + + def node_interpolation_callback( + inter_key: str, memo: Optional[Set[int]] + ) -> Optional["Node"]: + return self._resolve_node_interpolation(inter_key=inter_key, memo=memo) + + def resolver_interpolation_callback( + name: str, args: Tuple[Any, ...], args_str: Tuple[str, ...] + ) -> Any: + return self._evaluate_custom_resolver( + key=key, + node=node, + inter_type=name, + inter_args=args, + inter_args_str=args_str, + ) + + visitor = GrammarVisitor( + node_interpolation_callback=node_interpolation_callback, + resolver_interpolation_callback=resolver_interpolation_callback, + memo=memo, + ) + try: + return visitor.visit(parse_tree) + except InterpolationResolutionError: + raise + except Exception as exc: + # Other kinds of exceptions are wrapped in an `InterpolationResolutionError`. + raise InterpolationResolutionError( + f"{type(exc).__name__} raised while resolving interpolation: {exc}" + ).with_traceback(sys.exc_info()[2]) + + def _invalidate_flags_cache(self) -> None: + from .dictconfig import DictConfig + from .listconfig import ListConfig + + # invalidate subtree cache only if the cache is initialized in this node. + + if self.__dict__["_flags_cache"] is not None: + self.__dict__["_flags_cache"] = None + if isinstance(self, DictConfig): + content = self.__dict__["_content"] + if isinstance(content, dict): + for value in self.__dict__["_content"].values(): + value._invalidate_flags_cache() + elif isinstance(self, ListConfig): + content = self.__dict__["_content"] + if isinstance(content, list): + for item in self.__dict__["_content"]: + item._invalidate_flags_cache() + + +class SCMode(Enum): + DICT = 1 # Convert to plain dict + DICT_CONFIG = 2 # Keep as OmegaConf DictConfig + INSTANTIATE = 3 # Create a dataclass or attrs class instance + + +class UnionNode(Box): + """ + This class handles Union type hints. The `_content` attribute is either a + child node that is compatible with the given Union ref_type, or it is a + special value (None or MISSING or interpolation). + + Much of the logic for e.g. value assignment and type validation is + delegated to the child node. As such, UnionNode functions as a + "pass-through" node. User apps and downstream libraries should not need to + know about UnionNode (assuming they only use OmegaConf's public API). + """ + + _parent: Optional[Container] + _content: Union[Node, None, str] + + def __init__( + self, + content: Any, + ref_type: Any, + is_optional: bool = True, + key: Any = None, + parent: Optional[Box] = None, + ) -> None: + try: + if not is_union_annotation(ref_type): # pragma: no cover + msg = ( + f"UnionNode got unexpected ref_type {ref_type}. Please file a bug" + + " report at https://github.com/omry/omegaconf/issues" + ) + raise AssertionError(msg) + if not isinstance(parent, (Container, NoneType)): + raise ConfigTypeError("Parent type is not omegaconf.Container") + super().__init__( + parent=parent, + metadata=Metadata( + ref_type=ref_type, + object_type=None, + optional=is_optional, + key=key, + flags={"convert": False}, + ), + ) + self._set_value(content) + except Exception as ex: + format_and_raise(node=None, key=key, value=content, msg=str(ex), cause=ex) + + def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str: + parent = self._get_parent() + if parent is None: + if self._metadata.key is None: + return "" + else: + return str(self._metadata.key) + else: + return parent._get_full_key(self._metadata.key) + + def __eq__(self, other: Any) -> bool: + content = self.__dict__["_content"] + if isinstance(content, Node): + ret = content.__eq__(other) + elif isinstance(other, Node): + ret = other.__eq__(content) + else: + ret = content.__eq__(other) + assert isinstance(ret, (bool, type(NotImplemented))) + return ret + + def __ne__(self, other: Any) -> bool: + x = self.__eq__(other) + if x is NotImplemented: + return NotImplemented + return not x + + def __hash__(self) -> int: + return hash(self.__dict__["_content"]) + + def _value(self) -> Union[Node, None, str]: + content = self.__dict__["_content"] + assert isinstance(content, (Node, NoneType, str)) + return content + + def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None: + previous_content = self.__dict__["_content"] + previous_metadata = self.__dict__["_metadata"] + try: + self._set_value_impl(value, flags) + except Exception as e: + self.__dict__["_content"] = previous_content + self.__dict__["_metadata"] = previous_metadata + raise e + + def _set_value_impl( + self, value: Any, flags: Optional[Dict[str, bool]] = None + ) -> None: + from omegaconf.omegaconf import _node_wrap + + ref_type = self._metadata.ref_type + type_hint = self._metadata.type_hint + + value = _get_value(value) + if _is_special(value): + assert isinstance(value, (str, NoneType)) + if value is None: + if not self._is_optional(): + raise ValidationError( + f"Value '$VALUE' is incompatible with type hint '{type_str(type_hint)}'" + ) + self.__dict__["_content"] = value + elif isinstance(value, Container): + raise ValidationError( + f"Cannot assign container '$VALUE' of type '$VALUE_TYPE' to {type_str(type_hint)}" + ) + else: + for candidate_ref_type in ref_type.__args__: + try: + self.__dict__["_content"] = _node_wrap( + value=value, + ref_type=candidate_ref_type, + is_optional=False, + key=None, + parent=self, + ) + break + except ValidationError: + continue + else: + raise ValidationError( + f"Value '$VALUE' of type '$VALUE_TYPE' is incompatible with type hint '{type_str(type_hint)}'" + ) + + def _is_optional(self) -> bool: + return self.__dict__["_metadata"].optional is True + + def _is_interpolation(self) -> bool: + return _is_interpolation(self.__dict__["_content"]) + + def __str__(self) -> str: + return str(self.__dict__["_content"]) + + def __repr__(self) -> str: + return repr(self.__dict__["_content"]) + + def __deepcopy__(self, memo: Dict[int, Any]) -> "UnionNode": + res = object.__new__(type(self)) + for key, value in self.__dict__.items(): + if key not in ("_content", "_parent"): + res.__dict__[key] = copy.deepcopy(value, memo=memo) + + src_content = self.__dict__["_content"] + if isinstance(src_content, Node): + old_parent = src_content.__dict__["_parent"] + try: + src_content.__dict__["_parent"] = None + content_copy = copy.deepcopy(src_content, memo=memo) + content_copy.__dict__["_parent"] = res + finally: + src_content.__dict__["_parent"] = old_parent + else: + # None and strings can be assigned as is + content_copy = src_content + + res.__dict__["_content"] = content_copy + res.__dict__["_parent"] = self.__dict__["_parent"] + return res diff --git a/runtime/Lib/site-packages/omegaconf/basecontainer.py b/runtime/Lib/site-packages/omegaconf/basecontainer.py new file mode 100644 index 0000000000000000000000000000000000000000..575df3c72105f9563d29bca8077d7e3fb79742b2 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/basecontainer.py @@ -0,0 +1,916 @@ +import copy +import sys +from abc import ABC, abstractmethod +from enum import Enum +from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Tuple, Union + +import yaml + +from ._utils import ( + _DEFAULT_MARKER_, + ValueKind, + _ensure_container, + _get_value, + _is_interpolation, + _is_missing_value, + _is_none, + _is_special, + _resolve_optional, + get_structured_config_data, + get_type_hint, + get_value_kind, + get_yaml_loader, + is_container_annotation, + is_dict_annotation, + is_list_annotation, + is_primitive_dict, + is_primitive_type_annotation, + is_structured_config, + is_tuple_annotation, + is_union_annotation, +) +from .base import ( + Box, + Container, + ContainerMetadata, + DictKeyType, + Node, + SCMode, + UnionNode, +) +from .errors import ( + ConfigCycleDetectedException, + ConfigTypeError, + InterpolationResolutionError, + KeyValidationError, + MissingMandatoryValue, + OmegaConfBaseException, + ReadonlyConfigError, + ValidationError, +) + +if TYPE_CHECKING: + from .dictconfig import DictConfig # pragma: no cover + + +class BaseContainer(Container, ABC): + _resolvers: ClassVar[Dict[str, Any]] = {} + + def __init__(self, parent: Optional[Box], metadata: ContainerMetadata): + if not (parent is None or isinstance(parent, Box)): + raise ConfigTypeError("Parent type is not omegaconf.Box") + super().__init__(parent=parent, metadata=metadata) + + def _get_child( + self, + key: Any, + validate_access: bool = True, + validate_key: bool = True, + throw_on_missing_value: bool = False, + throw_on_missing_key: bool = False, + ) -> Union[Optional[Node], List[Optional[Node]]]: + """Like _get_node, passing through to the nearest concrete Node.""" + child = self._get_node( + key=key, + validate_access=validate_access, + validate_key=validate_key, + throw_on_missing_value=throw_on_missing_value, + throw_on_missing_key=throw_on_missing_key, + ) + if isinstance(child, UnionNode) and not _is_special(child): + value = child._value() + assert isinstance(value, Node) and not isinstance(value, UnionNode) + child = value + return child + + def _resolve_with_default( + self, + key: Union[DictKeyType, int], + value: Node, + default_value: Any = _DEFAULT_MARKER_, + ) -> Any: + """returns the value with the specified key, like obj.key and obj['key']""" + if _is_missing_value(value): + if default_value is not _DEFAULT_MARKER_: + return default_value + raise MissingMandatoryValue("Missing mandatory value: $FULL_KEY") + + resolved_node = self._maybe_resolve_interpolation( + parent=self, + key=key, + value=value, + throw_on_resolution_failure=True, + ) + + return _get_value(resolved_node) + + def __str__(self) -> str: + return self.__repr__() + + def __repr__(self) -> str: + if self.__dict__["_content"] is None: + return "None" + elif self._is_interpolation() or self._is_missing(): + v = self.__dict__["_content"] + return f"'{v}'" + else: + return self.__dict__["_content"].__repr__() # type: ignore + + # Support pickle + def __getstate__(self) -> Dict[str, Any]: + dict_copy = copy.copy(self.__dict__) + + # no need to serialize the flags cache, it can be re-constructed later + dict_copy.pop("_flags_cache", None) + + dict_copy["_metadata"] = copy.copy(dict_copy["_metadata"]) + ref_type = self._metadata.ref_type + if is_container_annotation(ref_type): + if is_dict_annotation(ref_type): + dict_copy["_metadata"].ref_type = Dict + elif is_list_annotation(ref_type): + dict_copy["_metadata"].ref_type = List + else: + assert False + if sys.version_info < (3, 7): # pragma: no cover + element_type = self._metadata.element_type + if is_union_annotation(element_type): + raise OmegaConfBaseException( + "Serializing structured configs with `Union` element type requires python >= 3.7" + ) + return dict_copy + + # Support pickle + def __setstate__(self, d: Dict[str, Any]) -> None: + from omegaconf import DictConfig + from omegaconf._utils import is_generic_dict, is_generic_list + + if isinstance(self, DictConfig): + key_type = d["_metadata"].key_type + + # backward compatibility to load OmegaConf 2.0 configs + if key_type is None: + key_type = Any + d["_metadata"].key_type = key_type + + element_type = d["_metadata"].element_type + + # backward compatibility to load OmegaConf 2.0 configs + if element_type is None: + element_type = Any + d["_metadata"].element_type = element_type + + ref_type = d["_metadata"].ref_type + if is_container_annotation(ref_type): + if is_generic_dict(ref_type): + d["_metadata"].ref_type = Dict[key_type, element_type] # type: ignore + elif is_generic_list(ref_type): + d["_metadata"].ref_type = List[element_type] # type: ignore + else: + assert False + + d["_flags_cache"] = None + self.__dict__.update(d) + + @abstractmethod + def __delitem__(self, key: Any) -> None: + ... + + def __len__(self) -> int: + if self._is_none() or self._is_missing() or self._is_interpolation(): + return 0 + content = self.__dict__["_content"] + return len(content) + + def merge_with_cli(self) -> None: + args_list = sys.argv[1:] + self.merge_with_dotlist(args_list) + + def merge_with_dotlist(self, dotlist: List[str]) -> None: + from omegaconf import OmegaConf + + def fail() -> None: + raise ValueError("Input list must be a list or a tuple of strings") + + if not isinstance(dotlist, (list, tuple)): + fail() + + for arg in dotlist: + if not isinstance(arg, str): + fail() + + idx = arg.find("=") + if idx == -1: + key = arg + value = None + else: + key = arg[0:idx] + value = arg[idx + 1 :] + value = yaml.load(value, Loader=get_yaml_loader()) + + OmegaConf.update(self, key, value) + + def is_empty(self) -> bool: + """return true if config is empty""" + return len(self.__dict__["_content"]) == 0 + + @staticmethod + def _to_content( + conf: Container, + resolve: bool, + throw_on_missing: bool, + enum_to_str: bool = False, + structured_config_mode: SCMode = SCMode.DICT, + ) -> Union[None, Any, str, Dict[DictKeyType, Any], List[Any]]: + from omegaconf import MISSING, DictConfig, ListConfig + + def convert(val: Node) -> Any: + value = val._value() + if enum_to_str and isinstance(value, Enum): + value = f"{value.name}" + + return value + + def get_node_value(key: Union[DictKeyType, int]) -> Any: + try: + node = conf._get_child(key, throw_on_missing_value=throw_on_missing) + except MissingMandatoryValue as e: + conf._format_and_raise(key=key, value=None, cause=e) + assert isinstance(node, Node) + if resolve: + try: + node = node._dereference_node() + except InterpolationResolutionError as e: + conf._format_and_raise(key=key, value=None, cause=e) + + if isinstance(node, Container): + value = BaseContainer._to_content( + node, + resolve=resolve, + throw_on_missing=throw_on_missing, + enum_to_str=enum_to_str, + structured_config_mode=structured_config_mode, + ) + else: + value = convert(node) + return value + + if conf._is_none(): + return None + elif conf._is_missing(): + if throw_on_missing: + conf._format_and_raise( + key=None, + value=None, + cause=MissingMandatoryValue("Missing mandatory value"), + ) + else: + return MISSING + elif not resolve and conf._is_interpolation(): + inter = conf._value() + assert isinstance(inter, str) + return inter + + if resolve: + _conf = conf._dereference_node() + assert isinstance(_conf, Container) + conf = _conf + + if isinstance(conf, DictConfig): + if ( + conf._metadata.object_type not in (dict, None) + and structured_config_mode == SCMode.DICT_CONFIG + ): + return conf + if structured_config_mode == SCMode.INSTANTIATE and is_structured_config( + conf._metadata.object_type + ): + return conf._to_object() + + retdict: Dict[DictKeyType, Any] = {} + for key in conf.keys(): + value = get_node_value(key) + if enum_to_str and isinstance(key, Enum): + key = f"{key.name}" + retdict[key] = value + return retdict + elif isinstance(conf, ListConfig): + retlist: List[Any] = [] + for index in range(len(conf)): + item = get_node_value(index) + retlist.append(item) + + return retlist + assert False + + @staticmethod + def _map_merge(dest: "BaseContainer", src: "BaseContainer") -> None: + """merge src into dest and return a new copy, does not modified input""" + from omegaconf import AnyNode, DictConfig, ValueNode + + assert isinstance(dest, DictConfig) + assert isinstance(src, DictConfig) + src_type = src._metadata.object_type + src_ref_type = get_type_hint(src) + assert src_ref_type is not None + + # If source DictConfig is: + # - None => set the destination DictConfig to None + # - an interpolation => set the destination DictConfig to be the same interpolation + if src._is_none() or src._is_interpolation(): + dest._set_value(src._value()) + _update_types(node=dest, ref_type=src_ref_type, object_type=src_type) + return + + dest._validate_merge(value=src) + + def expand(node: Container) -> None: + rt = node._metadata.ref_type + val: Any + if rt is not Any: + if is_dict_annotation(rt): + val = {} + elif is_list_annotation(rt) or is_tuple_annotation(rt): + val = [] + else: + val = rt + elif isinstance(node, DictConfig): + val = {} + else: + assert False + + node._set_value(val) + + if ( + src._is_missing() + and not dest._is_missing() + and is_structured_config(src_ref_type) + ): + # Replace `src` with a prototype of its corresponding structured config + # whose fields are all missing (to avoid overwriting fields in `dest`). + assert src_type is None # src missing, so src's object_type should be None + src_type = src_ref_type + src = _create_structured_with_missing_fields( + ref_type=src_ref_type, object_type=src_type + ) + + if (dest._is_interpolation() or dest._is_missing()) and not src._is_missing(): + expand(dest) + + src_items = list(src) if not src._is_missing() else [] + for key in src_items: + src_node = src._get_node(key, validate_access=False) + dest_node = dest._get_node(key, validate_access=False) + assert isinstance(src_node, Node) + assert dest_node is None or isinstance(dest_node, Node) + src_value = _get_value(src_node) + + src_vk = get_value_kind(src_node) + src_node_missing = src_vk is ValueKind.MANDATORY_MISSING + + if isinstance(dest_node, DictConfig): + dest_node._validate_merge(value=src_node) + + if ( + isinstance(dest_node, Container) + and dest_node._is_none() + and not src_node_missing + and not _is_none(src_node, resolve=True) + ): + expand(dest_node) + + if dest_node is not None and dest_node._is_interpolation(): + target_node = dest_node._maybe_dereference_node() + if isinstance(target_node, Container): + dest[key] = target_node + dest_node = dest._get_node(key) + + is_optional, et = _resolve_optional(dest._metadata.element_type) + if dest_node is None and is_structured_config(et) and not src_node_missing: + # merging into a new node. Use element_type as a base + dest[key] = DictConfig( + et, parent=dest, ref_type=et, is_optional=is_optional + ) + dest_node = dest._get_node(key) + + if dest_node is not None: + if isinstance(dest_node, BaseContainer): + if isinstance(src_node, BaseContainer): + dest_node._merge_with(src_node) + elif not src_node_missing: + dest.__setitem__(key, src_node) + else: + if isinstance(src_node, BaseContainer): + dest.__setitem__(key, src_node) + else: + assert isinstance(dest_node, (ValueNode, UnionNode)) + assert isinstance(src_node, (ValueNode, UnionNode)) + try: + if isinstance(dest_node, AnyNode): + if src_node_missing: + node = copy.copy(src_node) + # if src node is missing, use the value from the dest_node, + # but validate it against the type of the src node before assigment + node._set_value(dest_node._value()) + else: + node = src_node + dest.__setitem__(key, node) + else: + if not src_node_missing: + dest_node._set_value(src_value) + + except (ValidationError, ReadonlyConfigError) as e: + dest._format_and_raise(key=key, value=src_value, cause=e) + else: + from omegaconf import open_dict + + if is_structured_config(src_type): + # verified to be compatible above in _validate_merge + with open_dict(dest): + dest[key] = src._get_node(key) + else: + dest[key] = src._get_node(key) + + _update_types(node=dest, ref_type=src_ref_type, object_type=src_type) + + # explicit flags on the source config are replacing the flag values in the destination + flags = src._metadata.flags + assert flags is not None + for flag, value in flags.items(): + if value is not None: + dest._set_flag(flag, value) + + @staticmethod + def _list_merge(dest: Any, src: Any) -> None: + from omegaconf import DictConfig, ListConfig, OmegaConf + + assert isinstance(dest, ListConfig) + assert isinstance(src, ListConfig) + + if src._is_none(): + dest._set_value(None) + elif src._is_missing(): + # do not change dest if src is MISSING. + if dest._metadata.element_type is Any: + dest._metadata.element_type = src._metadata.element_type + elif src._is_interpolation(): + dest._set_value(src._value()) + else: + temp_target = ListConfig(content=[], parent=dest._get_parent()) + temp_target.__dict__["_metadata"] = copy.deepcopy( + dest.__dict__["_metadata"] + ) + is_optional, et = _resolve_optional(dest._metadata.element_type) + if is_structured_config(et): + prototype = DictConfig(et, ref_type=et, is_optional=is_optional) + for item in src._iter_ex(resolve=False): + if isinstance(item, DictConfig): + item = OmegaConf.merge(prototype, item) + temp_target.append(item) + else: + for item in src._iter_ex(resolve=False): + temp_target.append(item) + + dest.__dict__["_content"] = temp_target.__dict__["_content"] + + # explicit flags on the source config are replacing the flag values in the destination + flags = src._metadata.flags + assert flags is not None + for flag, value in flags.items(): + if value is not None: + dest._set_flag(flag, value) + + def merge_with( + self, + *others: Union[ + "BaseContainer", Dict[str, Any], List[Any], Tuple[Any, ...], Any + ], + ) -> None: + try: + self._merge_with(*others) + except Exception as e: + self._format_and_raise(key=None, value=None, cause=e) + + def _merge_with( + self, + *others: Union[ + "BaseContainer", Dict[str, Any], List[Any], Tuple[Any, ...], Any + ], + ) -> None: + from .dictconfig import DictConfig + from .listconfig import ListConfig + + """merge a list of other Config objects into this one, overriding as needed""" + for other in others: + if other is None: + raise ValueError("Cannot merge with a None config") + + my_flags = {} + if self._get_flag("allow_objects") is True: + my_flags = {"allow_objects": True} + other = _ensure_container(other, flags=my_flags) + + if isinstance(self, DictConfig) and isinstance(other, DictConfig): + BaseContainer._map_merge(self, other) + elif isinstance(self, ListConfig) and isinstance(other, ListConfig): + BaseContainer._list_merge(self, other) + else: + raise TypeError("Cannot merge DictConfig with ListConfig") + + # recursively correct the parent hierarchy after the merge + self._re_parent() + + # noinspection PyProtectedMember + def _set_item_impl(self, key: Any, value: Any) -> None: + """ + Changes the value of the node key with the desired value. If the node key doesn't + exist it creates a new one. + """ + from .nodes import AnyNode, ValueNode + + if isinstance(value, Node): + do_deepcopy = not self._get_flag("no_deepcopy_set_nodes") + if not do_deepcopy and isinstance(value, Box): + # if value is from the same config, perform a deepcopy no matter what. + if self._get_root() is value._get_root(): + do_deepcopy = True + + if do_deepcopy: + value = copy.deepcopy(value) + value._set_parent(None) + + try: + old = value._key() + value._set_key(key) + self._validate_set(key, value) + finally: + value._set_key(old) + else: + self._validate_set(key, value) + + if self._get_flag("readonly"): + raise ReadonlyConfigError("Cannot change read-only config container") + + input_is_node = isinstance(value, Node) + target_node_ref = self._get_node(key) + assert target_node_ref is None or isinstance(target_node_ref, Node) + + input_is_typed_vnode = isinstance(value, ValueNode) and not isinstance( + value, AnyNode + ) + + def get_target_type_hint(val: Any) -> Any: + if not is_structured_config(val): + type_hint = self._metadata.element_type + else: + target = self._get_node(key) + if target is None: + type_hint = self._metadata.element_type + else: + assert isinstance(target, Node) + type_hint = target._metadata.type_hint + return type_hint + + target_type_hint = get_target_type_hint(value) + _, target_ref_type = _resolve_optional(target_type_hint) + + def assign(value_key: Any, val: Node) -> None: + assert val._get_parent() is None + v = val + v._set_parent(self) + v._set_key(value_key) + _deep_update_type_hint(node=v, type_hint=self._metadata.element_type) + self.__dict__["_content"][value_key] = v + + if input_is_typed_vnode and not is_union_annotation(target_ref_type): + assign(key, value) + else: + # input is not a ValueNode, can be primitive or box + + special_value = _is_special(value) + # We use the `Node._set_value` method if the target node exists and: + # 1. the target has an explicit ref_type, or + # 2. the target is an AnyNode and the input is a primitive type. + should_set_value = target_node_ref is not None and ( + target_node_ref._has_ref_type() + or ( + isinstance(target_node_ref, AnyNode) + and is_primitive_type_annotation(value) + ) + ) + if should_set_value: + if special_value and isinstance(value, Node): + value = value._value() + self.__dict__["_content"][key]._set_value(value) + elif input_is_node: + if ( + special_value + and ( + is_container_annotation(target_ref_type) + or is_structured_config(target_ref_type) + ) + or is_primitive_type_annotation(target_ref_type) + or is_union_annotation(target_ref_type) + ): + value = _get_value(value) + self._wrap_value_and_set(key, value, target_type_hint) + else: + assign(key, value) + else: + self._wrap_value_and_set(key, value, target_type_hint) + + def _wrap_value_and_set(self, key: Any, val: Any, type_hint: Any) -> None: + from omegaconf.omegaconf import _maybe_wrap + + is_optional, ref_type = _resolve_optional(type_hint) + + try: + wrapped = _maybe_wrap( + ref_type=ref_type, + key=key, + value=val, + is_optional=is_optional, + parent=self, + ) + except ValidationError as e: + self._format_and_raise(key=key, value=val, cause=e) + self.__dict__["_content"][key] = wrapped + + @staticmethod + def _item_eq( + c1: Container, + k1: Union[DictKeyType, int], + c2: Container, + k2: Union[DictKeyType, int], + ) -> bool: + v1 = c1._get_child(k1) + v2 = c2._get_child(k2) + assert v1 is not None and v2 is not None + + assert isinstance(v1, Node) + assert isinstance(v2, Node) + + if v1._is_none() and v2._is_none(): + return True + + if v1._is_missing() and v2._is_missing(): + return True + + v1_inter = v1._is_interpolation() + v2_inter = v2._is_interpolation() + dv1: Optional[Node] = v1 + dv2: Optional[Node] = v2 + + if v1_inter: + dv1 = v1._maybe_dereference_node() + if v2_inter: + dv2 = v2._maybe_dereference_node() + + if v1_inter and v2_inter: + if dv1 is None or dv2 is None: + return v1 == v2 + else: + # both are not none, if both are containers compare as container + if isinstance(dv1, Container) and isinstance(dv2, Container): + if dv1 != dv2: + return False + dv1 = _get_value(dv1) + dv2 = _get_value(dv2) + return dv1 == dv2 + elif not v1_inter and not v2_inter: + v1 = _get_value(v1) + v2 = _get_value(v2) + ret = v1 == v2 + assert isinstance(ret, bool) + return ret + else: + dv1 = _get_value(dv1) + dv2 = _get_value(dv2) + ret = dv1 == dv2 + assert isinstance(ret, bool) + return ret + + def _is_optional(self) -> bool: + return self.__dict__["_metadata"].optional is True + + def _is_interpolation(self) -> bool: + return _is_interpolation(self.__dict__["_content"]) + + @abstractmethod + def _validate_get(self, key: Any, value: Any = None) -> None: + ... + + @abstractmethod + def _validate_set(self, key: Any, value: Any) -> None: + ... + + def _value(self) -> Any: + return self.__dict__["_content"] + + def _get_full_key(self, key: Union[DictKeyType, int, slice, None]) -> str: + from .listconfig import ListConfig + from .omegaconf import _select_one + + if not isinstance(key, (int, str, Enum, float, bool, slice, bytes, type(None))): + return "" + + def _slice_to_str(x: slice) -> str: + if x.step is not None: + return f"{x.start}:{x.stop}:{x.step}" + else: + return f"{x.start}:{x.stop}" + + def prepand( + full_key: str, + parent_type: Any, + cur_type: Any, + key: Optional[Union[DictKeyType, int, slice]], + ) -> str: + if key is None: + return full_key + + if isinstance(key, slice): + key = _slice_to_str(key) + elif isinstance(key, Enum): + key = key.name + else: + key = str(key) + + assert isinstance(key, str) + + if issubclass(parent_type, ListConfig): + if full_key != "": + if issubclass(cur_type, ListConfig): + full_key = f"[{key}]{full_key}" + else: + full_key = f"[{key}].{full_key}" + else: + full_key = f"[{key}]" + else: + if full_key == "": + full_key = key + else: + if issubclass(cur_type, ListConfig): + full_key = f"{key}{full_key}" + else: + full_key = f"{key}.{full_key}" + return full_key + + if key is not None and key != "": + assert isinstance(self, Container) + cur, _ = _select_one( + c=self, key=str(key), throw_on_missing=False, throw_on_type_error=False + ) + if cur is None: + cur = self + full_key = prepand("", type(cur), None, key) + if cur._key() is not None: + full_key = prepand( + full_key, type(cur._get_parent()), type(cur), cur._key() + ) + else: + full_key = prepand("", type(cur._get_parent()), type(cur), cur._key()) + else: + cur = self + if cur._key() is None: + return "" + full_key = self._key() + + assert cur is not None + memo = {id(cur)} # remember already visited nodes so as to detect cycles + while cur._get_parent() is not None: + cur = cur._get_parent() + if id(cur) in memo: + raise ConfigCycleDetectedException( + f"Cycle when iterating over parents of key `{key!s}`" + ) + memo.add(id(cur)) + assert cur is not None + if cur._key() is not None: + full_key = prepand( + full_key, type(cur._get_parent()), type(cur), cur._key() + ) + + return full_key + + +def _create_structured_with_missing_fields( + ref_type: type, object_type: Optional[type] = None +) -> "DictConfig": + from . import MISSING, DictConfig + + cfg_data = get_structured_config_data(ref_type) + for v in cfg_data.values(): + v._set_value(MISSING) + + cfg = DictConfig(cfg_data) + cfg._metadata.optional, cfg._metadata.ref_type = _resolve_optional(ref_type) + cfg._metadata.object_type = object_type + + return cfg + + +def _update_types(node: Node, ref_type: Any, object_type: Optional[type]) -> None: + if object_type is not None and not is_primitive_dict(object_type): + node._metadata.object_type = object_type + + if node._metadata.ref_type is Any: + _deep_update_type_hint(node, ref_type) + + +def _deep_update_type_hint(node: Node, type_hint: Any) -> None: + """Ensure node is compatible with type_hint, mutating if necessary.""" + from omegaconf import DictConfig, ListConfig + + from ._utils import get_dict_key_value_types, get_list_element_type + + if type_hint is Any: + return + + _shallow_validate_type_hint(node, type_hint) + + new_is_optional, new_ref_type = _resolve_optional(type_hint) + node._metadata.ref_type = new_ref_type + node._metadata.optional = new_is_optional + + if is_list_annotation(new_ref_type) and isinstance(node, ListConfig): + new_element_type = get_list_element_type(new_ref_type) + node._metadata.element_type = new_element_type + if not _is_special(node): + for i in range(len(node)): + _deep_update_subnode(node, i, new_element_type) + + if is_dict_annotation(new_ref_type) and isinstance(node, DictConfig): + new_key_type, new_element_type = get_dict_key_value_types(new_ref_type) + node._metadata.key_type = new_key_type + node._metadata.element_type = new_element_type + if not _is_special(node): + for key in node: + if new_key_type is not Any and not isinstance(key, new_key_type): + raise KeyValidationError( + f"Key {key!r} ({type(key).__name__}) is incompatible" + + f" with key type hint '{new_key_type.__name__}'" + ) + _deep_update_subnode(node, key, new_element_type) + + +def _deep_update_subnode(node: BaseContainer, key: Any, value_type_hint: Any) -> None: + """Get node[key] and ensure it is compatible with value_type_hint, mutating if necessary.""" + subnode = node._get_node(key) + assert isinstance(subnode, Node) + if _is_special(subnode): + # Ensure special values are wrapped in a Node subclass that + # is compatible with the type hint. + node._wrap_value_and_set(key, subnode._value(), value_type_hint) + subnode = node._get_node(key) + assert isinstance(subnode, Node) + _deep_update_type_hint(subnode, value_type_hint) + + +def _shallow_validate_type_hint(node: Node, type_hint: Any) -> None: + """Error if node's type, content and metadata are not compatible with type_hint.""" + from omegaconf import DictConfig, ListConfig, ValueNode + + is_optional, ref_type = _resolve_optional(type_hint) + + vk = get_value_kind(node) + + if node._is_none(): + if not is_optional: + value = _get_value(node) + raise ValidationError( + f"Value {value!r} ({type(value).__name__})" + + f" is incompatible with type hint '{ref_type.__name__}'" + ) + return + elif vk in (ValueKind.MANDATORY_MISSING, ValueKind.INTERPOLATION): + return + elif vk == ValueKind.VALUE: + if is_primitive_type_annotation(ref_type) and isinstance(node, ValueNode): + value = node._value() + if not isinstance(value, ref_type): + raise ValidationError( + f"Value {value!r} ({type(value).__name__})" + + f" is incompatible with type hint '{ref_type.__name__}'" + ) + elif is_structured_config(ref_type) and isinstance(node, DictConfig): + return + elif is_dict_annotation(ref_type) and isinstance(node, DictConfig): + return + elif is_list_annotation(ref_type) and isinstance(node, ListConfig): + return + else: + if isinstance(node, ValueNode): + value = node._value() + raise ValidationError( + f"Value {value!r} ({type(value).__name__})" + + f" is incompatible with type hint '{ref_type}'" + ) + else: + raise ValidationError( + f"'{type(node).__name__}' is incompatible" + + f" with type hint '{ref_type}'" + ) + + else: + assert False diff --git a/runtime/Lib/site-packages/omegaconf/dictconfig.py b/runtime/Lib/site-packages/omegaconf/dictconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..da7c8957f1c2e30b4c1889997c85c2a33cf72f01 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/dictconfig.py @@ -0,0 +1,776 @@ +import copy +from enum import Enum +from typing import ( + Any, + Dict, + ItemsView, + Iterable, + Iterator, + KeysView, + List, + MutableMapping, + Optional, + Sequence, + Tuple, + Type, + Union, +) + +from ._utils import ( + _DEFAULT_MARKER_, + ValueKind, + _get_value, + _is_interpolation, + _is_missing_literal, + _is_missing_value, + _is_none, + _resolve_optional, + _valid_dict_key_annotation_type, + format_and_raise, + get_structured_config_data, + get_structured_config_init_field_names, + get_type_of, + get_value_kind, + is_container_annotation, + is_dict, + is_primitive_dict, + is_structured_config, + is_structured_config_frozen, + type_str, +) +from .base import Box, Container, ContainerMetadata, DictKeyType, Node +from .basecontainer import BaseContainer +from .errors import ( + ConfigAttributeError, + ConfigKeyError, + ConfigTypeError, + InterpolationResolutionError, + KeyValidationError, + MissingMandatoryValue, + OmegaConfBaseException, + ReadonlyConfigError, + ValidationError, +) +from .nodes import EnumNode, ValueNode + + +class DictConfig(BaseContainer, MutableMapping[Any, Any]): + + _metadata: ContainerMetadata + _content: Union[Dict[DictKeyType, Node], None, str] + + def __init__( + self, + content: Union[Dict[DictKeyType, Any], "DictConfig", Any], + key: Any = None, + parent: Optional[Box] = None, + ref_type: Union[Any, Type[Any]] = Any, + key_type: Union[Any, Type[Any]] = Any, + element_type: Union[Any, Type[Any]] = Any, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ) -> None: + try: + if isinstance(content, DictConfig): + if flags is None: + flags = content._metadata.flags + super().__init__( + parent=parent, + metadata=ContainerMetadata( + key=key, + optional=is_optional, + ref_type=ref_type, + object_type=dict, + key_type=key_type, + element_type=element_type, + flags=flags, + ), + ) + + if not _valid_dict_key_annotation_type(key_type): + raise KeyValidationError(f"Unsupported key type {key_type}") + + if is_structured_config(content) or is_structured_config(ref_type): + self._set_value(content, flags=flags) + if is_structured_config_frozen(content) or is_structured_config_frozen( + ref_type + ): + self._set_flag("readonly", True) + + else: + if isinstance(content, DictConfig): + metadata = copy.deepcopy(content._metadata) + metadata.key = key + metadata.ref_type = ref_type + metadata.optional = is_optional + metadata.element_type = element_type + metadata.key_type = key_type + self.__dict__["_metadata"] = metadata + self._set_value(content, flags=flags) + except Exception as ex: + format_and_raise(node=None, key=key, value=None, cause=ex, msg=str(ex)) + + def __deepcopy__(self, memo: Dict[int, Any]) -> "DictConfig": + res = DictConfig(None) + res.__dict__["_metadata"] = copy.deepcopy(self.__dict__["_metadata"], memo=memo) + res.__dict__["_flags_cache"] = copy.deepcopy( + self.__dict__["_flags_cache"], memo=memo + ) + + src_content = self.__dict__["_content"] + if isinstance(src_content, dict): + content_copy = {} + for k, v in src_content.items(): + old_parent = v.__dict__["_parent"] + try: + v.__dict__["_parent"] = None + vc = copy.deepcopy(v, memo=memo) + vc.__dict__["_parent"] = res + content_copy[k] = vc + finally: + v.__dict__["_parent"] = old_parent + else: + # None and strings can be assigned as is + content_copy = src_content + + res.__dict__["_content"] = content_copy + # parent is retained, but not copied + res.__dict__["_parent"] = self.__dict__["_parent"] + return res + + def copy(self) -> "DictConfig": + return copy.copy(self) + + def _is_typed(self) -> bool: + return self._metadata.object_type not in (Any, None) and not is_dict( + self._metadata.object_type + ) + + def _validate_get(self, key: Any, value: Any = None) -> None: + is_typed = self._is_typed() + + is_struct = self._get_flag("struct") is True + if key not in self.__dict__["_content"]: + if is_typed: + # do not raise an exception if struct is explicitly set to False + if self._get_node_flag("struct") is False: + return + if is_typed or is_struct: + if is_typed: + assert self._metadata.object_type not in (dict, None) + msg = f"Key '{key}' not in '{self._metadata.object_type.__name__}'" + else: + msg = f"Key '{key}' is not in struct" + self._format_and_raise( + key=key, value=value, cause=ConfigAttributeError(msg) + ) + + def _validate_set(self, key: Any, value: Any) -> None: + from omegaconf import OmegaConf + + vk = get_value_kind(value) + if vk == ValueKind.INTERPOLATION: + return + if _is_none(value): + self._validate_non_optional(key, value) + return + if vk == ValueKind.MANDATORY_MISSING or value is None: + return + + target = self._get_node(key) if key is not None else self + + target_has_ref_type = isinstance( + target, DictConfig + ) and target._metadata.ref_type not in (Any, dict) + is_valid_target = target is None or not target_has_ref_type + + if is_valid_target: + return + + assert isinstance(target, Node) + + target_type = target._metadata.ref_type + value_type = OmegaConf.get_type(value) + + if is_dict(value_type) and is_dict(target_type): + return + if is_container_annotation(target_type) and not is_container_annotation( + value_type + ): + raise ValidationError( + f"Cannot assign {type_str(value_type)} to {type_str(target_type)}" + ) + + if target_type is not None and value_type is not None: + origin = getattr(target_type, "__origin__", target_type) + if not issubclass(value_type, origin): + self._raise_invalid_value(value, value_type, target_type) + + def _validate_merge(self, value: Any) -> None: + from omegaconf import OmegaConf + + dest = self + src = value + + self._validate_non_optional(None, src) + + dest_obj_type = OmegaConf.get_type(dest) + src_obj_type = OmegaConf.get_type(src) + + if dest._is_missing() and src._metadata.object_type not in (dict, None): + self._validate_set(key=None, value=_get_value(src)) + + if src._is_missing(): + return + + validation_error = ( + dest_obj_type is not None + and src_obj_type is not None + and is_structured_config(dest_obj_type) + and not src._is_none() + and not is_dict(src_obj_type) + and not issubclass(src_obj_type, dest_obj_type) + ) + if validation_error: + msg = ( + f"Merge error: {type_str(src_obj_type)} is not a " + f"subclass of {type_str(dest_obj_type)}. value: {src}" + ) + raise ValidationError(msg) + + def _validate_non_optional(self, key: Optional[DictKeyType], value: Any) -> None: + if _is_none(value, resolve=True, throw_on_resolution_failure=False): + + if key is not None: + child = self._get_node(key) + if child is not None: + assert isinstance(child, Node) + field_is_optional = child._is_optional() + else: + field_is_optional, _ = _resolve_optional( + self._metadata.element_type + ) + else: + field_is_optional = self._is_optional() + + if not field_is_optional: + self._format_and_raise( + key=key, + value=value, + cause=ValidationError("field '$FULL_KEY' is not Optional"), + ) + + def _raise_invalid_value( + self, value: Any, value_type: Any, target_type: Any + ) -> None: + assert value_type is not None + assert target_type is not None + msg = ( + f"Invalid type assigned: {type_str(value_type)} is not a " + f"subclass of {type_str(target_type)}. value: {value}" + ) + raise ValidationError(msg) + + def _validate_and_normalize_key(self, key: Any) -> DictKeyType: + return self._s_validate_and_normalize_key(self._metadata.key_type, key) + + def _s_validate_and_normalize_key(self, key_type: Any, key: Any) -> DictKeyType: + if key_type is Any: + for t in DictKeyType.__args__: # type: ignore + if isinstance(key, t): + return key # type: ignore + raise KeyValidationError("Incompatible key type '$KEY_TYPE'") + elif key_type is bool and key in [0, 1]: + # Python treats True as 1 and False as 0 when used as dict keys + # assert hash(0) == hash(False) + # assert hash(1) == hash(True) + return bool(key) + elif key_type in (str, bytes, int, float, bool): # primitive type + if not isinstance(key, key_type): + raise KeyValidationError( + f"Key $KEY ($KEY_TYPE) is incompatible with ({key_type.__name__})" + ) + + return key # type: ignore + elif issubclass(key_type, Enum): + try: + return EnumNode.validate_and_convert_to_enum(key_type, key) + except ValidationError: + valid = ", ".join([x for x in key_type.__members__.keys()]) + raise KeyValidationError( + f"Key '$KEY' is incompatible with the enum type '{key_type.__name__}', valid: [{valid}]" + ) + else: + assert False, f"Unsupported key type {key_type}" + + def __setitem__(self, key: DictKeyType, value: Any) -> None: + try: + self.__set_impl(key=key, value=value) + except AttributeError as e: + self._format_and_raise( + key=key, value=value, type_override=ConfigKeyError, cause=e + ) + except Exception as e: + self._format_and_raise(key=key, value=value, cause=e) + + def __set_impl(self, key: DictKeyType, value: Any) -> None: + key = self._validate_and_normalize_key(key) + self._set_item_impl(key, value) + + # hide content while inspecting in debugger + def __dir__(self) -> Iterable[str]: + if self._is_missing() or self._is_none(): + return [] + return self.__dict__["_content"].keys() # type: ignore + + def __setattr__(self, key: str, value: Any) -> None: + """ + Allow assigning attributes to DictConfig + :param key: + :param value: + :return: + """ + try: + self.__set_impl(key, value) + except Exception as e: + if isinstance(e, OmegaConfBaseException) and e._initialized: + raise e + self._format_and_raise(key=key, value=value, cause=e) + assert False + + def __getattr__(self, key: str) -> Any: + """ + Allow accessing dictionary values as attributes + :param key: + :return: + """ + if key == "__name__": + raise AttributeError() + + try: + return self._get_impl( + key=key, default_value=_DEFAULT_MARKER_, validate_key=False + ) + except ConfigKeyError as e: + self._format_and_raise( + key=key, value=None, cause=e, type_override=ConfigAttributeError + ) + except Exception as e: + self._format_and_raise(key=key, value=None, cause=e) + + def __getitem__(self, key: DictKeyType) -> Any: + """ + Allow map style access + :param key: + :return: + """ + + try: + return self._get_impl(key=key, default_value=_DEFAULT_MARKER_) + except AttributeError as e: + self._format_and_raise( + key=key, value=None, cause=e, type_override=ConfigKeyError + ) + except Exception as e: + self._format_and_raise(key=key, value=None, cause=e) + + def __delattr__(self, key: str) -> None: + """ + Allow deleting dictionary values as attributes + :param key: + :return: + """ + if self._get_flag("readonly"): + self._format_and_raise( + key=key, + value=None, + cause=ReadonlyConfigError( + "DictConfig in read-only mode does not support deletion" + ), + ) + try: + del self.__dict__["_content"][key] + except KeyError: + msg = "Attribute not found: '$KEY'" + self._format_and_raise(key=key, value=None, cause=ConfigAttributeError(msg)) + + def __delitem__(self, key: DictKeyType) -> None: + key = self._validate_and_normalize_key(key) + if self._get_flag("readonly"): + self._format_and_raise( + key=key, + value=None, + cause=ReadonlyConfigError( + "DictConfig in read-only mode does not support deletion" + ), + ) + if self._get_flag("struct"): + self._format_and_raise( + key=key, + value=None, + cause=ConfigTypeError( + "DictConfig in struct mode does not support deletion" + ), + ) + if self._is_typed() and self._get_node_flag("struct") is not False: + self._format_and_raise( + key=key, + value=None, + cause=ConfigTypeError( + f"{type_str(self._metadata.object_type)} (DictConfig) does not support deletion" + ), + ) + + try: + del self.__dict__["_content"][key] + except KeyError: + msg = "Key not found: '$KEY'" + self._format_and_raise(key=key, value=None, cause=ConfigKeyError(msg)) + + def get(self, key: DictKeyType, default_value: Any = None) -> Any: + """Return the value for `key` if `key` is in the dictionary, else + `default_value` (defaulting to `None`).""" + try: + return self._get_impl(key=key, default_value=default_value) + except KeyValidationError as e: + self._format_and_raise(key=key, value=None, cause=e) + + def _get_impl( + self, key: DictKeyType, default_value: Any, validate_key: bool = True + ) -> Any: + try: + node = self._get_child( + key=key, throw_on_missing_key=True, validate_key=validate_key + ) + except (ConfigAttributeError, ConfigKeyError): + if default_value is not _DEFAULT_MARKER_: + return default_value + else: + raise + assert isinstance(node, Node) + return self._resolve_with_default( + key=key, value=node, default_value=default_value + ) + + def _get_node( + self, + key: DictKeyType, + validate_access: bool = True, + validate_key: bool = True, + throw_on_missing_value: bool = False, + throw_on_missing_key: bool = False, + ) -> Optional[Node]: + try: + key = self._validate_and_normalize_key(key) + except KeyValidationError: + if validate_access and validate_key: + raise + else: + if throw_on_missing_key: + raise ConfigAttributeError + else: + return None + + if validate_access: + self._validate_get(key) + + value: Optional[Node] = self.__dict__["_content"].get(key) + if value is None: + if throw_on_missing_key: + raise ConfigKeyError(f"Missing key {key!s}") + elif throw_on_missing_value and value._is_missing(): + raise MissingMandatoryValue("Missing mandatory value: $KEY") + return value + + def pop(self, key: DictKeyType, default: Any = _DEFAULT_MARKER_) -> Any: + try: + if self._get_flag("readonly"): + raise ReadonlyConfigError("Cannot pop from read-only node") + if self._get_flag("struct"): + raise ConfigTypeError("DictConfig in struct mode does not support pop") + if self._is_typed() and self._get_node_flag("struct") is not False: + raise ConfigTypeError( + f"{type_str(self._metadata.object_type)} (DictConfig) does not support pop" + ) + key = self._validate_and_normalize_key(key) + node = self._get_child(key=key, validate_access=False) + if node is not None: + assert isinstance(node, Node) + value = self._resolve_with_default( + key=key, value=node, default_value=default + ) + + del self[key] + return value + else: + if default is not _DEFAULT_MARKER_: + return default + else: + full = self._get_full_key(key=key) + if full != key: + raise ConfigKeyError( + f"Key not found: '{key!s}' (path: '{full}')" + ) + else: + raise ConfigKeyError(f"Key not found: '{key!s}'") + except Exception as e: + self._format_and_raise(key=key, value=None, cause=e) + + def keys(self) -> KeysView[DictKeyType]: + if self._is_missing() or self._is_interpolation() or self._is_none(): + return {}.keys() + ret = self.__dict__["_content"].keys() + assert isinstance(ret, KeysView) + return ret + + def __contains__(self, key: object) -> bool: + """ + A key is contained in a DictConfig if there is an associated value and + it is not a mandatory missing value ('???'). + :param key: + :return: + """ + + try: + key = self._validate_and_normalize_key(key) + except KeyValidationError: + return False + + try: + node = self._get_child(key) + assert node is None or isinstance(node, Node) + except (KeyError, AttributeError): + node = None + + if node is None: + return False + else: + try: + self._resolve_with_default(key=key, value=node) + return True + except InterpolationResolutionError: + # Interpolations that fail count as existing. + return True + except MissingMandatoryValue: + # Missing values count as *not* existing. + return False + + def __iter__(self) -> Iterator[DictKeyType]: + return iter(self.keys()) + + def items(self) -> ItemsView[DictKeyType, Any]: + return dict(self.items_ex(resolve=True, keys=None)).items() + + def setdefault(self, key: DictKeyType, default: Any = None) -> Any: + if key in self: + ret = self.__getitem__(key) + else: + ret = default + self.__setitem__(key, default) + return ret + + def items_ex( + self, resolve: bool = True, keys: Optional[Sequence[DictKeyType]] = None + ) -> List[Tuple[DictKeyType, Any]]: + items: List[Tuple[DictKeyType, Any]] = [] + + if self._is_none(): + self._format_and_raise( + key=None, + value=None, + cause=TypeError("Cannot iterate a DictConfig object representing None"), + ) + if self._is_missing(): + raise MissingMandatoryValue("Cannot iterate a missing DictConfig") + + for key in self.keys(): + if resolve: + value = self[key] + else: + value = self.__dict__["_content"][key] + if isinstance(value, ValueNode): + value = value._value() + if keys is None or key in keys: + items.append((key, value)) + + return items + + def __eq__(self, other: Any) -> bool: + if other is None: + return self.__dict__["_content"] is None + if is_primitive_dict(other) or is_structured_config(other): + other = DictConfig(other, flags={"allow_objects": True}) + return DictConfig._dict_conf_eq(self, other) + if isinstance(other, DictConfig): + return DictConfig._dict_conf_eq(self, other) + if self._is_missing(): + return _is_missing_literal(other) + return NotImplemented + + def __ne__(self, other: Any) -> bool: + x = self.__eq__(other) + if x is not NotImplemented: + return not x + return NotImplemented + + def __hash__(self) -> int: + return hash(str(self)) + + def _promote(self, type_or_prototype: Optional[Type[Any]]) -> None: + """ + Retypes a node. + This should only be used in rare circumstances, where you want to dynamically change + the runtime structured-type of a DictConfig. + It will change the type and add the additional fields based on the input class or object + """ + if type_or_prototype is None: + return + if not is_structured_config(type_or_prototype): + raise ValueError(f"Expected structured config class: {type_or_prototype}") + + from omegaconf import OmegaConf + + proto: DictConfig = OmegaConf.structured(type_or_prototype) + object_type = proto._metadata.object_type + # remove the type to prevent assignment validation from rejecting the promotion. + proto._metadata.object_type = None + self.merge_with(proto) + # restore the type. + self._metadata.object_type = object_type + + def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None: + try: + previous_content = self.__dict__["_content"] + self._set_value_impl(value, flags) + except Exception as e: + self.__dict__["_content"] = previous_content + raise e + + def _set_value_impl( + self, value: Any, flags: Optional[Dict[str, bool]] = None + ) -> None: + from omegaconf import MISSING, flag_override + + if flags is None: + flags = {} + + assert not isinstance(value, ValueNode) + self._validate_set(key=None, value=value) + + if _is_none(value, resolve=True): + self.__dict__["_content"] = None + self._metadata.object_type = None + elif _is_interpolation(value, strict_interpolation_validation=True): + self.__dict__["_content"] = value + self._metadata.object_type = None + elif _is_missing_value(value): + self.__dict__["_content"] = MISSING + self._metadata.object_type = None + else: + self.__dict__["_content"] = {} + if is_structured_config(value): + self._metadata.object_type = None + ao = self._get_flag("allow_objects") + data = get_structured_config_data(value, allow_objects=ao) + with flag_override(self, ["struct", "readonly"], False): + for k, v in data.items(): + self.__setitem__(k, v) + self._metadata.object_type = get_type_of(value) + + elif isinstance(value, DictConfig): + self._metadata.flags = copy.deepcopy(flags) + with flag_override(self, ["struct", "readonly"], False): + for k, v in value.__dict__["_content"].items(): + self.__setitem__(k, v) + self._metadata.object_type = value._metadata.object_type + + elif isinstance(value, dict): + with flag_override(self, ["struct", "readonly"], False): + for k, v in value.items(): + self.__setitem__(k, v) + self._metadata.object_type = dict + + else: # pragma: no cover + msg = f"Unsupported value type: {value}" + raise ValidationError(msg) + + @staticmethod + def _dict_conf_eq(d1: "DictConfig", d2: "DictConfig") -> bool: + + d1_none = d1.__dict__["_content"] is None + d2_none = d2.__dict__["_content"] is None + if d1_none and d2_none: + return True + if d1_none != d2_none: + return False + + assert isinstance(d1, DictConfig) + assert isinstance(d2, DictConfig) + if len(d1) != len(d2): + return False + if d1._is_missing() or d2._is_missing(): + return d1._is_missing() is d2._is_missing() + + for k, v in d1.items_ex(resolve=False): + if k not in d2.__dict__["_content"]: + return False + if not BaseContainer._item_eq(d1, k, d2, k): + return False + + return True + + def _to_object(self) -> Any: + """ + Instantiate an instance of `self._metadata.object_type`. + This requires `self` to be a structured config. + Nested subconfigs are converted by calling `OmegaConf.to_object`. + """ + from omegaconf import OmegaConf + + object_type = self._metadata.object_type + assert is_structured_config(object_type) + init_field_names = set(get_structured_config_init_field_names(object_type)) + + init_field_items: Dict[str, Any] = {} + non_init_field_items: Dict[str, Any] = {} + for k in self.keys(): + assert isinstance(k, str) + node = self._get_child(k) + assert isinstance(node, Node) + try: + node = node._dereference_node() + except InterpolationResolutionError as e: + self._format_and_raise(key=k, value=None, cause=e) + if node._is_missing(): + if k not in init_field_names: + continue # MISSING is ignored for init=False fields + self._format_and_raise( + key=k, + value=None, + cause=MissingMandatoryValue( + "Structured config of type `$OBJECT_TYPE` has missing mandatory value: $KEY" + ), + ) + if isinstance(node, Container): + v = OmegaConf.to_object(node) + else: + v = node._value() + + if k in init_field_names: + init_field_items[k] = v + else: + non_init_field_items[k] = v + + try: + result = object_type(**init_field_items) + except TypeError as exc: + self._format_and_raise( + key=None, + value=None, + cause=exc, + msg="Could not create instance of `$OBJECT_TYPE`: " + str(exc), + ) + + for k, v in non_init_field_items.items(): + setattr(result, k, v) + return result diff --git a/runtime/Lib/site-packages/omegaconf/errors.py b/runtime/Lib/site-packages/omegaconf/errors.py new file mode 100644 index 0000000000000000000000000000000000000000..60525ef3c62fb89093c0b5aa1147ae6f80b61062 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/errors.py @@ -0,0 +1,141 @@ +from typing import Any, Optional, Type + + +class OmegaConfBaseException(Exception): + # would ideally be typed Optional[Node] + parent_node: Any + child_node: Any + key: Any + full_key: Optional[str] + value: Any + msg: Optional[str] + cause: Optional[Exception] + object_type: Optional[Type[Any]] + object_type_str: Optional[str] + ref_type: Optional[Type[Any]] + ref_type_str: Optional[str] + + _initialized: bool = False + + def __init__(self, *_args: Any, **_kwargs: Any) -> None: + self.parent_node = None + self.child_node = None + self.key = None + self.full_key = None + self.value = None + self.msg = None + self.object_type = None + self.ref_type = None + + +class MissingMandatoryValue(OmegaConfBaseException): + """Thrown when a variable flagged with '???' value is accessed to + indicate that the value was not set""" + + +class KeyValidationError(OmegaConfBaseException, ValueError): + """ + Thrown when an a key of invalid type is used + """ + + +class ValidationError(OmegaConfBaseException, ValueError): + """ + Thrown when a value fails validation + """ + + +class UnsupportedValueType(ValidationError, ValueError): + """ + Thrown when an input value is not of supported type + """ + + +class ReadonlyConfigError(OmegaConfBaseException): + """ + Thrown when someone tries to modify a frozen config + """ + + +class InterpolationResolutionError(OmegaConfBaseException, ValueError): + """ + Base class for exceptions raised when resolving an interpolation. + """ + + +class UnsupportedInterpolationType(InterpolationResolutionError): + """ + Thrown when an attempt to use an unregistered interpolation is made + """ + + +class InterpolationKeyError(InterpolationResolutionError): + """ + Thrown when a node does not exist when resolving an interpolation. + """ + + +class InterpolationToMissingValueError(InterpolationResolutionError): + """ + Thrown when a node interpolation points to a node that is set to ???. + """ + + +class InterpolationValidationError(InterpolationResolutionError, ValidationError): + """ + Thrown when the result of an interpolation fails the validation step. + """ + + +class ConfigKeyError(OmegaConfBaseException, KeyError): + """ + Thrown from DictConfig when a regular dict access would have caused a KeyError. + """ + + msg: str + + def __init__(self, msg: str) -> None: + super().__init__(msg) + self.msg = msg + + def __str__(self) -> str: + """ + Workaround to nasty KeyError quirk: https://bugs.python.org/issue2651 + """ + return self.msg + + +class ConfigAttributeError(OmegaConfBaseException, AttributeError): + """ + Thrown from a config object when a regular access would have caused an AttributeError. + """ + + +class ConfigTypeError(OmegaConfBaseException, TypeError): + """ + Thrown from a config object when a regular access would have caused a TypeError. + """ + + +class ConfigIndexError(OmegaConfBaseException, IndexError): + """ + Thrown from a config object when a regular access would have caused an IndexError. + """ + + +class ConfigValueError(OmegaConfBaseException, ValueError): + """ + Thrown from a config object when a regular access would have caused a ValueError. + """ + + +class ConfigCycleDetectedException(OmegaConfBaseException): + """ + Thrown when a cycle is detected in the graph made by config nodes. + """ + + +class GrammarParseError(OmegaConfBaseException): + """ + Thrown when failing to parse an expression according to the ANTLR grammar. + """ diff --git a/runtime/Lib/site-packages/omegaconf/grammar/__init__.py b/runtime/Lib/site-packages/omegaconf/grammar/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarLexer.py b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarLexer.py new file mode 100644 index 0000000000000000000000000000000000000000..1bf9416fab12aaf7eb45c73b620037d4800e3496 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarLexer.py @@ -0,0 +1,337 @@ +# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarLexer.g4 by ANTLR 4.9.3 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\36") + buf.write("\u01e7\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5") + buf.write("\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13") + buf.write("\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t") + buf.write("\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26") + buf.write("\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34") + buf.write("\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t") + buf.write("\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4") + buf.write("+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62") + buf.write("\t\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\3\2\3\2") + buf.write("\3\3\3\3\3\4\3\4\3\4\5\4y\n\4\3\4\7\4|\n\4\f\4\16\4\177") + buf.write("\13\4\5\4\u0081\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3") + buf.write("\7\7\7\u008c\n\7\f\7\16\7\u008f\13\7\3\7\3\7\3\b\7\b\u0094") + buf.write("\n\b\f\b\16\b\u0097\13\b\3\b\3\b\3\b\3\b\3\t\6\t\u009e") + buf.write("\n\t\r\t\16\t\u009f\3\n\6\n\u00a3\n\n\r\n\16\n\u00a4\3") + buf.write("\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\5\f\u00b1\n") + buf.write("\f\3\f\3\f\3\r\3\r\5\r\u00b7\n\r\3\r\3\r\3\16\5\16\u00bc") + buf.write("\n\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20") + buf.write("\3\20\3\20\3\21\5\21\u00cb\n\21\3\21\3\21\5\21\u00cf\n") + buf.write("\21\3\22\3\22\5\22\u00d3\n\22\3\23\5\23\u00d6\n\23\3\23") + buf.write("\3\23\3\24\5\24\u00db\n\24\3\24\3\24\5\24\u00df\n\24\3") + buf.write("\25\3\25\3\25\3\25\5\25\u00e5\n\25\3\25\3\25\3\25\5\25") + buf.write("\u00ea\n\25\3\25\7\25\u00ed\n\25\f\25\16\25\u00f0\13\25") + buf.write("\5\25\u00f2\n\25\3\26\3\26\5\26\u00f6\n\26\3\26\3\26\5") + buf.write("\26\u00fa\n\26\3\26\3\26\5\26\u00fe\n\26\3\26\7\26\u0101") + buf.write("\n\26\f\26\16\26\u0104\13\26\3\27\5\27\u0107\n\27\3\27") + buf.write("\3\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u0111\n\27\3") + buf.write("\30\5\30\u0114\n\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31") + buf.write("\3\31\3\31\3\31\3\31\5\31\u0121\n\31\3\32\3\32\3\32\3") + buf.write("\32\3\32\3\33\3\33\3\34\3\34\5\34\u012c\n\34\3\34\3\34") + buf.write("\3\34\7\34\u0131\n\34\f\34\16\34\u0134\13\34\3\35\3\35") + buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35") + buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\6\35") + buf.write("\u014d\n\35\r\35\16\35\u014e\3\36\6\36\u0152\n\36\r\36") + buf.write("\16\36\u0153\3\37\3\37\5\37\u0158\n\37\3\37\3\37\3\37") + buf.write("\3 \5 \u015e\n \3 \3 \5 \u0162\n \3 \3 \3 \3!\5!\u0168") + buf.write("\n!\3!\3!\3!\3!\3\"\3\"\3#\3#\3#\3#\3$\3$\3$\3$\3%\3%") + buf.write("\3%\3%\3&\6&\u017d\n&\r&\16&\u017e\3\'\3\'\3\'\3\'\3\'") + buf.write("\3(\3(\3(\3(\3)\7)\u018b\n)\f)\16)\u018e\13)\3)\3)\3)") + buf.write("\3)\3*\3*\3*\3*\3+\7+\u0199\n+\f+\16+\u019c\13+\3+\3+") + buf.write("\3+\3+\3+\3,\6,\u01a4\n,\r,\16,\u01a5\3-\6-\u01a9\n-\r") + buf.write("-\16-\u01aa\3-\3-\3.\3.\3.\3.\3/\3/\3/\3/\3/\3\60\3\60") + buf.write("\3\60\3\60\3\60\3\61\7\61\u01be\n\61\f\61\16\61\u01c1") + buf.write("\13\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\63\7") + buf.write("\63\u01cc\n\63\f\63\16\63\u01cf\13\63\3\63\3\63\3\63\3") + buf.write("\63\3\63\3\64\6\64\u01d7\n\64\r\64\16\64\u01d8\3\64\3") + buf.write("\64\3\65\6\65\u01de\n\65\r\65\16\65\u01df\3\65\3\65\3") + buf.write("\66\3\66\3\66\3\66\2\2\67\7\2\t\2\13\2\r\2\17\2\21\3\23") + buf.write("\4\25\5\27\2\31\34\33\6\35\7\37\b!\t#\n%\13\'\f)\r+\16") + buf.write("-\2/\2\61\17\63\20\65\21\67\229\23;\24=\25?\26A\2C\2E") + buf.write("\27G\30I\35K\36M\2O\31Q\2S\32U\2W\2Y\2[\33]\2_\2a\2c\2") + buf.write("e\2g\2i\2k\2m\2o\2\7\2\3\4\5\6\32\4\2C\\c|\3\2\62;\3\2") + buf.write("\63;\3\2&&\4\2&&^^\4\2GGgg\4\2--//\4\2KKkk\4\2PPpp\4\2") + buf.write("HHhh\4\2CCcc\4\2VVvv\4\2TTtt\4\2WWww\4\2NNnn\4\2UUuu\b") + buf.write("\2&\',-/\61AB^^~~\4\2//aa\4\2\13\13\"\"\13\2\13\13\"\"") + buf.write("$$)+\60\60<<]_}}\177\177\4\2&&))\5\2&&))^^\4\2$$&&\5\2") + buf.write("$$&&^^\2\u0218\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2") + buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\3\33\3\2\2\2\3") + buf.write("\35\3\2\2\2\3\37\3\2\2\2\3!\3\2\2\2\3#\3\2\2\2\3%\3\2") + buf.write("\2\2\3\'\3\2\2\2\3)\3\2\2\2\3+\3\2\2\2\3\61\3\2\2\2\3") + buf.write("\63\3\2\2\2\3\65\3\2\2\2\3\67\3\2\2\2\39\3\2\2\2\3;\3") + buf.write("\2\2\2\3=\3\2\2\2\3?\3\2\2\2\4A\3\2\2\2\4C\3\2\2\2\4E") + buf.write("\3\2\2\2\4G\3\2\2\2\4I\3\2\2\2\4K\3\2\2\2\4M\3\2\2\2\4") + buf.write("O\3\2\2\2\5Q\3\2\2\2\5S\3\2\2\2\5U\3\2\2\2\5W\3\2\2\2") + buf.write("\5Y\3\2\2\2\5[\3\2\2\2\5]\3\2\2\2\5_\3\2\2\2\6a\3\2\2") + buf.write("\2\6c\3\2\2\2\6e\3\2\2\2\6g\3\2\2\2\6i\3\2\2\2\6k\3\2") + buf.write("\2\2\6m\3\2\2\2\6o\3\2\2\2\7q\3\2\2\2\ts\3\2\2\2\13\u0080") + buf.write("\3\2\2\2\r\u0082\3\2\2\2\17\u0085\3\2\2\2\21\u008d\3\2") + buf.write("\2\2\23\u0095\3\2\2\2\25\u009d\3\2\2\2\27\u00a2\3\2\2") + buf.write("\2\31\u00a8\3\2\2\2\33\u00ac\3\2\2\2\35\u00b4\3\2\2\2") + buf.write("\37\u00bb\3\2\2\2!\u00c1\3\2\2\2#\u00c5\3\2\2\2%\u00ca") + buf.write("\3\2\2\2\'\u00d0\3\2\2\2)\u00d5\3\2\2\2+\u00da\3\2\2\2") + buf.write("-\u00f1\3\2\2\2/\u00f5\3\2\2\2\61\u0106\3\2\2\2\63\u0113") + buf.write("\3\2\2\2\65\u0120\3\2\2\2\67\u0122\3\2\2\29\u0127\3\2") + buf.write("\2\2;\u012b\3\2\2\2=\u014c\3\2\2\2?\u0151\3\2\2\2A\u0155") + buf.write("\3\2\2\2C\u015d\3\2\2\2E\u0167\3\2\2\2G\u016d\3\2\2\2") + buf.write("I\u016f\3\2\2\2K\u0173\3\2\2\2M\u0177\3\2\2\2O\u017c\3") + buf.write("\2\2\2Q\u0180\3\2\2\2S\u0185\3\2\2\2U\u018c\3\2\2\2W\u0193") + buf.write("\3\2\2\2Y\u019a\3\2\2\2[\u01a3\3\2\2\2]\u01a8\3\2\2\2") + buf.write("_\u01ae\3\2\2\2a\u01b2\3\2\2\2c\u01b7\3\2\2\2e\u01bf\3") + buf.write("\2\2\2g\u01c6\3\2\2\2i\u01cd\3\2\2\2k\u01d6\3\2\2\2m\u01dd") + buf.write("\3\2\2\2o\u01e3\3\2\2\2qr\t\2\2\2r\b\3\2\2\2st\t\3\2\2") + buf.write("t\n\3\2\2\2u\u0081\7\62\2\2v}\t\4\2\2wy\7a\2\2xw\3\2\2") + buf.write("\2xy\3\2\2\2yz\3\2\2\2z|\5\t\3\2{x\3\2\2\2|\177\3\2\2") + buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080") + buf.write("u\3\2\2\2\u0080v\3\2\2\2\u0081\f\3\2\2\2\u0082\u0083\7") + buf.write("^\2\2\u0083\u0084\7^\2\2\u0084\16\3\2\2\2\u0085\u0086") + buf.write("\5\33\f\2\u0086\u0087\3\2\2\2\u0087\u0088\b\6\2\2\u0088") + buf.write("\u0089\b\6\3\2\u0089\20\3\2\2\2\u008a\u008c\n\5\2\2\u008b") + buf.write("\u008a\3\2\2\2\u008c\u008f\3\2\2\2\u008d\u008b\3\2\2\2") + buf.write("\u008d\u008e\3\2\2\2\u008e\u0090\3\2\2\2\u008f\u008d\3") + buf.write("\2\2\2\u0090\u0091\n\6\2\2\u0091\22\3\2\2\2\u0092\u0094") + buf.write("\5\r\5\2\u0093\u0092\3\2\2\2\u0094\u0097\3\2\2\2\u0095") + buf.write("\u0093\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0098\3\2\2\2") + buf.write("\u0097\u0095\3\2\2\2\u0098\u0099\7^\2\2\u0099\u009a\7") + buf.write("&\2\2\u009a\u009b\7}\2\2\u009b\24\3\2\2\2\u009c\u009e") + buf.write("\5\r\5\2\u009d\u009c\3\2\2\2\u009e\u009f\3\2\2\2\u009f") + buf.write("\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\26\3\2\2\2\u00a1") + buf.write("\u00a3\7^\2\2\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2") + buf.write("\u00a4\u00a2\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a6\3") + buf.write("\2\2\2\u00a6\u00a7\b\n\4\2\u00a7\30\3\2\2\2\u00a8\u00a9") + buf.write("\7&\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\b\13\4\2\u00ab") + buf.write("\32\3\2\2\2\u00ac\u00ad\7&\2\2\u00ad\u00ae\7}\2\2\u00ae") + buf.write("\u00b0\3\2\2\2\u00af\u00b1\5?\36\2\u00b0\u00af\3\2\2\2") + buf.write("\u00b0\u00b1\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\b") + buf.write("\f\3\2\u00b3\34\3\2\2\2\u00b4\u00b6\7}\2\2\u00b5\u00b7") + buf.write("\5?\36\2\u00b6\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7") + buf.write("\u00b8\3\2\2\2\u00b8\u00b9\b\r\5\2\u00b9\36\3\2\2\2\u00ba") + buf.write("\u00bc\5?\36\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2") + buf.write("\u00bc\u00bd\3\2\2\2\u00bd\u00be\7\177\2\2\u00be\u00bf") + buf.write("\3\2\2\2\u00bf\u00c0\b\16\6\2\u00c0 \3\2\2\2\u00c1\u00c2") + buf.write("\7)\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c4\b\17\7\2\u00c4") + buf.write("\"\3\2\2\2\u00c5\u00c6\7$\2\2\u00c6\u00c7\3\2\2\2\u00c7") + buf.write("\u00c8\b\20\b\2\u00c8$\3\2\2\2\u00c9\u00cb\5?\36\2\u00ca") + buf.write("\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2") + buf.write("\u00cc\u00ce\7.\2\2\u00cd\u00cf\5?\36\2\u00ce\u00cd\3") + buf.write("\2\2\2\u00ce\u00cf\3\2\2\2\u00cf&\3\2\2\2\u00d0\u00d2") + buf.write("\7]\2\2\u00d1\u00d3\5?\36\2\u00d2\u00d1\3\2\2\2\u00d2") + buf.write("\u00d3\3\2\2\2\u00d3(\3\2\2\2\u00d4\u00d6\5?\36\2\u00d5") + buf.write("\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00d7\3\2\2\2") + buf.write("\u00d7\u00d8\7_\2\2\u00d8*\3\2\2\2\u00d9\u00db\5?\36\2") + buf.write("\u00da\u00d9\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\3") + buf.write("\2\2\2\u00dc\u00de\7<\2\2\u00dd\u00df\5?\36\2\u00de\u00dd") + buf.write("\3\2\2\2\u00de\u00df\3\2\2\2\u00df,\3\2\2\2\u00e0\u00e1") + buf.write("\5\13\4\2\u00e1\u00e2\7\60\2\2\u00e2\u00f2\3\2\2\2\u00e3") + buf.write("\u00e5\5\13\4\2\u00e4\u00e3\3\2\2\2\u00e4\u00e5\3\2\2") + buf.write("\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\7\60\2\2\u00e7\u00ee") + buf.write("\5\t\3\2\u00e8\u00ea\7a\2\2\u00e9\u00e8\3\2\2\2\u00e9") + buf.write("\u00ea\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ed\5\t\3\2") + buf.write("\u00ec\u00e9\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3") + buf.write("\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee") + buf.write("\3\2\2\2\u00f1\u00e0\3\2\2\2\u00f1\u00e4\3\2\2\2\u00f2") + buf.write(".\3\2\2\2\u00f3\u00f6\5\13\4\2\u00f4\u00f6\5-\25\2\u00f5") + buf.write("\u00f3\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2") + buf.write("\u00f7\u00f9\t\7\2\2\u00f8\u00fa\t\b\2\2\u00f9\u00f8\3") + buf.write("\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u0102") + buf.write("\5\t\3\2\u00fc\u00fe\7a\2\2\u00fd\u00fc\3\2\2\2\u00fd") + buf.write("\u00fe\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0101\5\t\3\2") + buf.write("\u0100\u00fd\3\2\2\2\u0101\u0104\3\2\2\2\u0102\u0100\3") + buf.write("\2\2\2\u0102\u0103\3\2\2\2\u0103\60\3\2\2\2\u0104\u0102") + buf.write("\3\2\2\2\u0105\u0107\t\b\2\2\u0106\u0105\3\2\2\2\u0106") + buf.write("\u0107\3\2\2\2\u0107\u0110\3\2\2\2\u0108\u0111\5-\25\2") + buf.write("\u0109\u0111\5/\26\2\u010a\u010b\t\t\2\2\u010b\u010c\t") + buf.write("\n\2\2\u010c\u0111\t\13\2\2\u010d\u010e\t\n\2\2\u010e") + buf.write("\u010f\t\f\2\2\u010f\u0111\t\n\2\2\u0110\u0108\3\2\2\2") + buf.write("\u0110\u0109\3\2\2\2\u0110\u010a\3\2\2\2\u0110\u010d\3") + buf.write("\2\2\2\u0111\62\3\2\2\2\u0112\u0114\t\b\2\2\u0113\u0112") + buf.write("\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0115\3\2\2\2\u0115") + buf.write("\u0116\5\13\4\2\u0116\64\3\2\2\2\u0117\u0118\t\r\2\2\u0118") + buf.write("\u0119\t\16\2\2\u0119\u011a\t\17\2\2\u011a\u0121\t\7\2") + buf.write("\2\u011b\u011c\t\13\2\2\u011c\u011d\t\f\2\2\u011d\u011e") + buf.write("\t\20\2\2\u011e\u011f\t\21\2\2\u011f\u0121\t\7\2\2\u0120") + buf.write("\u0117\3\2\2\2\u0120\u011b\3\2\2\2\u0121\66\3\2\2\2\u0122") + buf.write("\u0123\t\n\2\2\u0123\u0124\t\17\2\2\u0124\u0125\t\20\2") + buf.write("\2\u0125\u0126\t\20\2\2\u01268\3\2\2\2\u0127\u0128\t\22") + buf.write("\2\2\u0128:\3\2\2\2\u0129\u012c\5\7\2\2\u012a\u012c\7") + buf.write("a\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u0132") + buf.write("\3\2\2\2\u012d\u0131\5\7\2\2\u012e\u0131\5\t\3\2\u012f") + buf.write("\u0131\t\23\2\2\u0130\u012d\3\2\2\2\u0130\u012e\3\2\2") + buf.write("\2\u0130\u012f\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130") + buf.write("\3\2\2\2\u0132\u0133\3\2\2\2\u0133<\3\2\2\2\u0134\u0132") + buf.write("\3\2\2\2\u0135\u014d\5\r\5\2\u0136\u0137\7^\2\2\u0137") + buf.write("\u014d\7*\2\2\u0138\u0139\7^\2\2\u0139\u014d\7+\2\2\u013a") + buf.write("\u013b\7^\2\2\u013b\u014d\7]\2\2\u013c\u013d\7^\2\2\u013d") + buf.write("\u014d\7_\2\2\u013e\u013f\7^\2\2\u013f\u014d\7}\2\2\u0140") + buf.write("\u0141\7^\2\2\u0141\u014d\7\177\2\2\u0142\u0143\7^\2\2") + buf.write("\u0143\u014d\7<\2\2\u0144\u0145\7^\2\2\u0145\u014d\7?") + buf.write("\2\2\u0146\u0147\7^\2\2\u0147\u014d\7.\2\2\u0148\u0149") + buf.write("\7^\2\2\u0149\u014d\7\"\2\2\u014a\u014b\7^\2\2\u014b\u014d") + buf.write("\7\13\2\2\u014c\u0135\3\2\2\2\u014c\u0136\3\2\2\2\u014c") + buf.write("\u0138\3\2\2\2\u014c\u013a\3\2\2\2\u014c\u013c\3\2\2\2") + buf.write("\u014c\u013e\3\2\2\2\u014c\u0140\3\2\2\2\u014c\u0142\3") + buf.write("\2\2\2\u014c\u0144\3\2\2\2\u014c\u0146\3\2\2\2\u014c\u0148") + buf.write("\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u014e\3\2\2\2\u014e") + buf.write("\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f>\3\2\2\2\u0150") + buf.write("\u0152\t\24\2\2\u0151\u0150\3\2\2\2\u0152\u0153\3\2\2") + buf.write("\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154@\3\2") + buf.write("\2\2\u0155\u0157\5\33\f\2\u0156\u0158\5?\36\2\u0157\u0156") + buf.write("\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0159\3\2\2\2\u0159") + buf.write("\u015a\b\37\2\2\u015a\u015b\b\37\3\2\u015bB\3\2\2\2\u015c") + buf.write("\u015e\5?\36\2\u015d\u015c\3\2\2\2\u015d\u015e\3\2\2\2") + buf.write("\u015e\u015f\3\2\2\2\u015f\u0161\7<\2\2\u0160\u0162\5") + buf.write("?\36\2\u0161\u0160\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163") + buf.write("\3\2\2\2\u0163\u0164\b \t\2\u0164\u0165\b \n\2\u0165D") + buf.write("\3\2\2\2\u0166\u0168\5?\36\2\u0167\u0166\3\2\2\2\u0167") + buf.write("\u0168\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\7\177\2") + buf.write("\2\u016a\u016b\3\2\2\2\u016b\u016c\b!\6\2\u016cF\3\2\2") + buf.write("\2\u016d\u016e\7\60\2\2\u016eH\3\2\2\2\u016f\u0170\7]") + buf.write("\2\2\u0170\u0171\3\2\2\2\u0171\u0172\b#\13\2\u0172J\3") + buf.write("\2\2\2\u0173\u0174\7_\2\2\u0174\u0175\3\2\2\2\u0175\u0176") + buf.write("\b$\f\2\u0176L\3\2\2\2\u0177\u0178\5;\34\2\u0178\u0179") + buf.write("\3\2\2\2\u0179\u017a\b%\r\2\u017aN\3\2\2\2\u017b\u017d") + buf.write("\n\25\2\2\u017c\u017b\3\2\2\2\u017d\u017e\3\2\2\2\u017e") + buf.write("\u017c\3\2\2\2\u017e\u017f\3\2\2\2\u017fP\3\2\2\2\u0180") + buf.write("\u0181\5\33\f\2\u0181\u0182\3\2\2\2\u0182\u0183\b\'\2") + buf.write("\2\u0183\u0184\b\'\3\2\u0184R\3\2\2\2\u0185\u0186\7)\2") + buf.write("\2\u0186\u0187\3\2\2\2\u0187\u0188\b(\6\2\u0188T\3\2\2") + buf.write("\2\u0189\u018b\n\26\2\2\u018a\u0189\3\2\2\2\u018b\u018e") + buf.write("\3\2\2\2\u018c\u018a\3\2\2\2\u018c\u018d\3\2\2\2\u018d") + buf.write("\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f\u0190\n\27\2") + buf.write("\2\u0190\u0191\3\2\2\2\u0191\u0192\b)\4\2\u0192V\3\2\2") + buf.write("\2\u0193\u0194\5\23\b\2\u0194\u0195\3\2\2\2\u0195\u0196") + buf.write("\b*\16\2\u0196X\3\2\2\2\u0197\u0199\5\r\5\2\u0198\u0197") + buf.write("\3\2\2\2\u0199\u019c\3\2\2\2\u019a\u0198\3\2\2\2\u019a") + buf.write("\u019b\3\2\2\2\u019b\u019d\3\2\2\2\u019c\u019a\3\2\2\2") + buf.write("\u019d\u019e\7^\2\2\u019e\u019f\7)\2\2\u019f\u01a0\3\2") + buf.write("\2\2\u01a0\u01a1\b+\17\2\u01a1Z\3\2\2\2\u01a2\u01a4\5") + buf.write("\r\5\2\u01a3\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a3") + buf.write("\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\\\3\2\2\2\u01a7\u01a9") + buf.write("\7^\2\2\u01a8\u01a7\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa") + buf.write("\u01a8\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\3\2\2\2") + buf.write("\u01ac\u01ad\b-\4\2\u01ad^\3\2\2\2\u01ae\u01af\7&\2\2") + buf.write("\u01af\u01b0\3\2\2\2\u01b0\u01b1\b.\4\2\u01b1`\3\2\2\2") + buf.write("\u01b2\u01b3\5\33\f\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5") + buf.write("\b/\2\2\u01b5\u01b6\b/\3\2\u01b6b\3\2\2\2\u01b7\u01b8") + buf.write("\7$\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\b\60\20\2\u01ba") + buf.write("\u01bb\b\60\6\2\u01bbd\3\2\2\2\u01bc\u01be\n\30\2\2\u01bd") + buf.write("\u01bc\3\2\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2") + buf.write("\u01bf\u01c0\3\2\2\2\u01c0\u01c2\3\2\2\2\u01c1\u01bf\3") + buf.write("\2\2\2\u01c2\u01c3\n\31\2\2\u01c3\u01c4\3\2\2\2\u01c4") + buf.write("\u01c5\b\61\4\2\u01c5f\3\2\2\2\u01c6\u01c7\5\23\b\2\u01c7") + buf.write("\u01c8\3\2\2\2\u01c8\u01c9\b\62\16\2\u01c9h\3\2\2\2\u01ca") + buf.write("\u01cc\5\r\5\2\u01cb\u01ca\3\2\2\2\u01cc\u01cf\3\2\2\2") + buf.write("\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01d0\3") + buf.write("\2\2\2\u01cf\u01cd\3\2\2\2\u01d0\u01d1\7^\2\2\u01d1\u01d2") + buf.write("\7$\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\b\63\17\2\u01d4") + buf.write("j\3\2\2\2\u01d5\u01d7\5\r\5\2\u01d6\u01d5\3\2\2\2\u01d7") + buf.write("\u01d8\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2") + buf.write("\u01d9\u01da\3\2\2\2\u01da\u01db\b\64\21\2\u01dbl\3\2") + buf.write("\2\2\u01dc\u01de\7^\2\2\u01dd\u01dc\3\2\2\2\u01de\u01df") + buf.write("\3\2\2\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0") + buf.write("\u01e1\3\2\2\2\u01e1\u01e2\b\65\4\2\u01e2n\3\2\2\2\u01e3") + buf.write("\u01e4\7&\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\b\66\4\2") + buf.write("\u01e6p\3\2\2\2\66\2\3\4\5\6x}\u0080\u008d\u0095\u009f") + buf.write("\u00a4\u00b0\u00b6\u00bb\u00ca\u00ce\u00d2\u00d5\u00da") + buf.write("\u00de\u00e4\u00e9\u00ee\u00f1\u00f5\u00f9\u00fd\u0102") + buf.write("\u0106\u0110\u0113\u0120\u012b\u0130\u0132\u014c\u014e") + buf.write("\u0153\u0157\u015d\u0161\u0167\u017e\u018c\u019a\u01a5") + buf.write("\u01aa\u01bf\u01cd\u01d8\u01df\22\t\6\2\7\4\2\t\3\2\7") + buf.write("\3\2\6\2\2\7\5\2\7\6\2\t\16\2\4\3\2\t\f\2\t\r\2\t\24\2") + buf.write("\t\4\2\t\25\2\t\32\2\t\33\2") + return buf.getvalue() + + +class OmegaConfGrammarLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + VALUE_MODE = 1 + INTERPOLATION_MODE = 2 + QUOTED_SINGLE_MODE = 3 + QUOTED_DOUBLE_MODE = 4 + + ANY_STR = 1 + ESC_INTER = 2 + TOP_ESC = 3 + INTER_OPEN = 4 + BRACE_OPEN = 5 + BRACE_CLOSE = 6 + QUOTE_OPEN_SINGLE = 7 + QUOTE_OPEN_DOUBLE = 8 + COMMA = 9 + BRACKET_OPEN = 10 + BRACKET_CLOSE = 11 + COLON = 12 + FLOAT = 13 + INT = 14 + BOOL = 15 + NULL = 16 + UNQUOTED_CHAR = 17 + ID = 18 + ESC = 19 + WS = 20 + INTER_CLOSE = 21 + DOT = 22 + INTER_KEY = 23 + MATCHING_QUOTE_CLOSE = 24 + QUOTED_ESC = 25 + DOLLAR = 26 + INTER_BRACKET_OPEN = 27 + INTER_BRACKET_CLOSE = 28 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE", "VALUE_MODE", "INTERPOLATION_MODE", "QUOTED_SINGLE_MODE", + "QUOTED_DOUBLE_MODE" ] + + literalNames = [ "", + "'.'", "'['", "']'" ] + + symbolicNames = [ "", + "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", "BRACE_OPEN", + "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", "QUOTE_OPEN_DOUBLE", "COMMA", + "BRACKET_OPEN", "BRACKET_CLOSE", "COLON", "FLOAT", "INT", "BOOL", + "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "INTER_CLOSE", "DOT", + "INTER_KEY", "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", + "INTER_BRACKET_OPEN", "INTER_BRACKET_CLOSE" ] + + ruleNames = [ "CHAR", "DIGIT", "INT_UNSIGNED", "ESC_BACKSLASH", "TOP_INTER_OPEN", + "ANY_STR", "ESC_INTER", "TOP_ESC", "BACKSLASHES", "DOLLAR", + "INTER_OPEN", "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", + "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", + "COLON", "POINT_FLOAT", "EXPONENT_FLOAT", "FLOAT", "INT", + "BOOL", "NULL", "UNQUOTED_CHAR", "ID", "ESC", "WS", "NESTED_INTER_OPEN", + "INTER_COLON", "INTER_CLOSE", "DOT", "INTER_BRACKET_OPEN", + "INTER_BRACKET_CLOSE", "INTER_ID", "INTER_KEY", "QSINGLE_INTER_OPEN", + "MATCHING_QUOTE_CLOSE", "QSINGLE_STR", "QSINGLE_ESC_INTER", + "QSINGLE_ESC_QUOTE", "QUOTED_ESC", "QSINGLE_BACKSLASHES", + "QSINGLE_DOLLAR", "QDOUBLE_INTER_OPEN", "QDOUBLE_CLOSE", + "QDOUBLE_STR", "QDOUBLE_ESC_INTER", "QDOUBLE_ESC_QUOTE", + "QDOUBLE_ESC", "QDOUBLE_BACKSLASHES", "QDOUBLE_DOLLAR" ] + + grammarFileName = "OmegaConfGrammarLexer.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.3") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py new file mode 100644 index 0000000000000000000000000000000000000000..024cbab87fddd6ed3b4abb63105589f673b0e864 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParser.py @@ -0,0 +1,1595 @@ +# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\36") + buf.write("\u00b7\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") + buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") + buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3\2\3\3\3") + buf.write("\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\6\4/\n\4\r\4\16\4\60\3") + buf.write("\5\3\5\3\5\3\5\5\5\67\n\5\3\6\3\6\5\6;\n\6\3\6\3\6\3\7") + buf.write("\3\7\3\7\3\7\7\7C\n\7\f\7\16\7F\13\7\5\7H\n\7\3\7\3\7") + buf.write("\3\b\3\b\3\b\3\b\3\t\3\t\3\t\5\tS\n\t\7\tU\n\t\f\t\16") + buf.write("\tX\13\t\3\t\3\t\5\t\\\n\t\6\t^\n\t\r\t\16\t_\5\tb\n\t") + buf.write("\3\n\3\n\5\nf\n\n\3\13\3\13\7\13j\n\13\f\13\16\13m\13") + buf.write("\13\3\13\3\13\3\13\3\13\3\13\5\13t\n\13\3\13\3\13\3\13") + buf.write("\3\13\3\13\3\13\7\13|\n\13\f\13\16\13\177\13\13\3\13\3") + buf.write("\13\3\f\3\f\3\f\3\f\5\f\u0087\n\f\3\f\3\f\3\r\3\r\3\r") + buf.write("\5\r\u008e\n\r\3\16\3\16\5\16\u0092\n\16\3\16\3\16\3\16") + buf.write("\5\16\u0097\n\16\7\16\u0099\n\16\f\16\16\16\u009c\13\16") + buf.write("\3\17\3\17\5\17\u00a0\n\17\3\17\3\17\3\20\3\20\3\20\3") + buf.write("\20\3\20\3\20\3\20\3\20\3\20\3\20\6\20\u00ae\n\20\r\20") + buf.write("\16\20\u00af\3\21\6\21\u00b3\n\21\r\21\16\21\u00b4\3\21") + buf.write("\2\2\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \2\4\3") + buf.write("\2\t\n\3\2\17\26\2\u00ce\2\"\3\2\2\2\4%\3\2\2\2\6.\3\2") + buf.write("\2\2\b\66\3\2\2\2\n8\3\2\2\2\f>\3\2\2\2\16K\3\2\2\2\20") + buf.write("a\3\2\2\2\22e\3\2\2\2\24g\3\2\2\2\26\u0082\3\2\2\2\30") + buf.write("\u008d\3\2\2\2\32\u0091\3\2\2\2\34\u009d\3\2\2\2\36\u00ad") + buf.write("\3\2\2\2 \u00b2\3\2\2\2\"#\5\6\4\2#$\7\2\2\3$\3\3\2\2") + buf.write("\2%&\5\b\5\2&\'\7\2\2\3\'\5\3\2\2\2(/\5\22\n\2)/\7\3\2") + buf.write("\2*/\7\25\2\2+/\7\4\2\2,/\7\5\2\2-/\7\33\2\2.(\3\2\2\2") + buf.write(".)\3\2\2\2.*\3\2\2\2.+\3\2\2\2.,\3\2\2\2.-\3\2\2\2/\60") + buf.write("\3\2\2\2\60.\3\2\2\2\60\61\3\2\2\2\61\7\3\2\2\2\62\67") + buf.write("\5\36\20\2\63\67\5\34\17\2\64\67\5\n\6\2\65\67\5\f\7\2") + buf.write("\66\62\3\2\2\2\66\63\3\2\2\2\66\64\3\2\2\2\66\65\3\2\2") + buf.write("\2\67\t\3\2\2\28:\7\f\2\29;\5\20\t\2:9\3\2\2\2:;\3\2\2") + buf.write("\2;<\3\2\2\2<=\7\r\2\2=\13\3\2\2\2>G\7\7\2\2?D\5\16\b") + buf.write("\2@A\7\13\2\2AC\5\16\b\2B@\3\2\2\2CF\3\2\2\2DB\3\2\2\2") + buf.write("DE\3\2\2\2EH\3\2\2\2FD\3\2\2\2G?\3\2\2\2GH\3\2\2\2HI\3") + buf.write("\2\2\2IJ\7\b\2\2J\r\3\2\2\2KL\5 \21\2LM\7\16\2\2MN\5\b") + buf.write("\5\2N\17\3\2\2\2OV\5\b\5\2PR\7\13\2\2QS\5\b\5\2RQ\3\2") + buf.write("\2\2RS\3\2\2\2SU\3\2\2\2TP\3\2\2\2UX\3\2\2\2VT\3\2\2\2") + buf.write("VW\3\2\2\2Wb\3\2\2\2XV\3\2\2\2Y[\7\13\2\2Z\\\5\b\5\2[") + buf.write("Z\3\2\2\2[\\\3\2\2\2\\^\3\2\2\2]Y\3\2\2\2^_\3\2\2\2_]") + buf.write("\3\2\2\2_`\3\2\2\2`b\3\2\2\2aO\3\2\2\2a]\3\2\2\2b\21\3") + buf.write("\2\2\2cf\5\24\13\2df\5\26\f\2ec\3\2\2\2ed\3\2\2\2f\23") + buf.write("\3\2\2\2gk\7\6\2\2hj\7\30\2\2ih\3\2\2\2jm\3\2\2\2ki\3") + buf.write("\2\2\2kl\3\2\2\2ls\3\2\2\2mk\3\2\2\2nt\5\30\r\2op\7\f") + buf.write("\2\2pq\5\30\r\2qr\7\r\2\2rt\3\2\2\2sn\3\2\2\2so\3\2\2") + buf.write("\2t}\3\2\2\2uv\7\30\2\2v|\5\30\r\2wx\7\f\2\2xy\5\30\r") + buf.write("\2yz\7\r\2\2z|\3\2\2\2{u\3\2\2\2{w\3\2\2\2|\177\3\2\2") + buf.write("\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2\u0080") + buf.write("\u0081\7\27\2\2\u0081\25\3\2\2\2\u0082\u0083\7\6\2\2\u0083") + buf.write("\u0084\5\32\16\2\u0084\u0086\7\16\2\2\u0085\u0087\5\20") + buf.write("\t\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088") + buf.write("\3\2\2\2\u0088\u0089\7\b\2\2\u0089\27\3\2\2\2\u008a\u008e") + buf.write("\5\22\n\2\u008b\u008e\7\24\2\2\u008c\u008e\7\31\2\2\u008d") + buf.write("\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c\3\2\2\2") + buf.write("\u008e\31\3\2\2\2\u008f\u0092\5\22\n\2\u0090\u0092\7\24") + buf.write("\2\2\u0091\u008f\3\2\2\2\u0091\u0090\3\2\2\2\u0092\u009a") + buf.write("\3\2\2\2\u0093\u0096\7\30\2\2\u0094\u0097\5\22\n\2\u0095") + buf.write("\u0097\7\24\2\2\u0096\u0094\3\2\2\2\u0096\u0095\3\2\2") + buf.write("\2\u0097\u0099\3\2\2\2\u0098\u0093\3\2\2\2\u0099\u009c") + buf.write("\3\2\2\2\u009a\u0098\3\2\2\2\u009a\u009b\3\2\2\2\u009b") + buf.write("\33\3\2\2\2\u009c\u009a\3\2\2\2\u009d\u009f\t\2\2\2\u009e") + buf.write("\u00a0\5\6\4\2\u009f\u009e\3\2\2\2\u009f\u00a0\3\2\2\2") + buf.write("\u00a0\u00a1\3\2\2\2\u00a1\u00a2\7\32\2\2\u00a2\35\3\2") + buf.write("\2\2\u00a3\u00ae\7\24\2\2\u00a4\u00ae\7\22\2\2\u00a5\u00ae") + buf.write("\7\20\2\2\u00a6\u00ae\7\17\2\2\u00a7\u00ae\7\21\2\2\u00a8") + buf.write("\u00ae\7\23\2\2\u00a9\u00ae\7\16\2\2\u00aa\u00ae\7\25") + buf.write("\2\2\u00ab\u00ae\7\26\2\2\u00ac\u00ae\5\22\n\2\u00ad\u00a3") + buf.write("\3\2\2\2\u00ad\u00a4\3\2\2\2\u00ad\u00a5\3\2\2\2\u00ad") + buf.write("\u00a6\3\2\2\2\u00ad\u00a7\3\2\2\2\u00ad\u00a8\3\2\2\2") + buf.write("\u00ad\u00a9\3\2\2\2\u00ad\u00aa\3\2\2\2\u00ad\u00ab\3") + buf.write("\2\2\2\u00ad\u00ac\3\2\2\2\u00ae\u00af\3\2\2\2\u00af\u00ad") + buf.write("\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\37\3\2\2\2\u00b1\u00b3") + buf.write("\t\3\2\2\u00b2\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4") + buf.write("\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5!\3\2\2\2\33.") + buf.write("\60\66:DGRV[_aeks{}\u0086\u008d\u0091\u0096\u009a\u009f") + buf.write("\u00ad\u00af\u00b4") + return buf.getvalue() + + +class OmegaConfGrammarParser ( Parser ): + + grammarFileName = "OmegaConfGrammarParser.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "'.'", "", "", + "", "", "'['", "']'" ] + + symbolicNames = [ "", "ANY_STR", "ESC_INTER", "TOP_ESC", "INTER_OPEN", + "BRACE_OPEN", "BRACE_CLOSE", "QUOTE_OPEN_SINGLE", + "QUOTE_OPEN_DOUBLE", "COMMA", "BRACKET_OPEN", "BRACKET_CLOSE", + "COLON", "FLOAT", "INT", "BOOL", "NULL", "UNQUOTED_CHAR", + "ID", "ESC", "WS", "INTER_CLOSE", "DOT", "INTER_KEY", + "MATCHING_QUOTE_CLOSE", "QUOTED_ESC", "DOLLAR", "INTER_BRACKET_OPEN", + "INTER_BRACKET_CLOSE" ] + + RULE_configValue = 0 + RULE_singleElement = 1 + RULE_text = 2 + RULE_element = 3 + RULE_listContainer = 4 + RULE_dictContainer = 5 + RULE_dictKeyValuePair = 6 + RULE_sequence = 7 + RULE_interpolation = 8 + RULE_interpolationNode = 9 + RULE_interpolationResolver = 10 + RULE_configKey = 11 + RULE_resolverName = 12 + RULE_quotedValue = 13 + RULE_primitive = 14 + RULE_dictKey = 15 + + ruleNames = [ "configValue", "singleElement", "text", "element", "listContainer", + "dictContainer", "dictKeyValuePair", "sequence", "interpolation", + "interpolationNode", "interpolationResolver", "configKey", + "resolverName", "quotedValue", "primitive", "dictKey" ] + + EOF = Token.EOF + ANY_STR=1 + ESC_INTER=2 + TOP_ESC=3 + INTER_OPEN=4 + BRACE_OPEN=5 + BRACE_CLOSE=6 + QUOTE_OPEN_SINGLE=7 + QUOTE_OPEN_DOUBLE=8 + COMMA=9 + BRACKET_OPEN=10 + BRACKET_CLOSE=11 + COLON=12 + FLOAT=13 + INT=14 + BOOL=15 + NULL=16 + UNQUOTED_CHAR=17 + ID=18 + ESC=19 + WS=20 + INTER_CLOSE=21 + DOT=22 + INTER_KEY=23 + MATCHING_QUOTE_CLOSE=24 + QUOTED_ESC=25 + DOLLAR=26 + INTER_BRACKET_OPEN=27 + INTER_BRACKET_CLOSE=28 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.3") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class ConfigValueContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def text(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0) + + + def EOF(self): + return self.getToken(OmegaConfGrammarParser.EOF, 0) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_configValue + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConfigValue" ): + listener.enterConfigValue(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConfigValue" ): + listener.exitConfigValue(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConfigValue" ): + return visitor.visitConfigValue(self) + else: + return visitor.visitChildren(self) + + + + + def configValue(self): + + localctx = OmegaConfGrammarParser.ConfigValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_configValue) + try: + self.enterOuterAlt(localctx, 1) + self.state = 32 + self.text() + self.state = 33 + self.match(OmegaConfGrammarParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SingleElementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def element(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0) + + + def EOF(self): + return self.getToken(OmegaConfGrammarParser.EOF, 0) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_singleElement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSingleElement" ): + listener.enterSingleElement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSingleElement" ): + listener.exitSingleElement(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSingleElement" ): + return visitor.visitSingleElement(self) + else: + return visitor.visitChildren(self) + + + + + def singleElement(self): + + localctx = OmegaConfGrammarParser.SingleElementContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_singleElement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 35 + self.element() + self.state = 36 + self.match(OmegaConfGrammarParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TextContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def interpolation(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext) + else: + return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i) + + + def ANY_STR(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ANY_STR) + else: + return self.getToken(OmegaConfGrammarParser.ANY_STR, i) + + def ESC(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ESC) + else: + return self.getToken(OmegaConfGrammarParser.ESC, i) + + def ESC_INTER(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ESC_INTER) + else: + return self.getToken(OmegaConfGrammarParser.ESC_INTER, i) + + def TOP_ESC(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.TOP_ESC) + else: + return self.getToken(OmegaConfGrammarParser.TOP_ESC, i) + + def QUOTED_ESC(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.QUOTED_ESC) + else: + return self.getToken(OmegaConfGrammarParser.QUOTED_ESC, i) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_text + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterText" ): + listener.enterText(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitText" ): + listener.exitText(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitText" ): + return visitor.visitText(self) + else: + return visitor.visitChildren(self) + + + + + def text(self): + + localctx = OmegaConfGrammarParser.TextContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_text) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 44 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 44 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.INTER_OPEN]: + self.state = 38 + self.interpolation() + pass + elif token in [OmegaConfGrammarParser.ANY_STR]: + self.state = 39 + self.match(OmegaConfGrammarParser.ANY_STR) + pass + elif token in [OmegaConfGrammarParser.ESC]: + self.state = 40 + self.match(OmegaConfGrammarParser.ESC) + pass + elif token in [OmegaConfGrammarParser.ESC_INTER]: + self.state = 41 + self.match(OmegaConfGrammarParser.ESC_INTER) + pass + elif token in [OmegaConfGrammarParser.TOP_ESC]: + self.state = 42 + self.match(OmegaConfGrammarParser.TOP_ESC) + pass + elif token in [OmegaConfGrammarParser.QUOTED_ESC]: + self.state = 43 + self.match(OmegaConfGrammarParser.QUOTED_ESC) + pass + else: + raise NoViableAltException(self) + + self.state = 46 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0)): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ElementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def primitive(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.PrimitiveContext,0) + + + def quotedValue(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.QuotedValueContext,0) + + + def listContainer(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.ListContainerContext,0) + + + def dictContainer(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.DictContainerContext,0) + + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_element + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterElement" ): + listener.enterElement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitElement" ): + listener.exitElement(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitElement" ): + return visitor.visitElement(self) + else: + return visitor.visitChildren(self) + + + + + def element(self): + + localctx = OmegaConfGrammarParser.ElementContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_element) + try: + self.state = 52 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]: + self.enterOuterAlt(localctx, 1) + self.state = 48 + self.primitive() + pass + elif token in [OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE]: + self.enterOuterAlt(localctx, 2) + self.state = 49 + self.quotedValue() + pass + elif token in [OmegaConfGrammarParser.BRACKET_OPEN]: + self.enterOuterAlt(localctx, 3) + self.state = 50 + self.listContainer() + pass + elif token in [OmegaConfGrammarParser.BRACE_OPEN]: + self.enterOuterAlt(localctx, 4) + self.state = 51 + self.dictContainer() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ListContainerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BRACKET_OPEN(self): + return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, 0) + + def BRACKET_CLOSE(self): + return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, 0) + + def sequence(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0) + + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_listContainer + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterListContainer" ): + listener.enterListContainer(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitListContainer" ): + listener.exitListContainer(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitListContainer" ): + return visitor.visitListContainer(self) + else: + return visitor.visitChildren(self) + + + + + def listContainer(self): + + localctx = OmegaConfGrammarParser.ListContainerContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_listContainer) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 54 + self.match(OmegaConfGrammarParser.BRACKET_OPEN) + self.state = 56 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0): + self.state = 55 + self.sequence() + + + self.state = 58 + self.match(OmegaConfGrammarParser.BRACKET_CLOSE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DictContainerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BRACE_OPEN(self): + return self.getToken(OmegaConfGrammarParser.BRACE_OPEN, 0) + + def BRACE_CLOSE(self): + return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0) + + def dictKeyValuePair(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(OmegaConfGrammarParser.DictKeyValuePairContext) + else: + return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyValuePairContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.COMMA) + else: + return self.getToken(OmegaConfGrammarParser.COMMA, i) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_dictContainer + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDictContainer" ): + listener.enterDictContainer(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDictContainer" ): + listener.exitDictContainer(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDictContainer" ): + return visitor.visitDictContainer(self) + else: + return visitor.visitChildren(self) + + + + + def dictContainer(self): + + localctx = OmegaConfGrammarParser.DictContainerContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_dictContainer) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 60 + self.match(OmegaConfGrammarParser.BRACE_OPEN) + self.state = 69 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0): + self.state = 61 + self.dictKeyValuePair() + self.state = 66 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==OmegaConfGrammarParser.COMMA: + self.state = 62 + self.match(OmegaConfGrammarParser.COMMA) + self.state = 63 + self.dictKeyValuePair() + self.state = 68 + self._errHandler.sync(self) + _la = self._input.LA(1) + + + + self.state = 71 + self.match(OmegaConfGrammarParser.BRACE_CLOSE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DictKeyValuePairContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dictKey(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.DictKeyContext,0) + + + def COLON(self): + return self.getToken(OmegaConfGrammarParser.COLON, 0) + + def element(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,0) + + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_dictKeyValuePair + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDictKeyValuePair" ): + listener.enterDictKeyValuePair(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDictKeyValuePair" ): + listener.exitDictKeyValuePair(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDictKeyValuePair" ): + return visitor.visitDictKeyValuePair(self) + else: + return visitor.visitChildren(self) + + + + + def dictKeyValuePair(self): + + localctx = OmegaConfGrammarParser.DictKeyValuePairContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_dictKeyValuePair) + try: + self.enterOuterAlt(localctx, 1) + self.state = 73 + self.dictKey() + self.state = 74 + self.match(OmegaConfGrammarParser.COLON) + self.state = 75 + self.element() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SequenceContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def element(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(OmegaConfGrammarParser.ElementContext) + else: + return self.getTypedRuleContext(OmegaConfGrammarParser.ElementContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.COMMA) + else: + return self.getToken(OmegaConfGrammarParser.COMMA, i) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_sequence + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSequence" ): + listener.enterSequence(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSequence" ): + listener.exitSequence(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSequence" ): + return visitor.visitSequence(self) + else: + return visitor.visitChildren(self) + + + + + def sequence(self): + + localctx = OmegaConfGrammarParser.SequenceContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_sequence) + self._la = 0 # Token type + try: + self.state = 95 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.BRACE_OPEN, OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, OmegaConfGrammarParser.BRACKET_OPEN, OmegaConfGrammarParser.COLON, OmegaConfGrammarParser.FLOAT, OmegaConfGrammarParser.INT, OmegaConfGrammarParser.BOOL, OmegaConfGrammarParser.NULL, OmegaConfGrammarParser.UNQUOTED_CHAR, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.ESC, OmegaConfGrammarParser.WS]: + self.enterOuterAlt(localctx, 1) + self.state = 77 + self.element() + self.state = 84 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==OmegaConfGrammarParser.COMMA: + self.state = 78 + self.match(OmegaConfGrammarParser.COMMA) + self.state = 80 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0): + self.state = 79 + self.element() + + + self.state = 86 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + elif token in [OmegaConfGrammarParser.COMMA]: + self.enterOuterAlt(localctx, 2) + self.state = 91 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 87 + self.match(OmegaConfGrammarParser.COMMA) + self.state = 89 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0): + self.state = 88 + self.element() + + + self.state = 93 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==OmegaConfGrammarParser.COMMA): + break + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InterpolationContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def interpolationNode(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationNodeContext,0) + + + def interpolationResolver(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationResolverContext,0) + + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_interpolation + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterpolation" ): + listener.enterInterpolation(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterpolation" ): + listener.exitInterpolation(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInterpolation" ): + return visitor.visitInterpolation(self) + else: + return visitor.visitChildren(self) + + + + + def interpolation(self): + + localctx = OmegaConfGrammarParser.InterpolationContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_interpolation) + try: + self.state = 99 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,11,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 97 + self.interpolationNode() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 98 + self.interpolationResolver() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InterpolationNodeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTER_OPEN(self): + return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0) + + def INTER_CLOSE(self): + return self.getToken(OmegaConfGrammarParser.INTER_CLOSE, 0) + + def configKey(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(OmegaConfGrammarParser.ConfigKeyContext) + else: + return self.getTypedRuleContext(OmegaConfGrammarParser.ConfigKeyContext,i) + + + def BRACKET_OPEN(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.BRACKET_OPEN) + else: + return self.getToken(OmegaConfGrammarParser.BRACKET_OPEN, i) + + def BRACKET_CLOSE(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.BRACKET_CLOSE) + else: + return self.getToken(OmegaConfGrammarParser.BRACKET_CLOSE, i) + + def DOT(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.DOT) + else: + return self.getToken(OmegaConfGrammarParser.DOT, i) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_interpolationNode + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterpolationNode" ): + listener.enterInterpolationNode(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterpolationNode" ): + listener.exitInterpolationNode(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInterpolationNode" ): + return visitor.visitInterpolationNode(self) + else: + return visitor.visitChildren(self) + + + + + def interpolationNode(self): + + localctx = OmegaConfGrammarParser.InterpolationNodeContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_interpolationNode) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 101 + self.match(OmegaConfGrammarParser.INTER_OPEN) + self.state = 105 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==OmegaConfGrammarParser.DOT: + self.state = 102 + self.match(OmegaConfGrammarParser.DOT) + self.state = 107 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 113 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.INTER_OPEN, OmegaConfGrammarParser.ID, OmegaConfGrammarParser.INTER_KEY]: + self.state = 108 + self.configKey() + pass + elif token in [OmegaConfGrammarParser.BRACKET_OPEN]: + self.state = 109 + self.match(OmegaConfGrammarParser.BRACKET_OPEN) + self.state = 110 + self.configKey() + self.state = 111 + self.match(OmegaConfGrammarParser.BRACKET_CLOSE) + pass + else: + raise NoViableAltException(self) + + self.state = 123 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==OmegaConfGrammarParser.BRACKET_OPEN or _la==OmegaConfGrammarParser.DOT: + self.state = 121 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.DOT]: + self.state = 115 + self.match(OmegaConfGrammarParser.DOT) + self.state = 116 + self.configKey() + pass + elif token in [OmegaConfGrammarParser.BRACKET_OPEN]: + self.state = 117 + self.match(OmegaConfGrammarParser.BRACKET_OPEN) + self.state = 118 + self.configKey() + self.state = 119 + self.match(OmegaConfGrammarParser.BRACKET_CLOSE) + pass + else: + raise NoViableAltException(self) + + self.state = 125 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 126 + self.match(OmegaConfGrammarParser.INTER_CLOSE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InterpolationResolverContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTER_OPEN(self): + return self.getToken(OmegaConfGrammarParser.INTER_OPEN, 0) + + def resolverName(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.ResolverNameContext,0) + + + def COLON(self): + return self.getToken(OmegaConfGrammarParser.COLON, 0) + + def BRACE_CLOSE(self): + return self.getToken(OmegaConfGrammarParser.BRACE_CLOSE, 0) + + def sequence(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.SequenceContext,0) + + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_interpolationResolver + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterpolationResolver" ): + listener.enterInterpolationResolver(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterpolationResolver" ): + listener.exitInterpolationResolver(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInterpolationResolver" ): + return visitor.visitInterpolationResolver(self) + else: + return visitor.visitChildren(self) + + + + + def interpolationResolver(self): + + localctx = OmegaConfGrammarParser.InterpolationResolverContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_interpolationResolver) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 128 + self.match(OmegaConfGrammarParser.INTER_OPEN) + self.state = 129 + self.resolverName() + self.state = 130 + self.match(OmegaConfGrammarParser.COLON) + self.state = 132 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.BRACE_OPEN) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_SINGLE) | (1 << OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE) | (1 << OmegaConfGrammarParser.COMMA) | (1 << OmegaConfGrammarParser.BRACKET_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0): + self.state = 131 + self.sequence() + + + self.state = 134 + self.match(OmegaConfGrammarParser.BRACE_CLOSE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ConfigKeyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def interpolation(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,0) + + + def ID(self): + return self.getToken(OmegaConfGrammarParser.ID, 0) + + def INTER_KEY(self): + return self.getToken(OmegaConfGrammarParser.INTER_KEY, 0) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_configKey + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConfigKey" ): + listener.enterConfigKey(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConfigKey" ): + listener.exitConfigKey(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitConfigKey" ): + return visitor.visitConfigKey(self) + else: + return visitor.visitChildren(self) + + + + + def configKey(self): + + localctx = OmegaConfGrammarParser.ConfigKeyContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_configKey) + try: + self.state = 139 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.INTER_OPEN]: + self.enterOuterAlt(localctx, 1) + self.state = 136 + self.interpolation() + pass + elif token in [OmegaConfGrammarParser.ID]: + self.enterOuterAlt(localctx, 2) + self.state = 137 + self.match(OmegaConfGrammarParser.ID) + pass + elif token in [OmegaConfGrammarParser.INTER_KEY]: + self.enterOuterAlt(localctx, 3) + self.state = 138 + self.match(OmegaConfGrammarParser.INTER_KEY) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ResolverNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def interpolation(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext) + else: + return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i) + + + def ID(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ID) + else: + return self.getToken(OmegaConfGrammarParser.ID, i) + + def DOT(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.DOT) + else: + return self.getToken(OmegaConfGrammarParser.DOT, i) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_resolverName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterResolverName" ): + listener.enterResolverName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitResolverName" ): + listener.exitResolverName(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitResolverName" ): + return visitor.visitResolverName(self) + else: + return visitor.visitChildren(self) + + + + + def resolverName(self): + + localctx = OmegaConfGrammarParser.ResolverNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_resolverName) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 143 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.INTER_OPEN]: + self.state = 141 + self.interpolation() + pass + elif token in [OmegaConfGrammarParser.ID]: + self.state = 142 + self.match(OmegaConfGrammarParser.ID) + pass + else: + raise NoViableAltException(self) + + self.state = 152 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==OmegaConfGrammarParser.DOT: + self.state = 145 + self.match(OmegaConfGrammarParser.DOT) + self.state = 148 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.INTER_OPEN]: + self.state = 146 + self.interpolation() + pass + elif token in [OmegaConfGrammarParser.ID]: + self.state = 147 + self.match(OmegaConfGrammarParser.ID) + pass + else: + raise NoViableAltException(self) + + self.state = 154 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class QuotedValueContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MATCHING_QUOTE_CLOSE(self): + return self.getToken(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE, 0) + + def QUOTE_OPEN_SINGLE(self): + return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_SINGLE, 0) + + def QUOTE_OPEN_DOUBLE(self): + return self.getToken(OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE, 0) + + def text(self): + return self.getTypedRuleContext(OmegaConfGrammarParser.TextContext,0) + + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_quotedValue + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQuotedValue" ): + listener.enterQuotedValue(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQuotedValue" ): + listener.exitQuotedValue(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitQuotedValue" ): + return visitor.visitQuotedValue(self) + else: + return visitor.visitChildren(self) + + + + + def quotedValue(self): + + localctx = OmegaConfGrammarParser.QuotedValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_quotedValue) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 155 + _la = self._input.LA(1) + if not(_la==OmegaConfGrammarParser.QUOTE_OPEN_SINGLE or _la==OmegaConfGrammarParser.QUOTE_OPEN_DOUBLE): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 157 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.ANY_STR) | (1 << OmegaConfGrammarParser.ESC_INTER) | (1 << OmegaConfGrammarParser.TOP_ESC) | (1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.QUOTED_ESC))) != 0): + self.state = 156 + self.text() + + + self.state = 159 + self.match(OmegaConfGrammarParser.MATCHING_QUOTE_CLOSE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PrimitiveContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ID(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ID) + else: + return self.getToken(OmegaConfGrammarParser.ID, i) + + def NULL(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.NULL) + else: + return self.getToken(OmegaConfGrammarParser.NULL, i) + + def INT(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.INT) + else: + return self.getToken(OmegaConfGrammarParser.INT, i) + + def FLOAT(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.FLOAT) + else: + return self.getToken(OmegaConfGrammarParser.FLOAT, i) + + def BOOL(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.BOOL) + else: + return self.getToken(OmegaConfGrammarParser.BOOL, i) + + def UNQUOTED_CHAR(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR) + else: + return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i) + + def COLON(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.COLON) + else: + return self.getToken(OmegaConfGrammarParser.COLON, i) + + def ESC(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ESC) + else: + return self.getToken(OmegaConfGrammarParser.ESC, i) + + def WS(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.WS) + else: + return self.getToken(OmegaConfGrammarParser.WS, i) + + def interpolation(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(OmegaConfGrammarParser.InterpolationContext) + else: + return self.getTypedRuleContext(OmegaConfGrammarParser.InterpolationContext,i) + + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_primitive + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPrimitive" ): + listener.enterPrimitive(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPrimitive" ): + listener.exitPrimitive(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPrimitive" ): + return visitor.visitPrimitive(self) + else: + return visitor.visitChildren(self) + + + + + def primitive(self): + + localctx = OmegaConfGrammarParser.PrimitiveContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_primitive) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 171 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 171 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [OmegaConfGrammarParser.ID]: + self.state = 161 + self.match(OmegaConfGrammarParser.ID) + pass + elif token in [OmegaConfGrammarParser.NULL]: + self.state = 162 + self.match(OmegaConfGrammarParser.NULL) + pass + elif token in [OmegaConfGrammarParser.INT]: + self.state = 163 + self.match(OmegaConfGrammarParser.INT) + pass + elif token in [OmegaConfGrammarParser.FLOAT]: + self.state = 164 + self.match(OmegaConfGrammarParser.FLOAT) + pass + elif token in [OmegaConfGrammarParser.BOOL]: + self.state = 165 + self.match(OmegaConfGrammarParser.BOOL) + pass + elif token in [OmegaConfGrammarParser.UNQUOTED_CHAR]: + self.state = 166 + self.match(OmegaConfGrammarParser.UNQUOTED_CHAR) + pass + elif token in [OmegaConfGrammarParser.COLON]: + self.state = 167 + self.match(OmegaConfGrammarParser.COLON) + pass + elif token in [OmegaConfGrammarParser.ESC]: + self.state = 168 + self.match(OmegaConfGrammarParser.ESC) + pass + elif token in [OmegaConfGrammarParser.WS]: + self.state = 169 + self.match(OmegaConfGrammarParser.WS) + pass + elif token in [OmegaConfGrammarParser.INTER_OPEN]: + self.state = 170 + self.interpolation() + pass + else: + raise NoViableAltException(self) + + self.state = 173 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.INTER_OPEN) | (1 << OmegaConfGrammarParser.COLON) | (1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DictKeyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ID(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ID) + else: + return self.getToken(OmegaConfGrammarParser.ID, i) + + def NULL(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.NULL) + else: + return self.getToken(OmegaConfGrammarParser.NULL, i) + + def INT(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.INT) + else: + return self.getToken(OmegaConfGrammarParser.INT, i) + + def FLOAT(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.FLOAT) + else: + return self.getToken(OmegaConfGrammarParser.FLOAT, i) + + def BOOL(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.BOOL) + else: + return self.getToken(OmegaConfGrammarParser.BOOL, i) + + def UNQUOTED_CHAR(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.UNQUOTED_CHAR) + else: + return self.getToken(OmegaConfGrammarParser.UNQUOTED_CHAR, i) + + def ESC(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.ESC) + else: + return self.getToken(OmegaConfGrammarParser.ESC, i) + + def WS(self, i:int=None): + if i is None: + return self.getTokens(OmegaConfGrammarParser.WS) + else: + return self.getToken(OmegaConfGrammarParser.WS, i) + + def getRuleIndex(self): + return OmegaConfGrammarParser.RULE_dictKey + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDictKey" ): + listener.enterDictKey(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDictKey" ): + listener.exitDictKey(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDictKey" ): + return visitor.visitDictKey(self) + else: + return visitor.visitChildren(self) + + + + + def dictKey(self): + + localctx = OmegaConfGrammarParser.DictKeyContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_dictKey) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 176 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 175 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 178 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << OmegaConfGrammarParser.FLOAT) | (1 << OmegaConfGrammarParser.INT) | (1 << OmegaConfGrammarParser.BOOL) | (1 << OmegaConfGrammarParser.NULL) | (1 << OmegaConfGrammarParser.UNQUOTED_CHAR) | (1 << OmegaConfGrammarParser.ID) | (1 << OmegaConfGrammarParser.ESC) | (1 << OmegaConfGrammarParser.WS))) != 0)): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserListener.py b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserListener.py new file mode 100644 index 0000000000000000000000000000000000000000..d149348181e910757b6a3d6388073b951fac4678 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserListener.py @@ -0,0 +1,156 @@ +# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .OmegaConfGrammarParser import OmegaConfGrammarParser +else: + from OmegaConfGrammarParser import OmegaConfGrammarParser + +# This class defines a complete listener for a parse tree produced by OmegaConfGrammarParser. +class OmegaConfGrammarParserListener(ParseTreeListener): + + # Enter a parse tree produced by OmegaConfGrammarParser#configValue. + def enterConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#configValue. + def exitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#singleElement. + def enterSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#singleElement. + def exitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#text. + def enterText(self, ctx:OmegaConfGrammarParser.TextContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#text. + def exitText(self, ctx:OmegaConfGrammarParser.TextContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#element. + def enterElement(self, ctx:OmegaConfGrammarParser.ElementContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#element. + def exitElement(self, ctx:OmegaConfGrammarParser.ElementContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#listContainer. + def enterListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#listContainer. + def exitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#dictContainer. + def enterDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#dictContainer. + def exitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair. + def enterDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair. + def exitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#sequence. + def enterSequence(self, ctx:OmegaConfGrammarParser.SequenceContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#sequence. + def exitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#interpolation. + def enterInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#interpolation. + def exitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#interpolationNode. + def enterInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#interpolationNode. + def exitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#interpolationResolver. + def enterInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#interpolationResolver. + def exitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#configKey. + def enterConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#configKey. + def exitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#resolverName. + def enterResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#resolverName. + def exitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#quotedValue. + def enterQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#quotedValue. + def exitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#primitive. + def enterPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#primitive. + def exitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext): + pass + + + # Enter a parse tree produced by OmegaConfGrammarParser#dictKey. + def enterDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext): + pass + + # Exit a parse tree produced by OmegaConfGrammarParser#dictKey. + def exitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext): + pass + + + +del OmegaConfGrammarParser \ No newline at end of file diff --git a/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserVisitor.py b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserVisitor.py new file mode 100644 index 0000000000000000000000000000000000000000..ed247dd92f6654d2c862e848204a4679cc23e3e3 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/grammar/gen/OmegaConfGrammarParserVisitor.py @@ -0,0 +1,93 @@ +# Generated from /tmp/build-via-sdist-fm63w174/omegaconf-2.3.0/omegaconf/grammar/OmegaConfGrammarParser.g4 by ANTLR 4.9.3 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .OmegaConfGrammarParser import OmegaConfGrammarParser +else: + from OmegaConfGrammarParser import OmegaConfGrammarParser + +# This class defines a complete generic visitor for a parse tree produced by OmegaConfGrammarParser. + +class OmegaConfGrammarParserVisitor(ParseTreeVisitor): + + # Visit a parse tree produced by OmegaConfGrammarParser#configValue. + def visitConfigValue(self, ctx:OmegaConfGrammarParser.ConfigValueContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#singleElement. + def visitSingleElement(self, ctx:OmegaConfGrammarParser.SingleElementContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#text. + def visitText(self, ctx:OmegaConfGrammarParser.TextContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#element. + def visitElement(self, ctx:OmegaConfGrammarParser.ElementContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#listContainer. + def visitListContainer(self, ctx:OmegaConfGrammarParser.ListContainerContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#dictContainer. + def visitDictContainer(self, ctx:OmegaConfGrammarParser.DictContainerContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#dictKeyValuePair. + def visitDictKeyValuePair(self, ctx:OmegaConfGrammarParser.DictKeyValuePairContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#sequence. + def visitSequence(self, ctx:OmegaConfGrammarParser.SequenceContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#interpolation. + def visitInterpolation(self, ctx:OmegaConfGrammarParser.InterpolationContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#interpolationNode. + def visitInterpolationNode(self, ctx:OmegaConfGrammarParser.InterpolationNodeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#interpolationResolver. + def visitInterpolationResolver(self, ctx:OmegaConfGrammarParser.InterpolationResolverContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#configKey. + def visitConfigKey(self, ctx:OmegaConfGrammarParser.ConfigKeyContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#resolverName. + def visitResolverName(self, ctx:OmegaConfGrammarParser.ResolverNameContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#quotedValue. + def visitQuotedValue(self, ctx:OmegaConfGrammarParser.QuotedValueContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#primitive. + def visitPrimitive(self, ctx:OmegaConfGrammarParser.PrimitiveContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by OmegaConfGrammarParser#dictKey. + def visitDictKey(self, ctx:OmegaConfGrammarParser.DictKeyContext): + return self.visitChildren(ctx) + + + +del OmegaConfGrammarParser \ No newline at end of file diff --git a/runtime/Lib/site-packages/omegaconf/grammar/gen/__init__.py b/runtime/Lib/site-packages/omegaconf/grammar/gen/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/runtime/Lib/site-packages/omegaconf/grammar_parser.py b/runtime/Lib/site-packages/omegaconf/grammar_parser.py new file mode 100644 index 0000000000000000000000000000000000000000..3c883c2cfd49b442a90bda0c7777cccca706e82d --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/grammar_parser.py @@ -0,0 +1,144 @@ +import re +import threading +from typing import Any + +from antlr4 import CommonTokenStream, InputStream, ParserRuleContext +from antlr4.error.ErrorListener import ErrorListener + +from .errors import GrammarParseError + +# Import from visitor in order to check the presence of generated grammar files +# files in a single place. +from .grammar_visitor import ( # type: ignore + OmegaConfGrammarLexer, + OmegaConfGrammarParser, +) + +# Used to cache grammar objects to avoid re-creating them on each call to `parse()`. +# We use a per-thread cache to make it thread-safe. +_grammar_cache = threading.local() + +# Build regex pattern to efficiently identify typical interpolations. +# See test `test_match_simple_interpolation_pattern` for examples. +_config_key = r"[$\w]+" # foo, $0, $bar, $foo_$bar123$ +_key_maybe_brackets = f"{_config_key}|\\[{_config_key}\\]" # foo, [foo], [$bar] +_node_access = f"\\.{_key_maybe_brackets}" # .foo, [foo], [$bar] +_node_path = f"(\\.)*({_key_maybe_brackets})({_node_access})*" # [foo].bar, .foo[bar] +_node_inter = f"\\${{\\s*{_node_path}\\s*}}" # node interpolation ${foo.bar} +_id = "[a-zA-Z_][\\w\\-]*" # foo, foo_bar, foo-bar, abc123 +_resolver_name = f"({_id}(\\.{_id})*)?" # foo, ns.bar3, ns_1.ns_2.b0z +_arg = r"[a-zA-Z_0-9/\-\+.$%*@?|]+" # string representing a resolver argument +_args = f"{_arg}(\\s*,\\s*{_arg})*" # list of resolver arguments +_resolver_inter = f"\\${{\\s*{_resolver_name}\\s*:\\s*{_args}?\\s*}}" # ${foo:bar} +_inter = f"({_node_inter}|{_resolver_inter})" # any kind of interpolation +_outer = "([^$]|\\$(?!{))+" # any character except $ (unless not followed by {) +SIMPLE_INTERPOLATION_PATTERN = re.compile( + f"({_outer})?({_inter}({_outer})?)+$", flags=re.ASCII +) +# NOTE: SIMPLE_INTERPOLATION_PATTERN must not generate false positive matches: +# it must not accept anything that isn't a valid interpolation (per the +# interpolation grammar defined in `omegaconf/grammar/*.g4`). + + +class OmegaConfErrorListener(ErrorListener): # type: ignore + def syntaxError( + self, + recognizer: Any, + offending_symbol: Any, + line: Any, + column: Any, + msg: Any, + e: Any, + ) -> None: + raise GrammarParseError(str(e) if msg is None else msg) from e + + def reportAmbiguity( + self, + recognizer: Any, + dfa: Any, + startIndex: Any, + stopIndex: Any, + exact: Any, + ambigAlts: Any, + configs: Any, + ) -> None: + raise GrammarParseError("ANTLR error: Ambiguity") # pragma: no cover + + def reportAttemptingFullContext( + self, + recognizer: Any, + dfa: Any, + startIndex: Any, + stopIndex: Any, + conflictingAlts: Any, + configs: Any, + ) -> None: + # Note: for now we raise an error to be safe. However this is mostly a + # performance warning, so in the future this may be relaxed if we need + # to change the grammar in such a way that this warning cannot be + # avoided (another option would be to switch to SLL parsing mode). + raise GrammarParseError( + "ANTLR error: Attempting Full Context" + ) # pragma: no cover + + def reportContextSensitivity( + self, + recognizer: Any, + dfa: Any, + startIndex: Any, + stopIndex: Any, + prediction: Any, + configs: Any, + ) -> None: + raise GrammarParseError("ANTLR error: ContextSensitivity") # pragma: no cover + + +def parse( + value: str, parser_rule: str = "configValue", lexer_mode: str = "DEFAULT_MODE" +) -> ParserRuleContext: + """ + Parse interpolated string `value` (and return the parse tree). + """ + l_mode = getattr(OmegaConfGrammarLexer, lexer_mode) + istream = InputStream(value) + + cached = getattr(_grammar_cache, "data", None) + if cached is None: + error_listener = OmegaConfErrorListener() + lexer = OmegaConfGrammarLexer(istream) + lexer.removeErrorListeners() + lexer.addErrorListener(error_listener) + lexer.mode(l_mode) + token_stream = CommonTokenStream(lexer) + parser = OmegaConfGrammarParser(token_stream) + parser.removeErrorListeners() + parser.addErrorListener(error_listener) + + # The two lines below could be enabled in the future if we decide to switch + # to SLL prediction mode. Warning though, it has not been fully tested yet! + # from antlr4 import PredictionMode + # parser._interp.predictionMode = PredictionMode.SLL + + # Note that although the input stream `istream` is implicitly cached within + # the lexer, it will be replaced by a new input next time the lexer is re-used. + _grammar_cache.data = lexer, token_stream, parser + + else: + lexer, token_stream, parser = cached + # Replace the old input stream with the new one. + lexer.inputStream = istream + # Initialize the lexer / token stream / parser to process the new input. + lexer.mode(l_mode) + token_stream.setTokenSource(lexer) + parser.reset() + + try: + return getattr(parser, parser_rule)() + except Exception as exc: + if type(exc) is Exception and str(exc) == "Empty Stack": + # This exception is raised by antlr when trying to pop a mode while + # no mode has been pushed. We convert it into an `GrammarParseError` + # to facilitate exception handling from the caller. + raise GrammarParseError("Empty Stack") + else: + raise diff --git a/runtime/Lib/site-packages/omegaconf/grammar_visitor.py b/runtime/Lib/site-packages/omegaconf/grammar_visitor.py new file mode 100644 index 0000000000000000000000000000000000000000..1771516dcf78bbc692512d58d4dea55850b957b7 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/grammar_visitor.py @@ -0,0 +1,392 @@ +import sys +import warnings +from itertools import zip_longest +from typing import ( + TYPE_CHECKING, + Any, + Callable, + Dict, + Generator, + List, + Optional, + Set, + Tuple, + Union, +) + +from antlr4 import TerminalNode + +from .errors import InterpolationResolutionError + +if TYPE_CHECKING: + from .base import Node # noqa F401 + +try: + from omegaconf.grammar.gen.OmegaConfGrammarLexer import OmegaConfGrammarLexer + from omegaconf.grammar.gen.OmegaConfGrammarParser import OmegaConfGrammarParser + from omegaconf.grammar.gen.OmegaConfGrammarParserVisitor import ( + OmegaConfGrammarParserVisitor, + ) + +except ModuleNotFoundError: # pragma: no cover + print( + "Error importing OmegaConf's generated parsers, run `python setup.py antlr` to regenerate.", + file=sys.stderr, + ) + sys.exit(1) + + +class GrammarVisitor(OmegaConfGrammarParserVisitor): + def __init__( + self, + node_interpolation_callback: Callable[ + [str, Optional[Set[int]]], + Optional["Node"], + ], + resolver_interpolation_callback: Callable[..., Any], + memo: Optional[Set[int]], + **kw: Dict[Any, Any], + ): + """ + Constructor. + + :param node_interpolation_callback: Callback function that is called when + needing to resolve a node interpolation. This function should take a single + string input which is the key's dot path (ex: `"foo.bar"`). + + :param resolver_interpolation_callback: Callback function that is called when + needing to resolve a resolver interpolation. This function should accept + three keyword arguments: `name` (str, the name of the resolver), + `args` (tuple, the inputs to the resolver), and `args_str` (tuple, + the string representation of the inputs to the resolver). + + :param kw: Additional keyword arguments to be forwarded to parent class. + """ + super().__init__(**kw) + self.node_interpolation_callback = node_interpolation_callback + self.resolver_interpolation_callback = resolver_interpolation_callback + self.memo = memo + + def aggregateResult(self, aggregate: List[Any], nextResult: Any) -> List[Any]: + raise NotImplementedError + + def defaultResult(self) -> List[Any]: + # Raising an exception because not currently used (like `aggregateResult()`). + raise NotImplementedError + + def visitConfigKey(self, ctx: OmegaConfGrammarParser.ConfigKeyContext) -> str: + from ._utils import _get_value + + # interpolation | ID | INTER_KEY + assert ctx.getChildCount() == 1 + child = ctx.getChild(0) + if isinstance(child, OmegaConfGrammarParser.InterpolationContext): + res = _get_value(self.visitInterpolation(child)) + if not isinstance(res, str): + raise InterpolationResolutionError( + f"The following interpolation is used to denote a config key and " + f"thus should return a string, but instead returned `{res}` of " + f"type `{type(res)}`: {ctx.getChild(0).getText()}" + ) + return res + else: + assert isinstance(child, TerminalNode) and isinstance( + child.symbol.text, str + ) + return child.symbol.text + + def visitConfigValue(self, ctx: OmegaConfGrammarParser.ConfigValueContext) -> Any: + # text EOF + assert ctx.getChildCount() == 2 + return self.visit(ctx.getChild(0)) + + def visitDictKey(self, ctx: OmegaConfGrammarParser.DictKeyContext) -> Any: + return self._createPrimitive(ctx) + + def visitDictContainer( + self, ctx: OmegaConfGrammarParser.DictContainerContext + ) -> Dict[Any, Any]: + # BRACE_OPEN (dictKeyValuePair (COMMA dictKeyValuePair)*)? BRACE_CLOSE + assert ctx.getChildCount() >= 2 + return dict( + self.visitDictKeyValuePair(ctx.getChild(i)) + for i in range(1, ctx.getChildCount() - 1, 2) + ) + + def visitElement(self, ctx: OmegaConfGrammarParser.ElementContext) -> Any: + # primitive | quotedValue | listContainer | dictContainer + assert ctx.getChildCount() == 1 + return self.visit(ctx.getChild(0)) + + def visitInterpolation( + self, ctx: OmegaConfGrammarParser.InterpolationContext + ) -> Any: + assert ctx.getChildCount() == 1 # interpolationNode | interpolationResolver + return self.visit(ctx.getChild(0)) + + def visitInterpolationNode( + self, ctx: OmegaConfGrammarParser.InterpolationNodeContext + ) -> Optional["Node"]: + # INTER_OPEN + # DOT* // relative interpolation? + # (configKey | BRACKET_OPEN configKey BRACKET_CLOSE) // foo, [foo] + # (DOT configKey | BRACKET_OPEN configKey BRACKET_CLOSE)* // .foo, [foo], .foo[bar], [foo].bar[baz] + # INTER_CLOSE; + + assert ctx.getChildCount() >= 3 + + inter_key_tokens = [] # parsed elements of the dot path + for child in ctx.getChildren(): + if isinstance(child, TerminalNode): + s = child.symbol + if s.type in [ + OmegaConfGrammarLexer.DOT, + OmegaConfGrammarLexer.BRACKET_OPEN, + OmegaConfGrammarLexer.BRACKET_CLOSE, + ]: + inter_key_tokens.append(s.text) + else: + assert s.type in ( + OmegaConfGrammarLexer.INTER_OPEN, + OmegaConfGrammarLexer.INTER_CLOSE, + ) + else: + assert isinstance(child, OmegaConfGrammarParser.ConfigKeyContext) + inter_key_tokens.append(self.visitConfigKey(child)) + + inter_key = "".join(inter_key_tokens) + return self.node_interpolation_callback(inter_key, self.memo) + + def visitInterpolationResolver( + self, ctx: OmegaConfGrammarParser.InterpolationResolverContext + ) -> Any: + + # INTER_OPEN resolverName COLON sequence? BRACE_CLOSE + assert 4 <= ctx.getChildCount() <= 5 + + resolver_name = self.visit(ctx.getChild(1)) + maybe_seq = ctx.getChild(3) + args = [] + args_str = [] + if isinstance(maybe_seq, TerminalNode): # means there are no args + assert maybe_seq.symbol.type == OmegaConfGrammarLexer.BRACE_CLOSE + else: + assert isinstance(maybe_seq, OmegaConfGrammarParser.SequenceContext) + for val, txt in self.visitSequence(maybe_seq): + args.append(val) + args_str.append(txt) + + return self.resolver_interpolation_callback( + name=resolver_name, + args=tuple(args), + args_str=tuple(args_str), + ) + + def visitDictKeyValuePair( + self, ctx: OmegaConfGrammarParser.DictKeyValuePairContext + ) -> Tuple[Any, Any]: + from ._utils import _get_value + + assert ctx.getChildCount() == 3 # dictKey COLON element + key = self.visit(ctx.getChild(0)) + colon = ctx.getChild(1) + assert ( + isinstance(colon, TerminalNode) + and colon.symbol.type == OmegaConfGrammarLexer.COLON + ) + value = _get_value(self.visitElement(ctx.getChild(2))) + return key, value + + def visitListContainer( + self, ctx: OmegaConfGrammarParser.ListContainerContext + ) -> List[Any]: + # BRACKET_OPEN sequence? BRACKET_CLOSE; + assert ctx.getChildCount() in (2, 3) + if ctx.getChildCount() == 2: + return [] + sequence = ctx.getChild(1) + assert isinstance(sequence, OmegaConfGrammarParser.SequenceContext) + return list(val for val, _ in self.visitSequence(sequence)) # ignore raw text + + def visitPrimitive(self, ctx: OmegaConfGrammarParser.PrimitiveContext) -> Any: + return self._createPrimitive(ctx) + + def visitQuotedValue(self, ctx: OmegaConfGrammarParser.QuotedValueContext) -> str: + # (QUOTE_OPEN_SINGLE | QUOTE_OPEN_DOUBLE) text? MATCHING_QUOTE_CLOSE + n = ctx.getChildCount() + assert n in [2, 3] + return str(self.visit(ctx.getChild(1))) if n == 3 else "" + + def visitResolverName(self, ctx: OmegaConfGrammarParser.ResolverNameContext) -> str: + from ._utils import _get_value + + # (interpolation | ID) (DOT (interpolation | ID))* + assert ctx.getChildCount() >= 1 + items = [] + for child in list(ctx.getChildren())[::2]: + if isinstance(child, TerminalNode): + assert child.symbol.type == OmegaConfGrammarLexer.ID + items.append(child.symbol.text) + else: + assert isinstance(child, OmegaConfGrammarParser.InterpolationContext) + item = _get_value(self.visitInterpolation(child)) + if not isinstance(item, str): + raise InterpolationResolutionError( + f"The name of a resolver must be a string, but the interpolation " + f"{child.getText()} resolved to `{item}` which is of type " + f"{type(item)}" + ) + items.append(item) + return ".".join(items) + + def visitSequence( + self, ctx: OmegaConfGrammarParser.SequenceContext + ) -> Generator[Any, None, None]: + from ._utils import _get_value + + # (element (COMMA element?)*) | (COMMA element?)+ + assert ctx.getChildCount() >= 1 + + # DEPRECATED: remove in 2.2 (revert #571) + def empty_str_warning() -> None: + txt = ctx.getText() + warnings.warn( + f"In the sequence `{txt}` some elements are missing: please replace " + f"them with empty quoted strings. " + f"See https://github.com/omry/omegaconf/issues/572 for details.", + category=UserWarning, + ) + + is_previous_comma = True # whether previous child was a comma (init to True) + for child in ctx.getChildren(): + if isinstance(child, OmegaConfGrammarParser.ElementContext): + # Also preserve the original text representation of `child` so + # as to allow backward compatibility with old resolvers (registered + # with `legacy_register_resolver()`). Note that we cannot just cast + # the value to string later as for instance `null` would become "None". + yield _get_value(self.visitElement(child)), child.getText() + is_previous_comma = False + else: + assert ( + isinstance(child, TerminalNode) + and child.symbol.type == OmegaConfGrammarLexer.COMMA + ) + if is_previous_comma: + empty_str_warning() + yield "", "" + else: + is_previous_comma = True + if is_previous_comma: + # Trailing comma. + empty_str_warning() + yield "", "" + + def visitSingleElement( + self, ctx: OmegaConfGrammarParser.SingleElementContext + ) -> Any: + # element EOF + assert ctx.getChildCount() == 2 + return self.visit(ctx.getChild(0)) + + def visitText(self, ctx: OmegaConfGrammarParser.TextContext) -> Any: + # (interpolation | ANY_STR | ESC | ESC_INTER | TOP_ESC | QUOTED_ESC)+ + + # Single interpolation? If yes, return its resolved value "as is". + if ctx.getChildCount() == 1: + c = ctx.getChild(0) + if isinstance(c, OmegaConfGrammarParser.InterpolationContext): + return self.visitInterpolation(c) + + # Otherwise, concatenate string representations together. + return self._unescape(list(ctx.getChildren())) + + def _createPrimitive( + self, + ctx: Union[ + OmegaConfGrammarParser.PrimitiveContext, + OmegaConfGrammarParser.DictKeyContext, + ], + ) -> Any: + # (ID | NULL | INT | FLOAT | BOOL | UNQUOTED_CHAR | COLON | ESC | WS | interpolation)+ + if ctx.getChildCount() == 1: + child = ctx.getChild(0) + if isinstance(child, OmegaConfGrammarParser.InterpolationContext): + return self.visitInterpolation(child) + assert isinstance(child, TerminalNode) + symbol = child.symbol + # Parse primitive types. + if symbol.type in ( + OmegaConfGrammarLexer.ID, + OmegaConfGrammarLexer.UNQUOTED_CHAR, + OmegaConfGrammarLexer.COLON, + ): + return symbol.text + elif symbol.type == OmegaConfGrammarLexer.NULL: + return None + elif symbol.type == OmegaConfGrammarLexer.INT: + return int(symbol.text) + elif symbol.type == OmegaConfGrammarLexer.FLOAT: + return float(symbol.text) + elif symbol.type == OmegaConfGrammarLexer.BOOL: + return symbol.text.lower() == "true" + elif symbol.type == OmegaConfGrammarLexer.ESC: + return self._unescape([child]) + elif symbol.type == OmegaConfGrammarLexer.WS: # pragma: no cover + # A single WS should have been "consumed" by another token. + raise AssertionError("WS should never be reached") + assert False, symbol.type + # Concatenation of multiple items ==> un-escape the concatenation. + return self._unescape(list(ctx.getChildren())) + + def _unescape( + self, + seq: List[Union[TerminalNode, OmegaConfGrammarParser.InterpolationContext]], + ) -> str: + """ + Concatenate all symbols / interpolations in `seq`, unescaping symbols as needed. + + Interpolations are resolved and cast to string *WITHOUT* escaping their result + (it is assumed that whatever escaping is required was already handled during the + resolving of the interpolation). + """ + chrs = [] + for node, next_node in zip_longest(seq, seq[1:]): + if isinstance(node, TerminalNode): + s = node.symbol + if s.type == OmegaConfGrammarLexer.ESC_INTER: + # `ESC_INTER` is of the form `\\...\${`: the formula below computes + # the number of characters to keep at the end of the string to remove + # the correct number of backslashes. + text = s.text[-(len(s.text) // 2 + 1) :] + elif ( + # Character sequence identified as requiring un-escaping. + s.type == OmegaConfGrammarLexer.ESC + or ( + # At top level, we need to un-escape backslashes that precede + # an interpolation. + s.type == OmegaConfGrammarLexer.TOP_ESC + and isinstance( + next_node, OmegaConfGrammarParser.InterpolationContext + ) + ) + or ( + # In a quoted sring, we need to un-escape backslashes that + # either end the string, or are followed by an interpolation. + s.type == OmegaConfGrammarLexer.QUOTED_ESC + and ( + next_node is None + or isinstance( + next_node, OmegaConfGrammarParser.InterpolationContext + ) + ) + ) + ): + text = s.text[1::2] # un-escape the sequence + else: + text = s.text # keep the original text + else: + assert isinstance(node, OmegaConfGrammarParser.InterpolationContext) + text = str(self.visitInterpolation(node)) + chrs.append(text) + + return "".join(chrs) diff --git a/runtime/Lib/site-packages/omegaconf/listconfig.py b/runtime/Lib/site-packages/omegaconf/listconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..c3b0f18a4e1cc69f033fec788fe674a2c81dc700 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/listconfig.py @@ -0,0 +1,679 @@ +import copy +import itertools +from typing import ( + Any, + Callable, + Dict, + Iterable, + Iterator, + List, + MutableSequence, + Optional, + Tuple, + Type, + Union, +) + +from ._utils import ( + ValueKind, + _is_missing_literal, + _is_none, + _resolve_optional, + format_and_raise, + get_value_kind, + is_int, + is_primitive_list, + is_structured_config, + type_str, +) +from .base import Box, ContainerMetadata, Node +from .basecontainer import BaseContainer +from .errors import ( + ConfigAttributeError, + ConfigTypeError, + ConfigValueError, + KeyValidationError, + MissingMandatoryValue, + ReadonlyConfigError, + ValidationError, +) + + +class ListConfig(BaseContainer, MutableSequence[Any]): + + _content: Union[List[Node], None, str] + + def __init__( + self, + content: Union[List[Any], Tuple[Any, ...], "ListConfig", str, None], + key: Any = None, + parent: Optional[Box] = None, + element_type: Union[Type[Any], Any] = Any, + is_optional: bool = True, + ref_type: Union[Type[Any], Any] = Any, + flags: Optional[Dict[str, bool]] = None, + ) -> None: + try: + if isinstance(content, ListConfig): + if flags is None: + flags = content._metadata.flags + super().__init__( + parent=parent, + metadata=ContainerMetadata( + ref_type=ref_type, + object_type=list, + key=key, + optional=is_optional, + element_type=element_type, + key_type=int, + flags=flags, + ), + ) + + if isinstance(content, ListConfig): + metadata = copy.deepcopy(content._metadata) + metadata.key = key + metadata.ref_type = ref_type + metadata.optional = is_optional + metadata.element_type = element_type + self.__dict__["_metadata"] = metadata + self._set_value(value=content, flags=flags) + except Exception as ex: + format_and_raise(node=None, key=key, value=None, cause=ex, msg=str(ex)) + + def _validate_get(self, key: Any, value: Any = None) -> None: + if not isinstance(key, (int, slice)): + raise KeyValidationError( + "ListConfig indices must be integers or slices, not $KEY_TYPE" + ) + + def _validate_set(self, key: Any, value: Any) -> None: + from omegaconf import OmegaConf + + self._validate_get(key, value) + + if self._get_flag("readonly"): + raise ReadonlyConfigError("ListConfig is read-only") + + if 0 <= key < self.__len__(): + target = self._get_node(key) + if target is not None: + assert isinstance(target, Node) + if value is None and not target._is_optional(): + raise ValidationError( + "$FULL_KEY is not optional and cannot be assigned None" + ) + + vk = get_value_kind(value) + if vk == ValueKind.MANDATORY_MISSING: + return + else: + is_optional, target_type = _resolve_optional(self._metadata.element_type) + value_type = OmegaConf.get_type(value) + + if (value_type is None and not is_optional) or ( + is_structured_config(target_type) + and value_type is not None + and not issubclass(value_type, target_type) + ): + msg = ( + f"Invalid type assigned: {type_str(value_type)} is not a " + f"subclass of {type_str(target_type)}. value: {value}" + ) + raise ValidationError(msg) + + def __deepcopy__(self, memo: Dict[int, Any]) -> "ListConfig": + res = ListConfig(None) + res.__dict__["_metadata"] = copy.deepcopy(self.__dict__["_metadata"], memo=memo) + res.__dict__["_flags_cache"] = copy.deepcopy( + self.__dict__["_flags_cache"], memo=memo + ) + + src_content = self.__dict__["_content"] + if isinstance(src_content, list): + content_copy: List[Optional[Node]] = [] + for v in src_content: + old_parent = v.__dict__["_parent"] + try: + v.__dict__["_parent"] = None + vc = copy.deepcopy(v, memo=memo) + vc.__dict__["_parent"] = res + content_copy.append(vc) + finally: + v.__dict__["_parent"] = old_parent + else: + # None and strings can be assigned as is + content_copy = src_content + + res.__dict__["_content"] = content_copy + res.__dict__["_parent"] = self.__dict__["_parent"] + + return res + + def copy(self) -> "ListConfig": + return copy.copy(self) + + # hide content while inspecting in debugger + def __dir__(self) -> Iterable[str]: + if self._is_missing() or self._is_none(): + return [] + return [str(x) for x in range(0, len(self))] + + def __setattr__(self, key: str, value: Any) -> None: + self._format_and_raise( + key=key, + value=value, + cause=ConfigAttributeError("ListConfig does not support attribute access"), + ) + assert False + + def __getattr__(self, key: str) -> Any: + # PyCharm is sometimes inspecting __members__, be sure to tell it we don't have that. + if key == "__members__": + raise AttributeError() + + if key == "__name__": + raise AttributeError() + + if is_int(key): + return self.__getitem__(int(key)) + else: + self._format_and_raise( + key=key, + value=None, + cause=ConfigAttributeError( + "ListConfig does not support attribute access" + ), + ) + + def __getitem__(self, index: Union[int, slice]) -> Any: + try: + if self._is_missing(): + raise MissingMandatoryValue("ListConfig is missing") + self._validate_get(index, None) + if self._is_none(): + raise TypeError( + "ListConfig object representing None is not subscriptable" + ) + + assert isinstance(self.__dict__["_content"], list) + if isinstance(index, slice): + result = [] + start, stop, step = self._correct_index_params(index) + for slice_idx in itertools.islice( + range(0, len(self)), start, stop, step + ): + val = self._resolve_with_default( + key=slice_idx, value=self.__dict__["_content"][slice_idx] + ) + result.append(val) + if index.step and index.step < 0: + result.reverse() + return result + else: + return self._resolve_with_default( + key=index, value=self.__dict__["_content"][index] + ) + except Exception as e: + self._format_and_raise(key=index, value=None, cause=e) + + def _correct_index_params(self, index: slice) -> Tuple[int, int, int]: + start = index.start + stop = index.stop + step = index.step + if index.start and index.start < 0: + start = self.__len__() + index.start + if index.stop and index.stop < 0: + stop = self.__len__() + index.stop + if index.step and index.step < 0: + step = abs(step) + if start and stop: + if start > stop: + start, stop = stop + 1, start + 1 + else: + start = stop = 0 + elif not start and stop: + start = list(range(self.__len__() - 1, stop, -step))[0] + stop = None + elif start and not stop: + stop = start + 1 + start = (stop - 1) % step + else: + start = (self.__len__() - 1) % step + return start, stop, step + + def _set_at_index(self, index: Union[int, slice], value: Any) -> None: + self._set_item_impl(index, value) + + def __setitem__(self, index: Union[int, slice], value: Any) -> None: + try: + if isinstance(index, slice): + _ = iter(value) # check iterable + self_indices = index.indices(len(self)) + indexes = range(*self_indices) + + # Ensure lengths match for extended slice assignment + if index.step not in (None, 1): + if len(indexes) != len(value): + raise ValueError( + f"attempt to assign sequence of size {len(value)}" + f" to extended slice of size {len(indexes)}" + ) + + # Initialize insertion offsets for empty slices + if len(indexes) == 0: + curr_index = self_indices[0] - 1 + val_i = -1 + + work_copy = self.copy() # For atomicity manipulate a copy + + # Delete and optionally replace non empty slices + only_removed = 0 + for val_i, i in enumerate(indexes): + curr_index = i - only_removed + del work_copy[curr_index] + if val_i < len(value): + work_copy.insert(curr_index, value[val_i]) + else: + only_removed += 1 + + # Insert any remaining input items + for val_i in range(val_i + 1, len(value)): + curr_index += 1 + work_copy.insert(curr_index, value[val_i]) + + # Reinitialize self with work_copy + self.clear() + self.extend(work_copy) + else: + self._set_at_index(index, value) + except Exception as e: + self._format_and_raise(key=index, value=value, cause=e) + + def append(self, item: Any) -> None: + content = self.__dict__["_content"] + index = len(content) + content.append(None) + try: + self._set_item_impl(index, item) + except Exception as e: + del content[index] + self._format_and_raise(key=index, value=item, cause=e) + assert False + + def _update_keys(self) -> None: + for i in range(len(self)): + node = self._get_node(i) + if node is not None: + assert isinstance(node, Node) + node._metadata.key = i + + def insert(self, index: int, item: Any) -> None: + from omegaconf.omegaconf import _maybe_wrap + + try: + if self._get_flag("readonly"): + raise ReadonlyConfigError("Cannot insert into a read-only ListConfig") + if self._is_none(): + raise TypeError( + "Cannot insert into ListConfig object representing None" + ) + if self._is_missing(): + raise MissingMandatoryValue("Cannot insert into missing ListConfig") + + try: + assert isinstance(self.__dict__["_content"], list) + # insert place holder + self.__dict__["_content"].insert(index, None) + is_optional, ref_type = _resolve_optional(self._metadata.element_type) + node = _maybe_wrap( + ref_type=ref_type, + key=index, + value=item, + is_optional=is_optional, + parent=self, + ) + self._validate_set(key=index, value=node) + self._set_at_index(index, node) + self._update_keys() + except Exception: + del self.__dict__["_content"][index] + self._update_keys() + raise + except Exception as e: + self._format_and_raise(key=index, value=item, cause=e) + assert False + + def extend(self, lst: Iterable[Any]) -> None: + assert isinstance(lst, (tuple, list, ListConfig)) + for x in lst: + self.append(x) + + def remove(self, x: Any) -> None: + del self[self.index(x)] + + def __delitem__(self, key: Union[int, slice]) -> None: + if self._get_flag("readonly"): + self._format_and_raise( + key=key, + value=None, + cause=ReadonlyConfigError( + "Cannot delete item from read-only ListConfig" + ), + ) + del self.__dict__["_content"][key] + self._update_keys() + + def clear(self) -> None: + del self[:] + + def index( + self, x: Any, start: Optional[int] = None, end: Optional[int] = None + ) -> int: + if start is None: + start = 0 + if end is None: + end = len(self) + assert start >= 0 + assert end <= len(self) + found_idx = -1 + for idx in range(start, end): + item = self[idx] + if x == item: + found_idx = idx + break + if found_idx != -1: + return found_idx + else: + self._format_and_raise( + key=None, + value=None, + cause=ConfigValueError("Item not found in ListConfig"), + ) + assert False + + def count(self, x: Any) -> int: + c = 0 + for item in self: + if item == x: + c = c + 1 + return c + + def _get_node( + self, + key: Union[int, slice], + validate_access: bool = True, + validate_key: bool = True, + throw_on_missing_value: bool = False, + throw_on_missing_key: bool = False, + ) -> Union[Optional[Node], List[Optional[Node]]]: + try: + if self._is_none(): + raise TypeError( + "Cannot get_node from a ListConfig object representing None" + ) + if self._is_missing(): + raise MissingMandatoryValue("Cannot get_node from a missing ListConfig") + assert isinstance(self.__dict__["_content"], list) + if validate_access: + self._validate_get(key) + + value = self.__dict__["_content"][key] + if value is not None: + if isinstance(key, slice): + assert isinstance(value, list) + for v in value: + if throw_on_missing_value and v._is_missing(): + raise MissingMandatoryValue("Missing mandatory value") + else: + assert isinstance(value, Node) + if throw_on_missing_value and value._is_missing(): + raise MissingMandatoryValue("Missing mandatory value: $KEY") + return value + except (IndexError, TypeError, MissingMandatoryValue, KeyValidationError) as e: + if isinstance(e, MissingMandatoryValue) and throw_on_missing_value: + raise + if validate_access: + self._format_and_raise(key=key, value=None, cause=e) + assert False + else: + return None + + def get(self, index: int, default_value: Any = None) -> Any: + try: + if self._is_none(): + raise TypeError("Cannot get from a ListConfig object representing None") + if self._is_missing(): + raise MissingMandatoryValue("Cannot get from a missing ListConfig") + self._validate_get(index, None) + assert isinstance(self.__dict__["_content"], list) + return self._resolve_with_default( + key=index, + value=self.__dict__["_content"][index], + default_value=default_value, + ) + except Exception as e: + self._format_and_raise(key=index, value=None, cause=e) + assert False + + def pop(self, index: int = -1) -> Any: + try: + if self._get_flag("readonly"): + raise ReadonlyConfigError("Cannot pop from read-only ListConfig") + if self._is_none(): + raise TypeError("Cannot pop from a ListConfig object representing None") + if self._is_missing(): + raise MissingMandatoryValue("Cannot pop from a missing ListConfig") + + assert isinstance(self.__dict__["_content"], list) + node = self._get_child(index) + assert isinstance(node, Node) + ret = self._resolve_with_default(key=index, value=node, default_value=None) + del self.__dict__["_content"][index] + self._update_keys() + return ret + except KeyValidationError as e: + self._format_and_raise( + key=index, value=None, cause=e, type_override=ConfigTypeError + ) + assert False + except Exception as e: + self._format_and_raise(key=index, value=None, cause=e) + assert False + + def sort( + self, key: Optional[Callable[[Any], Any]] = None, reverse: bool = False + ) -> None: + try: + if self._get_flag("readonly"): + raise ReadonlyConfigError("Cannot sort a read-only ListConfig") + if self._is_none(): + raise TypeError("Cannot sort a ListConfig object representing None") + if self._is_missing(): + raise MissingMandatoryValue("Cannot sort a missing ListConfig") + + if key is None: + + def key1(x: Any) -> Any: + return x._value() + + else: + + def key1(x: Any) -> Any: + return key(x._value()) # type: ignore + + assert isinstance(self.__dict__["_content"], list) + self.__dict__["_content"].sort(key=key1, reverse=reverse) + + except Exception as e: + self._format_and_raise(key=None, value=None, cause=e) + assert False + + def __eq__(self, other: Any) -> bool: + if isinstance(other, (list, tuple)) or other is None: + other = ListConfig(other, flags={"allow_objects": True}) + return ListConfig._list_eq(self, other) + if other is None or isinstance(other, ListConfig): + return ListConfig._list_eq(self, other) + if self._is_missing(): + return _is_missing_literal(other) + return NotImplemented + + def __ne__(self, other: Any) -> bool: + x = self.__eq__(other) + if x is not NotImplemented: + return not x + return NotImplemented + + def __hash__(self) -> int: + return hash(str(self)) + + def __iter__(self) -> Iterator[Any]: + return self._iter_ex(resolve=True) + + class ListIterator(Iterator[Any]): + def __init__(self, lst: Any, resolve: bool) -> None: + self.resolve = resolve + self.iterator = iter(lst.__dict__["_content"]) + self.index = 0 + from .nodes import ValueNode + + self.ValueNode = ValueNode + + def __next__(self) -> Any: + + x = next(self.iterator) + if self.resolve: + x = x._dereference_node() + if x._is_missing(): + raise MissingMandatoryValue(f"Missing value at index {self.index}") + + self.index = self.index + 1 + if isinstance(x, self.ValueNode): + return x._value() + else: + # Must be omegaconf.Container. not checking for perf reasons. + if x._is_none(): + return None + return x + + def __repr__(self) -> str: # pragma: no cover + return f"ListConfig.ListIterator(resolve={self.resolve})" + + def _iter_ex(self, resolve: bool) -> Iterator[Any]: + try: + if self._is_none(): + raise TypeError("Cannot iterate a ListConfig object representing None") + if self._is_missing(): + raise MissingMandatoryValue("Cannot iterate a missing ListConfig") + + return ListConfig.ListIterator(self, resolve) + except (TypeError, MissingMandatoryValue) as e: + self._format_and_raise(key=None, value=None, cause=e) + assert False + + def __add__(self, other: Union[List[Any], "ListConfig"]) -> "ListConfig": + # res is sharing this list's parent to allow interpolation to work as expected + res = ListConfig(parent=self._get_parent(), content=[]) + res.extend(self) + res.extend(other) + return res + + def __radd__(self, other: Union[List[Any], "ListConfig"]) -> "ListConfig": + # res is sharing this list's parent to allow interpolation to work as expected + res = ListConfig(parent=self._get_parent(), content=[]) + res.extend(other) + res.extend(self) + return res + + def __iadd__(self, other: Iterable[Any]) -> "ListConfig": + self.extend(other) + return self + + def __contains__(self, item: Any) -> bool: + if self._is_none(): + raise TypeError( + "Cannot check if an item is in a ListConfig object representing None" + ) + if self._is_missing(): + raise MissingMandatoryValue( + "Cannot check if an item is in missing ListConfig" + ) + + lst = self.__dict__["_content"] + for x in lst: + x = x._dereference_node() + if x == item: + return True + return False + + def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None: + try: + previous_content = self.__dict__["_content"] + previous_metadata = self.__dict__["_metadata"] + self._set_value_impl(value, flags) + except Exception as e: + self.__dict__["_content"] = previous_content + self.__dict__["_metadata"] = previous_metadata + raise e + + def _set_value_impl( + self, value: Any, flags: Optional[Dict[str, bool]] = None + ) -> None: + from omegaconf import MISSING, flag_override + + if flags is None: + flags = {} + + vk = get_value_kind(value, strict_interpolation_validation=True) + if _is_none(value): + if not self._is_optional(): + raise ValidationError( + "Non optional ListConfig cannot be constructed from None" + ) + self.__dict__["_content"] = None + self._metadata.object_type = None + elif vk is ValueKind.MANDATORY_MISSING: + self.__dict__["_content"] = MISSING + self._metadata.object_type = None + elif vk == ValueKind.INTERPOLATION: + self.__dict__["_content"] = value + self._metadata.object_type = None + else: + if not (is_primitive_list(value) or isinstance(value, ListConfig)): + type_ = type(value) + msg = f"Invalid value assigned: {type_.__name__} is not a ListConfig, list or tuple." + raise ValidationError(msg) + + self.__dict__["_content"] = [] + if isinstance(value, ListConfig): + self._metadata.flags = copy.deepcopy(flags) + # disable struct and readonly for the construction phase + # retaining other flags like allow_objects. The real flags are restored at the end of this function + with flag_override(self, ["struct", "readonly"], False): + for item in value._iter_ex(resolve=False): + self.append(item) + elif is_primitive_list(value): + with flag_override(self, ["struct", "readonly"], False): + for item in value: + self.append(item) + self._metadata.object_type = list + + @staticmethod + def _list_eq(l1: Optional["ListConfig"], l2: Optional["ListConfig"]) -> bool: + l1_none = l1.__dict__["_content"] is None + l2_none = l2.__dict__["_content"] is None + if l1_none and l2_none: + return True + if l1_none != l2_none: + return False + + assert isinstance(l1, ListConfig) + assert isinstance(l2, ListConfig) + if len(l1) != len(l2): + return False + for i in range(len(l1)): + if not BaseContainer._item_eq(l1, i, l2, i): + return False + + return True diff --git a/runtime/Lib/site-packages/omegaconf/nodes.py b/runtime/Lib/site-packages/omegaconf/nodes.py new file mode 100644 index 0000000000000000000000000000000000000000..1f02cde65801fc9b7443595fc80bd8017dd8273b --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/nodes.py @@ -0,0 +1,545 @@ +import copy +import math +import sys +from abc import abstractmethod +from enum import Enum +from pathlib import Path +from typing import Any, Dict, Optional, Type, Union + +from omegaconf._utils import ( + ValueKind, + _is_interpolation, + get_type_of, + get_value_kind, + is_primitive_container, + type_str, +) +from omegaconf.base import Box, DictKeyType, Metadata, Node +from omegaconf.errors import ReadonlyConfigError, UnsupportedValueType, ValidationError + + +class ValueNode(Node): + _val: Any + + def __init__(self, parent: Optional[Box], value: Any, metadata: Metadata): + from omegaconf import read_write + + super().__init__(parent=parent, metadata=metadata) + with read_write(self): + self._set_value(value) # lgtm [py/init-calls-subclass] + + def _value(self) -> Any: + return self._val + + def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None: + if self._get_flag("readonly"): + raise ReadonlyConfigError("Cannot set value of read-only config node") + + if isinstance(value, str) and get_value_kind( + value, strict_interpolation_validation=True + ) in ( + ValueKind.INTERPOLATION, + ValueKind.MANDATORY_MISSING, + ): + self._val = value + else: + self._val = self.validate_and_convert(value) + + def _strict_validate_type(self, value: Any) -> None: + ref_type = self._metadata.ref_type + if isinstance(ref_type, type) and type(value) is not ref_type: + type_hint = type_str(self._metadata.type_hint) + raise ValidationError( + f"Value '$VALUE' of type '$VALUE_TYPE' is incompatible with type hint '{type_hint}'" + ) + + def validate_and_convert(self, value: Any) -> Any: + """ + Validates input and converts to canonical form + :param value: input value + :return: converted value ("100" may be converted to 100 for example) + """ + if value is None: + if self._is_optional(): + return None + ref_type_str = type_str(self._metadata.ref_type) + raise ValidationError( + f"Incompatible value '{value}' for field of type '{ref_type_str}'" + ) + + # Subclasses can assume that `value` is not None in + # `_validate_and_convert_impl()` and in `_strict_validate_type()`. + if self._get_flag("convert") is False: + self._strict_validate_type(value) + return value + else: + return self._validate_and_convert_impl(value) + + @abstractmethod + def _validate_and_convert_impl(self, value: Any) -> Any: + ... + + def __str__(self) -> str: + return str(self._val) + + def __repr__(self) -> str: + return repr(self._val) if hasattr(self, "_val") else "__INVALID__" + + def __eq__(self, other: Any) -> bool: + if isinstance(other, AnyNode): + return self._val == other._val # type: ignore + else: + return self._val == other # type: ignore + + def __ne__(self, other: Any) -> bool: + x = self.__eq__(other) + assert x is not NotImplemented + return not x + + def __hash__(self) -> int: + return hash(self._val) + + def _deepcopy_impl(self, res: Any, memo: Dict[int, Any]) -> None: + res.__dict__["_metadata"] = copy.deepcopy(self._metadata, memo=memo) + # shallow copy for value to support non-copyable value + res.__dict__["_val"] = self._val + + # parent is retained, but not copied + res.__dict__["_parent"] = self._parent + + def _is_optional(self) -> bool: + return self._metadata.optional + + def _is_interpolation(self) -> bool: + return _is_interpolation(self._value()) + + def _get_full_key(self, key: Optional[Union[DictKeyType, int]]) -> str: + parent = self._get_parent() + if parent is None: + if self._metadata.key is None: + return "" + else: + return str(self._metadata.key) + else: + return parent._get_full_key(self._metadata.key) + + +class AnyNode(ValueNode): + def __init__( + self, + value: Any = None, + key: Any = None, + parent: Optional[Box] = None, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + ref_type=Any, object_type=None, key=key, optional=True, flags=flags + ), + ) + + def _validate_and_convert_impl(self, value: Any) -> Any: + from ._utils import is_primitive_type_annotation + + # allow_objects is internal and not an official API. use at your own risk. + # Please be aware that this support is subject to change without notice. + # If this is deemed useful and supportable it may become an official API. + + if self._get_flag( + "allow_objects" + ) is not True and not is_primitive_type_annotation(value): + t = get_type_of(value) + raise UnsupportedValueType( + f"Value '{t.__name__}' is not a supported primitive type" + ) + return value + + def __deepcopy__(self, memo: Dict[int, Any]) -> "AnyNode": + res = AnyNode() + self._deepcopy_impl(res, memo) + return res + + +class StringNode(ValueNode): + def __init__( + self, + value: Any = None, + key: Any = None, + parent: Optional[Box] = None, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + key=key, + optional=is_optional, + ref_type=str, + object_type=str, + flags=flags, + ), + ) + + def _validate_and_convert_impl(self, value: Any) -> str: + from omegaconf import OmegaConf + + if ( + OmegaConf.is_config(value) + or is_primitive_container(value) + or isinstance(value, bytes) + ): + raise ValidationError("Cannot convert '$VALUE_TYPE' to string: '$VALUE'") + return str(value) + + def __deepcopy__(self, memo: Dict[int, Any]) -> "StringNode": + res = StringNode() + self._deepcopy_impl(res, memo) + return res + + +class PathNode(ValueNode): + def __init__( + self, + value: Any = None, + key: Any = None, + parent: Optional[Box] = None, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + key=key, + optional=is_optional, + ref_type=Path, + object_type=Path, + flags=flags, + ), + ) + + def _strict_validate_type(self, value: Any) -> None: + if not isinstance(value, Path): + raise ValidationError( + "Value '$VALUE' of type '$VALUE_TYPE' is not an instance of 'pathlib.Path'" + ) + + def _validate_and_convert_impl(self, value: Any) -> Path: + if not isinstance(value, (str, Path)): + raise ValidationError( + "Value '$VALUE' of type '$VALUE_TYPE' could not be converted to Path" + ) + + return Path(value) + + def __deepcopy__(self, memo: Dict[int, Any]) -> "PathNode": + res = PathNode() + self._deepcopy_impl(res, memo) + return res + + +class IntegerNode(ValueNode): + def __init__( + self, + value: Any = None, + key: Any = None, + parent: Optional[Box] = None, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + key=key, + optional=is_optional, + ref_type=int, + object_type=int, + flags=flags, + ), + ) + + def _validate_and_convert_impl(self, value: Any) -> int: + try: + if type(value) in (str, int): + val = int(value) + else: + raise ValueError() + except ValueError: + raise ValidationError( + "Value '$VALUE' of type '$VALUE_TYPE' could not be converted to Integer" + ) + return val + + def __deepcopy__(self, memo: Dict[int, Any]) -> "IntegerNode": + res = IntegerNode() + self._deepcopy_impl(res, memo) + return res + + +class BytesNode(ValueNode): + def __init__( + self, + value: Any = None, + key: Any = None, + parent: Optional[Box] = None, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + key=key, + optional=is_optional, + ref_type=bytes, + object_type=bytes, + flags=flags, + ), + ) + + def _validate_and_convert_impl(self, value: Any) -> bytes: + if not isinstance(value, bytes): + raise ValidationError( + "Value '$VALUE' of type '$VALUE_TYPE' is not of type 'bytes'" + ) + return value + + def __deepcopy__(self, memo: Dict[int, Any]) -> "BytesNode": + res = BytesNode() + self._deepcopy_impl(res, memo) + return res + + +class FloatNode(ValueNode): + def __init__( + self, + value: Any = None, + key: Any = None, + parent: Optional[Box] = None, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + key=key, + optional=is_optional, + ref_type=float, + object_type=float, + flags=flags, + ), + ) + + def _validate_and_convert_impl(self, value: Any) -> float: + try: + if type(value) in (float, str, int): + return float(value) + else: + raise ValueError() + except ValueError: + raise ValidationError( + "Value '$VALUE' of type '$VALUE_TYPE' could not be converted to Float" + ) + + def __eq__(self, other: Any) -> bool: + if isinstance(other, ValueNode): + other_val = other._val + else: + other_val = other + if self._val is None and other is None: + return True + if self._val is None and other is not None: + return False + if self._val is not None and other is None: + return False + nan1 = math.isnan(self._val) if isinstance(self._val, float) else False + nan2 = math.isnan(other_val) if isinstance(other_val, float) else False + return self._val == other_val or (nan1 and nan2) + + def __hash__(self) -> int: + return hash(self._val) + + def __deepcopy__(self, memo: Dict[int, Any]) -> "FloatNode": + res = FloatNode() + self._deepcopy_impl(res, memo) + return res + + +class BooleanNode(ValueNode): + def __init__( + self, + value: Any = None, + key: Any = None, + parent: Optional[Box] = None, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + key=key, + optional=is_optional, + ref_type=bool, + object_type=bool, + flags=flags, + ), + ) + + def _validate_and_convert_impl(self, value: Any) -> bool: + if isinstance(value, bool): + return value + if isinstance(value, int): + return value != 0 + elif isinstance(value, str): + try: + return self._validate_and_convert_impl(int(value)) + except ValueError as e: + if value.lower() in ("yes", "y", "on", "true"): + return True + elif value.lower() in ("no", "n", "off", "false"): + return False + else: + raise ValidationError( + "Value '$VALUE' is not a valid bool (type $VALUE_TYPE)" + ).with_traceback(sys.exc_info()[2]) from e + else: + raise ValidationError( + "Value '$VALUE' is not a valid bool (type $VALUE_TYPE)" + ) + + def __deepcopy__(self, memo: Dict[int, Any]) -> "BooleanNode": + res = BooleanNode() + self._deepcopy_impl(res, memo) + return res + + +class EnumNode(ValueNode): # lgtm [py/missing-equals] : Intentional. + """ + NOTE: EnumNode is serialized to yaml as a string ("Color.BLUE"), not as a fully qualified yaml type. + this means serialization to YAML of a typed config (with EnumNode) will not retain the type of the Enum + when loaded. + This is intentional, Please open an issue against OmegaConf if you wish to discuss this decision. + """ + + def __init__( + self, + enum_type: Type[Enum], + value: Optional[Union[Enum, str]] = None, + key: Any = None, + parent: Optional[Box] = None, + is_optional: bool = True, + flags: Optional[Dict[str, bool]] = None, + ): + if not isinstance(enum_type, type) or not issubclass(enum_type, Enum): + raise ValidationError( + f"EnumNode can only operate on Enum subclasses ({enum_type})" + ) + self.fields: Dict[str, str] = {} + self.enum_type: Type[Enum] = enum_type + for name, constant in enum_type.__members__.items(): + self.fields[name] = constant.value + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + key=key, + optional=is_optional, + ref_type=enum_type, + object_type=enum_type, + flags=flags, + ), + ) + + def _strict_validate_type(self, value: Any) -> None: + ref_type = self._metadata.ref_type + if not isinstance(value, ref_type): + type_hint = type_str(self._metadata.type_hint) + raise ValidationError( + f"Value '$VALUE' of type '$VALUE_TYPE' is incompatible with type hint '{type_hint}'" + ) + + def _validate_and_convert_impl(self, value: Any) -> Enum: + return self.validate_and_convert_to_enum(enum_type=self.enum_type, value=value) + + @staticmethod + def validate_and_convert_to_enum(enum_type: Type[Enum], value: Any) -> Enum: + if not isinstance(value, (str, int)) and not isinstance(value, enum_type): + raise ValidationError( + f"Value $VALUE ($VALUE_TYPE) is not a valid input for {enum_type}" + ) + + if isinstance(value, enum_type): + return value + + try: + if isinstance(value, (float, bool)): + raise ValueError + + if isinstance(value, int): + return enum_type(value) + + if isinstance(value, str): + prefix = f"{enum_type.__name__}." + if value.startswith(prefix): + value = value[len(prefix) :] + return enum_type[value] + + assert False + + except (ValueError, KeyError) as e: + valid = ", ".join([x for x in enum_type.__members__.keys()]) + raise ValidationError( + f"Invalid value '$VALUE', expected one of [{valid}]" + ).with_traceback(sys.exc_info()[2]) from e + + def __deepcopy__(self, memo: Dict[int, Any]) -> "EnumNode": + res = EnumNode(enum_type=self.enum_type) + self._deepcopy_impl(res, memo) + return res + + +class InterpolationResultNode(ValueNode): + """ + Special node type, used to wrap interpolation results. + """ + + def __init__( + self, + value: Any, + key: Any = None, + parent: Optional[Box] = None, + flags: Optional[Dict[str, bool]] = None, + ): + super().__init__( + parent=parent, + value=value, + metadata=Metadata( + ref_type=Any, object_type=None, key=key, optional=True, flags=flags + ), + ) + # In general we should not try to write into interpolation results. + if flags is None or "readonly" not in flags: + self._set_flag("readonly", True) + + def _set_value(self, value: Any, flags: Optional[Dict[str, bool]] = None) -> None: + if self._get_flag("readonly"): + raise ReadonlyConfigError("Cannot set value of read-only config node") + self._val = self.validate_and_convert(value) + + def _validate_and_convert_impl(self, value: Any) -> Any: + # Interpolation results may be anything. + return value + + def __deepcopy__(self, memo: Dict[int, Any]) -> "InterpolationResultNode": + # Currently there should be no need to deep-copy such nodes. + raise NotImplementedError + + def _is_interpolation(self) -> bool: + # The result of an interpolation cannot be itself an interpolation. + return False diff --git a/runtime/Lib/site-packages/omegaconf/omegaconf.py b/runtime/Lib/site-packages/omegaconf/omegaconf.py new file mode 100644 index 0000000000000000000000000000000000000000..efde14a4e266ede954c479c8809cdb8ab80cb2d5 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/omegaconf.py @@ -0,0 +1,1157 @@ +"""OmegaConf module""" +import copy +import inspect +import io +import os +import pathlib +import sys +import warnings +from collections import defaultdict +from contextlib import contextmanager +from enum import Enum +from textwrap import dedent +from typing import ( + IO, + Any, + Callable, + Dict, + Generator, + Iterable, + List, + Optional, + Set, + Tuple, + Type, + Union, + overload, +) + +import yaml + +from . import DictConfig, DictKeyType, ListConfig +from ._utils import ( + _DEFAULT_MARKER_, + _ensure_container, + _get_value, + format_and_raise, + get_dict_key_value_types, + get_list_element_type, + get_omega_conf_dumper, + get_type_of, + is_attr_class, + is_dataclass, + is_dict_annotation, + is_int, + is_list_annotation, + is_primitive_container, + is_primitive_dict, + is_primitive_list, + is_structured_config, + is_tuple_annotation, + is_union_annotation, + nullcontext, + split_key, + type_str, +) +from .base import Box, Container, Node, SCMode, UnionNode +from .basecontainer import BaseContainer +from .errors import ( + MissingMandatoryValue, + OmegaConfBaseException, + UnsupportedInterpolationType, + ValidationError, +) +from .nodes import ( + AnyNode, + BooleanNode, + BytesNode, + EnumNode, + FloatNode, + IntegerNode, + PathNode, + StringNode, + ValueNode, +) + +MISSING: Any = "???" + +Resolver = Callable[..., Any] + + +def II(interpolation: str) -> Any: + """ + Equivalent to ``${interpolation}`` + + :param interpolation: + :return: input ``${node}`` with type Any + """ + return "${" + interpolation + "}" + + +def SI(interpolation: str) -> Any: + """ + Use this for String interpolation, for example ``"http://${host}:${port}"`` + + :param interpolation: interpolation string + :return: input interpolation with type ``Any`` + """ + return interpolation + + +def register_default_resolvers() -> None: + from omegaconf.resolvers import oc + + OmegaConf.register_new_resolver("oc.create", oc.create) + OmegaConf.register_new_resolver("oc.decode", oc.decode) + OmegaConf.register_new_resolver("oc.deprecated", oc.deprecated) + OmegaConf.register_new_resolver("oc.env", oc.env) + OmegaConf.register_new_resolver("oc.select", oc.select) + OmegaConf.register_new_resolver("oc.dict.keys", oc.dict.keys) + OmegaConf.register_new_resolver("oc.dict.values", oc.dict.values) + + +class OmegaConf: + """OmegaConf primary class""" + + def __init__(self) -> None: + raise NotImplementedError("Use one of the static construction functions") + + @staticmethod + def structured( + obj: Any, + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> Any: + return OmegaConf.create(obj, parent, flags) + + @staticmethod + @overload + def create( + obj: str, + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> Union[DictConfig, ListConfig]: + ... + + @staticmethod + @overload + def create( + obj: Union[List[Any], Tuple[Any, ...]], + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> ListConfig: + ... + + @staticmethod + @overload + def create( + obj: DictConfig, + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> DictConfig: + ... + + @staticmethod + @overload + def create( + obj: ListConfig, + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> ListConfig: + ... + + @staticmethod + @overload + def create( + obj: Optional[Dict[Any, Any]] = None, + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> DictConfig: + ... + + @staticmethod + def create( # noqa F811 + obj: Any = _DEFAULT_MARKER_, + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> Union[DictConfig, ListConfig]: + return OmegaConf._create_impl( + obj=obj, + parent=parent, + flags=flags, + ) + + @staticmethod + def load(file_: Union[str, pathlib.Path, IO[Any]]) -> Union[DictConfig, ListConfig]: + from ._utils import get_yaml_loader + + if isinstance(file_, (str, pathlib.Path)): + with io.open(os.path.abspath(file_), "r", encoding="utf-8") as f: + obj = yaml.load(f, Loader=get_yaml_loader()) + elif getattr(file_, "read", None): + obj = yaml.load(file_, Loader=get_yaml_loader()) + else: + raise TypeError("Unexpected file type") + + if obj is not None and not isinstance(obj, (list, dict, str)): + raise IOError( # pragma: no cover + f"Invalid loaded object type: {type(obj).__name__}" + ) + + ret: Union[DictConfig, ListConfig] + if obj is None: + ret = OmegaConf.create() + else: + ret = OmegaConf.create(obj) + return ret + + @staticmethod + def save( + config: Any, f: Union[str, pathlib.Path, IO[Any]], resolve: bool = False + ) -> None: + """ + Save as configuration object to a file + + :param config: omegaconf.Config object (DictConfig or ListConfig). + :param f: filename or file object + :param resolve: True to save a resolved config (defaults to False) + """ + if is_dataclass(config) or is_attr_class(config): + config = OmegaConf.create(config) + data = OmegaConf.to_yaml(config, resolve=resolve) + if isinstance(f, (str, pathlib.Path)): + with io.open(os.path.abspath(f), "w", encoding="utf-8") as file: + file.write(data) + elif hasattr(f, "write"): + f.write(data) + f.flush() + else: + raise TypeError("Unexpected file type") + + @staticmethod + def from_cli(args_list: Optional[List[str]] = None) -> DictConfig: + if args_list is None: + # Skip program name + args_list = sys.argv[1:] + return OmegaConf.from_dotlist(args_list) + + @staticmethod + def from_dotlist(dotlist: List[str]) -> DictConfig: + """ + Creates config from the content sys.argv or from the specified args list of not None + + :param dotlist: A list of dotlist-style strings, e.g. ``["foo.bar=1", "baz=qux"]``. + :return: A ``DictConfig`` object created from the dotlist. + """ + conf = OmegaConf.create() + conf.merge_with_dotlist(dotlist) + return conf + + @staticmethod + def merge( + *configs: Union[ + DictConfig, + ListConfig, + Dict[DictKeyType, Any], + List[Any], + Tuple[Any, ...], + Any, + ], + ) -> Union[ListConfig, DictConfig]: + """ + Merge a list of previously created configs into a single one + + :param configs: Input configs + :return: the merged config object. + """ + assert len(configs) > 0 + target = copy.deepcopy(configs[0]) + target = _ensure_container(target) + assert isinstance(target, (DictConfig, ListConfig)) + + with flag_override(target, "readonly", False): + target.merge_with(*configs[1:]) + turned_readonly = target._get_flag("readonly") is True + + if turned_readonly: + OmegaConf.set_readonly(target, True) + + return target + + @staticmethod + def unsafe_merge( + *configs: Union[ + DictConfig, + ListConfig, + Dict[DictKeyType, Any], + List[Any], + Tuple[Any, ...], + Any, + ], + ) -> Union[ListConfig, DictConfig]: + """ + Merge a list of previously created configs into a single one + This is much faster than OmegaConf.merge() as the input configs are not copied. + However, the input configs must not be used after this operation as will become inconsistent. + + :param configs: Input configs + :return: the merged config object. + """ + assert len(configs) > 0 + target = configs[0] + target = _ensure_container(target) + assert isinstance(target, (DictConfig, ListConfig)) + + with flag_override( + target, ["readonly", "no_deepcopy_set_nodes"], [False, True] + ): + target.merge_with(*configs[1:]) + turned_readonly = target._get_flag("readonly") is True + + if turned_readonly: + OmegaConf.set_readonly(target, True) + + return target + + @staticmethod + def register_resolver(name: str, resolver: Resolver) -> None: + warnings.warn( + dedent( + """\ + register_resolver() is deprecated. + See https://github.com/omry/omegaconf/issues/426 for migration instructions. + """ + ), + stacklevel=2, + ) + return OmegaConf.legacy_register_resolver(name, resolver) + + # This function will eventually be deprecated and removed. + @staticmethod + def legacy_register_resolver(name: str, resolver: Resolver) -> None: + assert callable(resolver), "resolver must be callable" + # noinspection PyProtectedMember + assert ( + name not in BaseContainer._resolvers + ), f"resolver '{name}' is already registered" + + def resolver_wrapper( + config: BaseContainer, + parent: BaseContainer, + node: Node, + args: Tuple[Any, ...], + args_str: Tuple[str, ...], + ) -> Any: + cache = OmegaConf.get_cache(config)[name] + # "Un-escape " spaces and commas. + args_unesc = [x.replace(r"\ ", " ").replace(r"\,", ",") for x in args_str] + + # Nested interpolations behave in a potentially surprising way with + # legacy resolvers (they remain as strings, e.g., "${foo}"). If any + # input looks like an interpolation we thus raise an exception. + try: + bad_arg = next(i for i in args_unesc if "${" in i) + except StopIteration: + pass + else: + raise ValueError( + f"Resolver '{name}' was called with argument '{bad_arg}' that appears " + f"to be an interpolation. Nested interpolations are not supported for " + f"resolvers registered with `[legacy_]register_resolver()`, please use " + f"`register_new_resolver()` instead (see " + f"https://github.com/omry/omegaconf/issues/426 for migration instructions)." + ) + key = args_str + val = cache[key] if key in cache else resolver(*args_unesc) + cache[key] = val + return val + + # noinspection PyProtectedMember + BaseContainer._resolvers[name] = resolver_wrapper + + @staticmethod + def register_new_resolver( + name: str, + resolver: Resolver, + *, + replace: bool = False, + use_cache: bool = False, + ) -> None: + """ + Register a resolver. + + :param name: Name of the resolver. + :param resolver: Callable whose arguments are provided in the interpolation, + e.g., with ${foo:x,0,${y.z}} these arguments are respectively "x" (str), + 0 (int) and the value of ``y.z``. + :param replace: If set to ``False`` (default), then a ``ValueError`` is raised if + an existing resolver has already been registered with the same name. + If set to ``True``, then the new resolver replaces the previous one. + NOTE: The cache on existing config objects is not affected, use + ``OmegaConf.clear_cache(cfg)`` to clear it. + :param use_cache: Whether the resolver's outputs should be cached. The cache is + based only on the string literals representing the resolver arguments, e.g., + ${foo:${bar}} will always return the same value regardless of the value of + ``bar`` if the cache is enabled for ``foo``. + """ + if not callable(resolver): + raise TypeError("resolver must be callable") + if not name: + raise ValueError("cannot use an empty resolver name") + + if not replace and OmegaConf.has_resolver(name): + raise ValueError(f"resolver '{name}' is already registered") + + try: + sig: Optional[inspect.Signature] = inspect.signature(resolver) + except ValueError: + sig = None + + def _should_pass(special: str) -> bool: + ret = sig is not None and special in sig.parameters + if ret and use_cache: + raise ValueError( + f"use_cache=True is incompatible with functions that receive the {special}" + ) + return ret + + pass_parent = _should_pass("_parent_") + pass_node = _should_pass("_node_") + pass_root = _should_pass("_root_") + + def resolver_wrapper( + config: BaseContainer, + parent: Container, + node: Node, + args: Tuple[Any, ...], + args_str: Tuple[str, ...], + ) -> Any: + if use_cache: + cache = OmegaConf.get_cache(config)[name] + try: + return cache[args_str] + except KeyError: + pass + + # Call resolver. + kwargs: Dict[str, Node] = {} + if pass_parent: + kwargs["_parent_"] = parent + if pass_node: + kwargs["_node_"] = node + if pass_root: + kwargs["_root_"] = config + + ret = resolver(*args, **kwargs) + + if use_cache: + cache[args_str] = ret + return ret + + # noinspection PyProtectedMember + BaseContainer._resolvers[name] = resolver_wrapper + + @classmethod + def has_resolver(cls, name: str) -> bool: + return cls._get_resolver(name) is not None + + # noinspection PyProtectedMember + @staticmethod + def clear_resolvers() -> None: + """ + Clear(remove) all OmegaConf resolvers, then re-register OmegaConf's default resolvers. + """ + BaseContainer._resolvers = {} + register_default_resolvers() + + @classmethod + def clear_resolver(cls, name: str) -> bool: + """ + Clear(remove) any resolver only if it exists. + + Returns a bool: True if resolver is removed and False if not removed. + + .. warning: + This method can remove deafult resolvers as well. + + :param name: Name of the resolver. + :return: A bool (``True`` if resolver is removed, ``False`` if not found before removing). + """ + if cls.has_resolver(name): + BaseContainer._resolvers.pop(name) + return True + else: + # return False if resolver does not exist + return False + + @staticmethod + def get_cache(conf: BaseContainer) -> Dict[str, Any]: + return conf._metadata.resolver_cache + + @staticmethod + def set_cache(conf: BaseContainer, cache: Dict[str, Any]) -> None: + conf._metadata.resolver_cache = copy.deepcopy(cache) + + @staticmethod + def clear_cache(conf: BaseContainer) -> None: + OmegaConf.set_cache(conf, defaultdict(dict, {})) + + @staticmethod + def copy_cache(from_config: BaseContainer, to_config: BaseContainer) -> None: + OmegaConf.set_cache(to_config, OmegaConf.get_cache(from_config)) + + @staticmethod + def set_readonly(conf: Node, value: Optional[bool]) -> None: + # noinspection PyProtectedMember + conf._set_flag("readonly", value) + + @staticmethod + def is_readonly(conf: Node) -> Optional[bool]: + # noinspection PyProtectedMember + return conf._get_flag("readonly") + + @staticmethod + def set_struct(conf: Container, value: Optional[bool]) -> None: + # noinspection PyProtectedMember + conf._set_flag("struct", value) + + @staticmethod + def is_struct(conf: Container) -> Optional[bool]: + # noinspection PyProtectedMember + return conf._get_flag("struct") + + @staticmethod + def masked_copy(conf: DictConfig, keys: Union[str, List[str]]) -> DictConfig: + """ + Create a masked copy of of this config that contains a subset of the keys + + :param conf: DictConfig object + :param keys: keys to preserve in the copy + :return: The masked ``DictConfig`` object. + """ + from .dictconfig import DictConfig + + if not isinstance(conf, DictConfig): + raise ValueError("masked_copy is only supported for DictConfig") + + if isinstance(keys, str): + keys = [keys] + content = {key: value for key, value in conf.items_ex(resolve=False, keys=keys)} + return DictConfig(content=content) + + @staticmethod + def to_container( + cfg: Any, + *, + resolve: bool = False, + throw_on_missing: bool = False, + enum_to_str: bool = False, + structured_config_mode: SCMode = SCMode.DICT, + ) -> Union[Dict[DictKeyType, Any], List[Any], None, str, Any]: + """ + Resursively converts an OmegaConf config to a primitive container (dict or list). + + :param cfg: the config to convert + :param resolve: True to resolve all values + :param throw_on_missing: When True, raise MissingMandatoryValue if any missing values are present. + When False (the default), replace missing values with the string "???" in the output container. + :param enum_to_str: True to convert Enum keys and values to strings + :param structured_config_mode: Specify how Structured Configs (DictConfigs backed by a dataclass) are handled. + - By default (``structured_config_mode=SCMode.DICT``) structured configs are converted to plain dicts. + - If ``structured_config_mode=SCMode.DICT_CONFIG``, structured config nodes will remain as DictConfig. + - If ``structured_config_mode=SCMode.INSTANTIATE``, this function will instantiate structured configs + (DictConfigs backed by a dataclass), by creating an instance of the underlying dataclass. + + See also OmegaConf.to_object. + :return: A dict or a list representing this config as a primitive container. + """ + if not OmegaConf.is_config(cfg): + raise ValueError( + f"Input cfg is not an OmegaConf config object ({type_str(type(cfg))})" + ) + + return BaseContainer._to_content( + cfg, + resolve=resolve, + throw_on_missing=throw_on_missing, + enum_to_str=enum_to_str, + structured_config_mode=structured_config_mode, + ) + + @staticmethod + def to_object(cfg: Any) -> Union[Dict[DictKeyType, Any], List[Any], None, str, Any]: + """ + Resursively converts an OmegaConf config to a primitive container (dict or list). + Any DictConfig objects backed by dataclasses or attrs classes are instantiated + as instances of those backing classes. + + This is an alias for OmegaConf.to_container(..., resolve=True, throw_on_missing=True, + structured_config_mode=SCMode.INSTANTIATE) + + :param cfg: the config to convert + :return: A dict or a list or dataclass representing this config. + """ + return OmegaConf.to_container( + cfg=cfg, + resolve=True, + throw_on_missing=True, + enum_to_str=False, + structured_config_mode=SCMode.INSTANTIATE, + ) + + @staticmethod + def is_missing(cfg: Any, key: DictKeyType) -> bool: + assert isinstance(cfg, Container) + try: + node = cfg._get_child(key) + if node is None: + return False + assert isinstance(node, Node) + return node._is_missing() + except (UnsupportedInterpolationType, KeyError, AttributeError): + return False + + @staticmethod + def is_interpolation(node: Any, key: Optional[Union[int, str]] = None) -> bool: + if key is not None: + assert isinstance(node, Container) + target = node._get_child(key) + else: + target = node + if target is not None: + assert isinstance(target, Node) + return target._is_interpolation() + return False + + @staticmethod + def is_list(obj: Any) -> bool: + from . import ListConfig + + return isinstance(obj, ListConfig) + + @staticmethod + def is_dict(obj: Any) -> bool: + from . import DictConfig + + return isinstance(obj, DictConfig) + + @staticmethod + def is_config(obj: Any) -> bool: + from . import Container + + return isinstance(obj, Container) + + @staticmethod + def get_type(obj: Any, key: Optional[str] = None) -> Optional[Type[Any]]: + if key is not None: + c = obj._get_child(key) + else: + c = obj + return OmegaConf._get_obj_type(c) + + @staticmethod + def select( + cfg: Container, + key: str, + *, + default: Any = _DEFAULT_MARKER_, + throw_on_resolution_failure: bool = True, + throw_on_missing: bool = False, + ) -> Any: + """ + :param cfg: Config node to select from + :param key: Key to select + :param default: Default value to return if key is not found + :param throw_on_resolution_failure: Raise an exception if an interpolation + resolution error occurs, otherwise return None + :param throw_on_missing: Raise an exception if an attempt to select a missing key (with the value '???') + is made, otherwise return None + :return: selected value or None if not found. + """ + from ._impl import select_value + + try: + return select_value( + cfg=cfg, + key=key, + default=default, + throw_on_resolution_failure=throw_on_resolution_failure, + throw_on_missing=throw_on_missing, + ) + except Exception as e: + format_and_raise(node=cfg, key=key, value=None, cause=e, msg=str(e)) + + @staticmethod + def update( + cfg: Container, + key: str, + value: Any = None, + *, + merge: bool = True, + force_add: bool = False, + ) -> None: + """ + Updates a dot separated key sequence to a value + + :param cfg: input config to update + :param key: key to update (can be a dot separated path) + :param value: value to set, if value if a list or a dict it will be merged or set + depending on merge_config_values + :param merge: If value is a dict or a list, True (default) to merge + into the destination, False to replace the destination. + :param force_add: insert the entire path regardless of Struct flag or Structured Config nodes. + """ + + split = split_key(key) + root = cfg + for i in range(len(split) - 1): + k = split[i] + # if next_root is a primitive (string, int etc) replace it with an empty map + next_root, key_ = _select_one(root, k, throw_on_missing=False) + if not isinstance(next_root, Container): + if force_add: + with flag_override(root, "struct", False): + root[key_] = {} + else: + root[key_] = {} + root = root[key_] + + last = split[-1] + + assert isinstance( + root, Container + ), f"Unexpected type for root: {type(root).__name__}" + + last_key: Union[str, int] = last + if isinstance(root, ListConfig): + last_key = int(last) + + ctx = flag_override(root, "struct", False) if force_add else nullcontext() + with ctx: + if merge and (OmegaConf.is_config(value) or is_primitive_container(value)): + assert isinstance(root, BaseContainer) + node = root._get_child(last_key) + if OmegaConf.is_config(node): + assert isinstance(node, BaseContainer) + node.merge_with(value) + return + + if OmegaConf.is_dict(root): + assert isinstance(last_key, str) + root.__setattr__(last_key, value) + elif OmegaConf.is_list(root): + assert isinstance(last_key, int) + root.__setitem__(last_key, value) + else: + assert False + + @staticmethod + def to_yaml(cfg: Any, *, resolve: bool = False, sort_keys: bool = False) -> str: + """ + returns a yaml dump of this config object. + + :param cfg: Config object, Structured Config type or instance + :param resolve: if True, will return a string with the interpolations resolved, otherwise + interpolations are preserved + :param sort_keys: If True, will print dict keys in sorted order. default False. + :return: A string containing the yaml representation. + """ + cfg = _ensure_container(cfg) + container = OmegaConf.to_container(cfg, resolve=resolve, enum_to_str=True) + return yaml.dump( # type: ignore + container, + default_flow_style=False, + allow_unicode=True, + sort_keys=sort_keys, + Dumper=get_omega_conf_dumper(), + ) + + @staticmethod + def resolve(cfg: Container) -> None: + """ + Resolves all interpolations in the given config object in-place. + + :param cfg: An OmegaConf container (DictConfig, ListConfig) + Raises a ValueError if the input object is not an OmegaConf container. + """ + import omegaconf._impl + + if not OmegaConf.is_config(cfg): + # Since this function is mutating the input object in-place, it doesn't make sense to + # auto-convert the input object to an OmegaConf container + raise ValueError( + f"Invalid config type ({type(cfg).__name__}), expected an OmegaConf Container" + ) + omegaconf._impl._resolve(cfg) + + @staticmethod + def missing_keys(cfg: Any) -> Set[str]: + """ + Returns a set of missing keys in a dotlist style. + + :param cfg: An ``OmegaConf.Container``, + or a convertible object via ``OmegaConf.create`` (dict, list, ...). + :return: set of strings of the missing keys. + :raises ValueError: On input not representing a config. + """ + cfg = _ensure_container(cfg) + missings: Set[str] = set() + + def gather(_cfg: Container) -> None: + itr: Iterable[Any] + if isinstance(_cfg, ListConfig): + itr = range(len(_cfg)) + else: + itr = _cfg + + for key in itr: + if OmegaConf.is_missing(_cfg, key): + missings.add(_cfg._get_full_key(key)) + elif OmegaConf.is_config(_cfg[key]): + gather(_cfg[key]) + + gather(cfg) + return missings + + # === private === # + + @staticmethod + def _create_impl( # noqa F811 + obj: Any = _DEFAULT_MARKER_, + parent: Optional[BaseContainer] = None, + flags: Optional[Dict[str, bool]] = None, + ) -> Union[DictConfig, ListConfig]: + try: + from ._utils import get_yaml_loader + from .dictconfig import DictConfig + from .listconfig import ListConfig + + if obj is _DEFAULT_MARKER_: + obj = {} + if isinstance(obj, str): + obj = yaml.load(obj, Loader=get_yaml_loader()) + if obj is None: + return OmegaConf.create({}, parent=parent, flags=flags) + elif isinstance(obj, str): + return OmegaConf.create({obj: None}, parent=parent, flags=flags) + else: + assert isinstance(obj, (list, dict)) + return OmegaConf.create(obj, parent=parent, flags=flags) + + else: + if ( + is_primitive_dict(obj) + or OmegaConf.is_dict(obj) + or is_structured_config(obj) + or obj is None + ): + if isinstance(obj, DictConfig): + return DictConfig( + content=obj, + parent=parent, + ref_type=obj._metadata.ref_type, + is_optional=obj._metadata.optional, + key_type=obj._metadata.key_type, + element_type=obj._metadata.element_type, + flags=flags, + ) + else: + obj_type = OmegaConf.get_type(obj) + key_type, element_type = get_dict_key_value_types(obj_type) + return DictConfig( + content=obj, + parent=parent, + key_type=key_type, + element_type=element_type, + flags=flags, + ) + elif is_primitive_list(obj) or OmegaConf.is_list(obj): + if isinstance(obj, ListConfig): + return ListConfig( + content=obj, + parent=parent, + element_type=obj._metadata.element_type, + ref_type=obj._metadata.ref_type, + is_optional=obj._metadata.optional, + flags=flags, + ) + else: + obj_type = OmegaConf.get_type(obj) + element_type = get_list_element_type(obj_type) + return ListConfig( + content=obj, + parent=parent, + element_type=element_type, + ref_type=Any, + is_optional=True, + flags=flags, + ) + else: + if isinstance(obj, type): + raise ValidationError( + f"Input class '{obj.__name__}' is not a structured config. " + "did you forget to decorate it as a dataclass?" + ) + else: + raise ValidationError( + f"Object of unsupported type: '{type(obj).__name__}'" + ) + except OmegaConfBaseException as e: + format_and_raise(node=None, key=None, value=None, msg=str(e), cause=e) + assert False + + @staticmethod + def _get_obj_type(c: Any) -> Optional[Type[Any]]: + if is_structured_config(c): + return get_type_of(c) + elif c is None: + return None + elif isinstance(c, DictConfig): + if c._is_none(): + return None + elif c._is_missing(): + return None + else: + if is_structured_config(c._metadata.object_type): + return c._metadata.object_type + else: + return dict + elif isinstance(c, ListConfig): + return list + elif isinstance(c, ValueNode): + return type(c._value()) + elif isinstance(c, UnionNode): + return type(_get_value(c)) + elif isinstance(c, dict): + return dict + elif isinstance(c, (list, tuple)): + return list + else: + return get_type_of(c) + + @staticmethod + def _get_resolver( + name: str, + ) -> Optional[ + Callable[ + [Container, Container, Node, Tuple[Any, ...], Tuple[str, ...]], + Any, + ] + ]: + # noinspection PyProtectedMember + return ( + BaseContainer._resolvers[name] if name in BaseContainer._resolvers else None + ) + + +# register all default resolvers +register_default_resolvers() + + +@contextmanager +def flag_override( + config: Node, + names: Union[List[str], str], + values: Union[List[Optional[bool]], Optional[bool]], +) -> Generator[Node, None, None]: + if isinstance(names, str): + names = [names] + if values is None or isinstance(values, bool): + values = [values] + + prev_states = [config._get_node_flag(name) for name in names] + + try: + config._set_flag(names, values) + yield config + finally: + config._set_flag(names, prev_states) + + +@contextmanager +def read_write(config: Node) -> Generator[Node, None, None]: + prev_state = config._get_node_flag("readonly") + try: + OmegaConf.set_readonly(config, False) + yield config + finally: + OmegaConf.set_readonly(config, prev_state) + + +@contextmanager +def open_dict(config: Container) -> Generator[Container, None, None]: + prev_state = config._get_node_flag("struct") + try: + OmegaConf.set_struct(config, False) + yield config + finally: + OmegaConf.set_struct(config, prev_state) + + +# === private === # + + +def _node_wrap( + parent: Optional[Box], + is_optional: bool, + value: Any, + key: Any, + ref_type: Any = Any, +) -> Node: + node: Node + if is_dict_annotation(ref_type) or (is_primitive_dict(value) and ref_type is Any): + key_type, element_type = get_dict_key_value_types(ref_type) + node = DictConfig( + content=value, + key=key, + parent=parent, + ref_type=ref_type, + is_optional=is_optional, + key_type=key_type, + element_type=element_type, + ) + elif (is_list_annotation(ref_type) or is_tuple_annotation(ref_type)) or ( + type(value) in (list, tuple) and ref_type is Any + ): + element_type = get_list_element_type(ref_type) + node = ListConfig( + content=value, + key=key, + parent=parent, + is_optional=is_optional, + element_type=element_type, + ref_type=ref_type, + ) + elif is_structured_config(ref_type) or is_structured_config(value): + key_type, element_type = get_dict_key_value_types(value) + node = DictConfig( + ref_type=ref_type, + is_optional=is_optional, + content=value, + key=key, + parent=parent, + key_type=key_type, + element_type=element_type, + ) + elif is_union_annotation(ref_type): + node = UnionNode( + content=value, + ref_type=ref_type, + is_optional=is_optional, + key=key, + parent=parent, + ) + elif ref_type == Any or ref_type is None: + node = AnyNode(value=value, key=key, parent=parent) + elif isinstance(ref_type, type) and issubclass(ref_type, Enum): + node = EnumNode( + enum_type=ref_type, + value=value, + key=key, + parent=parent, + is_optional=is_optional, + ) + elif ref_type == int: + node = IntegerNode(value=value, key=key, parent=parent, is_optional=is_optional) + elif ref_type == float: + node = FloatNode(value=value, key=key, parent=parent, is_optional=is_optional) + elif ref_type == bool: + node = BooleanNode(value=value, key=key, parent=parent, is_optional=is_optional) + elif ref_type == str: + node = StringNode(value=value, key=key, parent=parent, is_optional=is_optional) + elif ref_type == bytes: + node = BytesNode(value=value, key=key, parent=parent, is_optional=is_optional) + elif ref_type == pathlib.Path: + node = PathNode(value=value, key=key, parent=parent, is_optional=is_optional) + else: + if parent is not None and parent._get_flag("allow_objects") is True: + if type(value) in (list, tuple): + node = ListConfig( + content=value, + key=key, + parent=parent, + ref_type=ref_type, + is_optional=is_optional, + ) + elif is_primitive_dict(value): + node = DictConfig( + content=value, + key=key, + parent=parent, + ref_type=ref_type, + is_optional=is_optional, + ) + else: + node = AnyNode(value=value, key=key, parent=parent) + else: + raise ValidationError(f"Unexpected type annotation: {type_str(ref_type)}") + return node + + +def _maybe_wrap( + ref_type: Any, + key: Any, + value: Any, + is_optional: bool, + parent: Optional[BaseContainer], +) -> Node: + # if already a node, update key and parent and return as is. + # NOTE: that this mutate the input node! + if isinstance(value, Node): + value._set_key(key) + value._set_parent(parent) + return value + else: + return _node_wrap( + ref_type=ref_type, + parent=parent, + is_optional=is_optional, + value=value, + key=key, + ) + + +def _select_one( + c: Container, key: str, throw_on_missing: bool, throw_on_type_error: bool = True +) -> Tuple[Optional[Node], Union[str, int]]: + from .dictconfig import DictConfig + from .listconfig import ListConfig + + ret_key: Union[str, int] = key + assert isinstance(c, Container), f"Unexpected type: {c}" + if c._is_none(): + return None, ret_key + + if isinstance(c, DictConfig): + assert isinstance(ret_key, str) + val = c._get_child(ret_key, validate_access=False) + elif isinstance(c, ListConfig): + assert isinstance(ret_key, str) + if not is_int(ret_key): + if throw_on_type_error: + raise TypeError( + f"Index '{ret_key}' ({type(ret_key).__name__}) is not an int" + ) + else: + val = None + else: + ret_key = int(ret_key) + if ret_key < 0 or ret_key + 1 > len(c): + val = None + else: + val = c._get_child(ret_key) + else: + assert False + + if val is not None: + assert isinstance(val, Node) + if val._is_missing(): + if throw_on_missing: + raise MissingMandatoryValue( + f"Missing mandatory value: {c._get_full_key(ret_key)}" + ) + else: + return val, ret_key + + assert val is None or isinstance(val, Node) + return val, ret_key diff --git a/runtime/Lib/site-packages/omegaconf/py.typed b/runtime/Lib/site-packages/omegaconf/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/runtime/Lib/site-packages/omegaconf/resolvers/__init__.py b/runtime/Lib/site-packages/omegaconf/resolvers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1b0bb71168722281af5ddecb46f79e36f63c71e4 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/resolvers/__init__.py @@ -0,0 +1,5 @@ +from omegaconf.resolvers import oc + +__all__ = [ + "oc", +] diff --git a/runtime/Lib/site-packages/omegaconf/resolvers/oc/__init__.py b/runtime/Lib/site-packages/omegaconf/resolvers/oc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c177ab4f1b35dfa5502a9b6359439bfca180ba1d --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/resolvers/oc/__init__.py @@ -0,0 +1,113 @@ +import os +import string +import warnings +from typing import Any, Optional + +from omegaconf import Container, Node +from omegaconf._utils import _DEFAULT_MARKER_, _get_value +from omegaconf.basecontainer import BaseContainer +from omegaconf.errors import ConfigKeyError +from omegaconf.grammar_parser import parse +from omegaconf.resolvers.oc import dict + + +def create(obj: Any, _parent_: Container) -> Any: + """Create a config object from `obj`, similar to `OmegaConf.create`""" + from omegaconf import OmegaConf + + assert isinstance(_parent_, BaseContainer) + return OmegaConf.create(obj, parent=_parent_) + + +def env(key: str, default: Any = _DEFAULT_MARKER_) -> Optional[str]: + """ + :param key: Environment variable key + :param default: Optional default value to use in case the key environment variable is not set. + If default is not a string, it is converted with str(default). + None default is returned as is. + :return: The environment variable 'key'. If the environment variable is not set and a default is + provided, the default is used. If used, the default is converted to a string with str(default). + If the default is None, None is returned (without a string conversion). + """ + try: + return os.environ[key] + except KeyError: + if default is not _DEFAULT_MARKER_: + return str(default) if default is not None else None + else: + raise KeyError(f"Environment variable '{key}' not found") + + +def decode(expr: Optional[str], _parent_: Container, _node_: Node) -> Any: + """ + Parse and evaluate `expr` according to the `singleElement` rule of the grammar. + + If `expr` is `None`, then return `None`. + """ + if expr is None: + return None + + if not isinstance(expr, str): + raise TypeError( + f"`oc.decode` can only take strings or None as input, " + f"but `{expr}` is of type {type(expr).__name__}" + ) + + parse_tree = parse(expr, parser_rule="singleElement", lexer_mode="VALUE_MODE") + val = _parent_.resolve_parse_tree(parse_tree, node=_node_) + return _get_value(val) + + +def deprecated( + key: str, + message: str = "'$OLD_KEY' is deprecated. Change your code and config to use '$NEW_KEY'", + *, + _parent_: Container, + _node_: Node, +) -> Any: + from omegaconf._impl import select_node + + if not isinstance(key, str): + raise TypeError( + f"oc.deprecated: interpolation key type is not a string ({type(key).__name__})" + ) + + if not isinstance(message, str): + raise TypeError( + f"oc.deprecated: interpolation message type is not a string ({type(message).__name__})" + ) + + full_key = _node_._get_full_key(key=None) + target_node = select_node(_parent_, key, absolute_key=True) + if target_node is None: + raise ConfigKeyError( + f"In oc.deprecated resolver at '{full_key}': Key not found: '{key}'" + ) + new_key = target_node._get_full_key(key=None) + msg = string.Template(message).safe_substitute( + OLD_KEY=full_key, + NEW_KEY=new_key, + ) + warnings.warn(category=UserWarning, message=msg) + return target_node + + +def select( + key: str, + default: Any = _DEFAULT_MARKER_, + *, + _parent_: Container, +) -> Any: + from omegaconf._impl import select_value + + return select_value(cfg=_parent_, key=key, absolute_key=True, default=default) + + +__all__ = [ + "create", + "decode", + "deprecated", + "dict", + "env", + "select", +] diff --git a/runtime/Lib/site-packages/omegaconf/resolvers/oc/dict.py b/runtime/Lib/site-packages/omegaconf/resolvers/oc/dict.py new file mode 100644 index 0000000000000000000000000000000000000000..adbfd16ac47f2dced46f509c8dfdc8516ba97f4a --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/resolvers/oc/dict.py @@ -0,0 +1,83 @@ +from typing import Any, List + +from omegaconf import AnyNode, Container, DictConfig, ListConfig +from omegaconf._utils import Marker +from omegaconf.basecontainer import BaseContainer +from omegaconf.errors import ConfigKeyError + +_DEFAULT_SELECT_MARKER_: Any = Marker("_DEFAULT_SELECT_MARKER_") + + +def keys( + key: str, + _parent_: Container, +) -> ListConfig: + from omegaconf import OmegaConf + + assert isinstance(_parent_, BaseContainer) + + in_dict = _get_and_validate_dict_input( + key, parent=_parent_, resolver_name="oc.dict.keys" + ) + + ret = OmegaConf.create(list(in_dict.keys()), parent=_parent_) + assert isinstance(ret, ListConfig) + return ret + + +def values(key: str, _root_: BaseContainer, _parent_: Container) -> ListConfig: + assert isinstance(_parent_, BaseContainer) + in_dict = _get_and_validate_dict_input( + key, parent=_parent_, resolver_name="oc.dict.values" + ) + + content = in_dict._content + assert isinstance(content, dict) + + ret = ListConfig([]) + if key.startswith("."): + key = f".{key}" # extra dot to compensate for extra level of nesting within ret ListConfig + for k in content: + ref_node = AnyNode(f"${{{key}.{k!s}}}") + ret.append(ref_node) + + # Finalize result by setting proper type and parent. + element_type: Any = in_dict._metadata.element_type + ret._metadata.element_type = element_type + ret._metadata.ref_type = List[element_type] + ret._set_parent(_parent_) + + return ret + + +def _get_and_validate_dict_input( + key: str, + parent: BaseContainer, + resolver_name: str, +) -> DictConfig: + from omegaconf._impl import select_value + + if not isinstance(key, str): + raise TypeError( + f"`{resolver_name}` requires a string as input, but obtained `{key}` " + f"of type: {type(key).__name__}" + ) + + in_dict = select_value( + parent, + key, + throw_on_missing=True, + absolute_key=True, + default=_DEFAULT_SELECT_MARKER_, + ) + + if in_dict is _DEFAULT_SELECT_MARKER_: + raise ConfigKeyError(f"Key not found: '{key}'") + + if not isinstance(in_dict, DictConfig): + raise TypeError( + f"`{resolver_name}` cannot be applied to objects of type: " + f"{type(in_dict).__name__}" + ) + + return in_dict diff --git a/runtime/Lib/site-packages/omegaconf/version.py b/runtime/Lib/site-packages/omegaconf/version.py new file mode 100644 index 0000000000000000000000000000000000000000..b4989b2ef4670f866a92767403c3f63204a06f81 --- /dev/null +++ b/runtime/Lib/site-packages/omegaconf/version.py @@ -0,0 +1,13 @@ +import sys # pragma: no cover + +__version__ = "2.3.0" + +msg = """OmegaConf 2.0 and above is compatible with Python 3.6 and newer. +You have the following options: +1. Upgrade to Python 3.6 or newer. + This is highly recommended. new features will not be added to OmegaConf 1.4. +2. Continue using OmegaConf 1.4: + You can pip install 'OmegaConf<1.5' to do that. +""" +if sys.version_info < (3, 6): + raise ImportError(msg) # pragma: no cover diff --git a/runtime/Lib/site-packages/onnx-1.14.0.dist-info/INSTALLER b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/runtime/Lib/site-packages/onnx-1.14.0.dist-info/LICENSE b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..75b52484ea471f882c29e02693b4f02dba175b5e --- /dev/null +++ b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/runtime/Lib/site-packages/onnx-1.14.0.dist-info/METADATA b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..0e500bc9ec38b52262ca3a5724a580bcbb3acff6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/METADATA @@ -0,0 +1,350 @@ +Metadata-Version: 2.1 +Name: onnx +Version: 1.14.0 +Summary: Open Neural Network Exchange +Home-page: https://github.com/onnx/onnx +Author: ONNX +Author-email: onnx-technical-discuss@lists.lfaidata.foundation +License: Apache License v2.0 +Platform: UNKNOWN +Classifier: Programming Language :: Python :: 3 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: numpy +Requires-Dist: protobuf (>=3.20.2) +Requires-Dist: typing-extensions (>=3.6.2.1) +Provides-Extra: lint +Requires-Dist: lintrunner (>=0.10.0) ; extra == 'lint' +Requires-Dist: lintrunner-adapters (>=0.3) ; extra == 'lint' + + + + + +

+ +[![Build Status](https://dev.azure.com/onnx-pipelines/onnx/_apis/build/status/Windows-CI?branchName=main&label=Windows)](https://dev.azure.com/onnx-pipelines/onnx/_build/latest?definitionId=5&branchName=main) +[![Build Status](https://dev.azure.com/onnx-pipelines/onnx/_apis/build/status/Linux-CI?branchName=main&label=Linux)](https://dev.azure.com/onnx-pipelines/onnx/_build/latest?definitionId=7&branchName=main) +[![Build Status](https://dev.azure.com/onnx-pipelines/onnx/_apis/build/status/MacOS-CI?branchName=main&label=MacOS)](https://dev.azure.com/onnx-pipelines/onnx/_build/latest?definitionId=6&branchName=main) +[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3313/badge)](https://bestpractices.coreinfrastructure.org/projects/3313) +[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/onnx/onnx/badge)](https://api.securityscorecards.dev/projects/github.com/onnx/onnx) +[![REUSE compliant](https://api.reuse.software/badge/github.com/onnx/onnx)](https://api.reuse.software/info/github.com/onnx/onnx) + + +[Open Neural Network Exchange (ONNX)](https://onnx.ai) is an open ecosystem that empowers AI developers +to choose the right tools as their project evolves. ONNX provides an open source format for AI models, both deep learning and traditional ML. It defines an extensible computation graph model, as well as definitions of built-in operators and standard +data types. Currently we focus on the capabilities needed for inferencing (scoring). + +ONNX is [widely supported](http://onnx.ai/supported-tools) and can be found in many frameworks, tools, and hardware. Enabling interoperability between different frameworks and streamlining the path from research to production helps increase the speed of innovation in the AI community. We invite the community to join us and further evolve ONNX. + +# Use ONNX + +* [Documentation of ONNX Python Package](https://onnx.ai/onnx/) +* [Tutorials for creating ONNX models](https://github.com/onnx/tutorials) +* [Pre-trained ONNX models](https://github.com/onnx/models) + +# Learn about the ONNX spec + +* [Overview](docs/Overview.md) +* [ONNX intermediate representation spec](docs/IR.md) +* [Versioning principles of the spec](docs/Versioning.md) +* [Operators documentation](docs/Operators.md) (development version) +* [Operators documentation](https://onnx.ai/onnx/operators/index.html) (latest release) +* [Python API Overview](docs/PythonAPIOverview.md) + +# Programming utilities for working with ONNX Graphs + +* [Shape and Type Inference](docs/ShapeInference.md) +* [Graph Optimization](https://github.com/onnx/optimizer) +* [Opset Version Conversion](docs/VersionConverter.md) + +# Contribute + +ONNX is a community project and the open governance model is described [here](community/readme.md). We encourage you to join the effort and contribute feedback, ideas, and code. You can participate in the [Special Interest Groups](community/sigs.md) and [Working Groups](community/working-groups.md) to shape the future of ONNX. + +Check out our [contribution guide](docs/CONTRIBUTING.md) to get started. + +If you think some operator should be added to ONNX specification, please read +[this document](docs/AddNewOp.md). + +# Community meetings + +The schedules of the regular meetings of the Steering Committee, the working groups and the SIGs can be found [here](https://onnx.ai/calendar) + +Community Meetups are held at least once a year. Content from previous community meetups are at: + +* 2020.04.09 +* 2020.10.14 +* 2021.03.24 +* 2021.10.21 +* 2022.06.24 + +# Discuss + +We encourage you to open [Issues](https://github.com/onnx/onnx/issues), or use [Slack](https://lfaifoundation.slack.com/) (If you have not joined yet, please use this [link](https://join.slack.com/t/lfaifoundation/shared_invite/zt-o65errpw-gMTbwNr7FnNbVXNVFkmyNA) to join the group) for more real-time discussion. + +# Follow Us + +Stay up to date with the latest ONNX news. [[Facebook](https://www.facebook.com/onnxai/)] [[Twitter](https://twitter.com/onnxai)] + +# Roadmap + +A roadmap process takes place every year. More details can be found [here](https://github.com/onnx/steering-committee/tree/main/roadmap) + +# Installation + +## Official Python packages + +ONNX released packages are published in PyPi. + +```sh +pip install onnx +``` + +[ONNX weekly packages](https://pypi.org/project/onnx-weekly/) are published in PyPI to enable experimentation and early testing. + +## vcpkg packages + +onnx is in the maintenance list of [vcpkg](https://github.com/microsoft/vcpkg), you can easily use vcpkg to build and install it. + +```sh +git clone https://github.com/microsoft/vcpkg.git +cd vcpkg +./bootstrap-vcpkg.bat # For powershell +./bootstrap-vcpkg.sh # For bash +./vcpkg install onnx +``` + +## Conda packages + +A binary build of ONNX is available from [Conda](https://conda.io), in [conda-forge](https://conda-forge.org/): + +```sh +conda install -c conda-forge onnx +``` + +## Build ONNX from Source + +Before building from source uninstall any existing versions of onnx `pip uninstall onnx`. + +c++17 or higher C++ compiler version is required to build ONNX from source on Windows. For other platforms, please use C++11 or higher versions. + +Generally speaking, you need to install [protobuf C/C++ libraries and tools](https://github.com/protocolbuffers/protobuf) before proceeding forward. Then depending on how you installed protobuf, you need to set environment variable CMAKE_ARGS to "-DONNX_USE_PROTOBUF_SHARED_LIBS=ON" or "-DONNX_USE_PROTOBUF_SHARED_LIBS=OFF". For example, you may need to run the following command: + +Linux: + +```sh +export CMAKE_ARGS="-DONNX_USE_PROTOBUF_SHARED_LIBS=ON" +``` + +Windows: + +```bat +set CMAKE_ARGS="-DONNX_USE_PROTOBUF_SHARED_LIBS=ON" +``` + +The ON/OFF depends on what kind of protobuf library you have. Shared libraries are files ending with \*.dll/\*.so/\*.dylib. Static libraries are files ending with \*.a/\*.lib. This option depends on how you get your protobuf library and how it was built. And it is default OFF. You don't need to run the commands above if you'd prefer to use a static protobuf library. + +### Windows + +If you are building ONNX from source, it is recommended that you also build Protobuf locally as a static library. The version distributed with conda-forge is a DLL, but ONNX expects it to be a static library. Building protobuf locally also lets you control the version of protobuf. The tested and recommended version is 3.20.2. + +The instructions in this README assume you are using Visual Studio. It is recommended that you run all the commands from a shell started from "x64 Native Tools Command Prompt for VS 2019" and keep the build system generator for cmake (e.g., cmake -G "Visual Studio 16 2019") consistent while building protobuf as well as ONNX. + +You can get protobuf by running the following commands: + +```bat +git clone https://github.com/protocolbuffers/protobuf.git +cd protobuf +git checkout v3.20.2 +cd cmake +cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX= -Dprotobuf_MSVC_STATIC_RUNTIME=OFF -Dprotobuf_BUILD_SHARED_LIBS=OFF -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_BUILD_EXAMPLES=OFF . +msbuild protobuf.sln /m /p:Configuration=Release +msbuild INSTALL.vcxproj /p:Configuration=Release +``` + +Then it will be built as a static library and installed to . Please add the bin directory(which contains protoc.exe) to your PATH. + +```bat +set PATH=/bin;%PATH% +``` + +Please note: if your protobuf_install_dir contains spaces, **do not** add quotation marks around it. + +Alternative: if you don't want to change your PATH, you can set ONNX_PROTOC_EXECUTABLE instead. + +```bat +set CMAKE_ARGS=-DONNX_PROTOC_EXECUTABLE= +``` + +Then you can build ONNX as: + +``` +git clone https://github.com/onnx/onnx.git +cd onnx +git submodule update --init --recursive +# prefer lite proto +set CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON +pip install -e . +``` + +### Linux + +First, you need to install protobuf. The minimum Protobuf compiler (protoc) version required by ONNX is 3.6.1. Please note that old protoc versions might not work with `CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON`. + +Ubuntu 20.04 (and newer) users may choose to install protobuf via + +```sh +apt-get install python3-pip python3-dev libprotobuf-dev protobuf-compiler +``` + +In this case, it is required to add `-DONNX_USE_PROTOBUF_SHARED_LIBS=ON` to CMAKE_ARGS in the ONNX build step. + +A more general way is to build and install it from source. See the instructions below for more details. + +
+ Installing Protobuf from source + + Debian/Ubuntu: + + ```sh + git clone https://github.com/protocolbuffers/protobuf.git + cd protobuf + git checkout v3.20.2 + git submodule update --init --recursive + mkdir build_source && cd build_source + cmake ../cmake -Dprotobuf_BUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_INSTALL_SYSCONFDIR=/etc -DCMAKE_POSITION_INDEPENDENT_CODE=ON -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release + make -j$(nproc) + make install + ``` + + CentOS/RHEL/Fedora: + + ```sh + git clone https://github.com/protocolbuffers/protobuf.git + cd protobuf + git checkout v3.20.2 + git submodule update --init --recursive + mkdir build_source && cd build_source + cmake ../cmake -DCMAKE_INSTALL_LIBDIR=lib64 -Dprotobuf_BUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_INSTALL_SYSCONFDIR=/etc -DCMAKE_POSITION_INDEPENDENT_CODE=ON -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release + make -j$(nproc) + make install + ``` + + Here "-DCMAKE_POSITION_INDEPENDENT_CODE=ON" is crucial. By default static libraries are built without "-fPIC" flag, they are not position independent code. But shared libraries must be position independent code. Python C/C++ extensions(like ONNX) are shared libraries. So if a static library was not built with "-fPIC", it can't be linked to such a shared library. + + Once build is successful, update PATH to include protobuf paths. + +
+ +Then you can build ONNX as: + +```sh +git clone https://github.com/onnx/onnx.git +cd onnx +git submodule update --init --recursive +# Optional: prefer lite proto +export CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON +pip install -e . +``` + +### Mac + +```sh +export NUM_CORES=`sysctl -n hw.ncpu` +brew update +brew install autoconf && brew install automake +wget https://github.com/protocolbuffers/protobuf/releases/download/v3.20.2/protobuf-cpp-3.20.2.tar.gz +tar -xvf protobuf-cpp-3.20.2.tar.gz +cd protobuf-3.20.2 +mkdir build_source && cd build_source +cmake ../cmake -Dprotobuf_BUILD_SHARED_LIBS=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release +make -j${NUM_CORES} +make install +``` + +Once build is successful, update PATH to include protobuf paths. + +Then you can build ONNX as: + +```sh +git clone --recursive https://github.com/onnx/onnx.git +cd onnx +# Optional: prefer lite proto +set CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON +pip install -e . +``` + +## Verify Installation + +After installation, run + +```sh +python -c "import onnx" +``` + +to verify it works. + +## Common Build Options + +For full list refer to CMakeLists.txt + +### Environment variables + +* `USE_MSVC_STATIC_RUNTIME` should be 1 or 0, not ON or OFF. When set to 1 onnx links statically to runtime library. +**Default**: `USE_MSVC_STATIC_RUNTIME=0` + +* `DEBUG` should be 0 or 1. When set to 1 onnx is built in debug mode. or debug versions of the dependencies, you need to open the [CMakeLists file](CMakeLists.txt) and append a letter `d` at the end of the package name lines. For example, `NAMES protobuf-lite` would become `NAMES protobuf-lited`. +**Default**: `Debug=0` + +### CMake variables + +* `ONNX_USE_PROTOBUF_SHARED_LIBS` should be `ON` or `OFF`. +**Default**: `ONNX_USE_PROTOBUF_SHARED_LIBS=OFF USE_MSVC_STATIC_RUNTIME=0` +`ONNX_USE_PROTOBUF_SHARED_LIBS` determines how onnx links to protobuf libraries. + * When set to `ON` - onnx will dynamically link to protobuf shared libs, PROTOBUF_USE_DLLS will be defined as described [here](https://github.com/protocolbuffers/protobuf/blob/main/cmake/README.md#dlls-vs-static-linking), Protobuf_USE_STATIC_LIBS will be set to `OFF` and `USE_MSVC_STATIC_RUNTIME` must be 0. + * When set to `OFF` - onnx will link statically to protobuf, and Protobuf_USE_STATIC_LIBS will be set to `ON` (to force the use of the static libraries) and `USE_MSVC_STATIC_RUNTIME` can be `0` or `1`. + +* `ONNX_USE_LITE_PROTO` should be `ON` or `OFF`. When set to `ON` onnx uses lite protobuf instead of full protobuf. +**Default**: `ONNX_USE_LITE_PROTO=OFF` + +* `ONNX_WERROR` should be `ON` or `OFF`. When set to `ON` warnings are treated as errors. +**Default**: `ONNX_WERROR=OFF` in local builds, `ON` in CI and release pipelines. + +## Common Errors + +* Note: the `import onnx` command does not work from the source checkout directory; in this case you'll see `ModuleNotFoundError: No module named 'onnx.onnx_cpp2py_export'`. Change into another directory to fix this error. + +* If you run into any issues while building Protobuf as a static library, please ensure that shared Protobuf libraries, like libprotobuf, are not installed on your device or in the conda environment. If these shared libraries exist, either remove them to build Protobuf from source as a static library, or skip the Protobuf build from source to use the shared version directly. + +* If you run into any issues while building ONNX from source, and your error message reads, `Could not find pythonXX.lib`, ensure that you have consistent Python versions for common commands, such as `python` and `pip`. Clean all existing build files and rebuild ONNX again. + +# Testing + +ONNX uses [pytest](https://docs.pytest.org) as test driver. In order to run tests, you will first need to install `pytest`: + +```sh +pip install pytest nbval +``` + +After installing pytest, use the following command to run tests. + +```sh +pytest +``` + +# Development + +Check out the [contributor guide](docs/CONTRIBUTING.md) for instructions. + +# License + +[Apache License v2.0](LICENSE) + +# Code of Conduct + +[ONNX Open Source Code of Conduct](https://onnx.ai/codeofconduct.html) + + diff --git a/runtime/Lib/site-packages/onnx-1.14.0.dist-info/RECORD b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..80d4c5e1d15f9e568ee0be1e4fa72fbcbb7fc0c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/RECORD @@ -0,0 +1,6419 @@ +../../Scripts/backend-test-tools.exe,sha256=9ikLWeAx5M4MYFoQtUVUMcrbJfgXNJ6odAFu2EJzNkI,108428 +../../Scripts/check-model.exe,sha256=pECTomjwPk7GvRMFnzoDpdZVhJQl1pJ84Xs-ipQaP38,108431 +../../Scripts/check-node.exe,sha256=OFMtvCEOZ0XQpuD7EI77t-d8c0P7VPlrLpXGNYuUofY,108429 +onnx-1.14.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +onnx-1.14.0.dist-info/LICENSE,sha256=Pd-b5cKP4n2tFDpdx27qJSIq0d1ok0oEcGTlbtL6QMU,11560 +onnx-1.14.0.dist-info/METADATA,sha256=-OO5zz-LSl3gkhnTVEWQfRKP2gnW0qeUJMlHYVIUIAc,15641 +onnx-1.14.0.dist-info/RECORD,, +onnx-1.14.0.dist-info/WHEEL,sha256=eep6QWEFiQfg2wcclssb_WY-D33AnLYLnEKGA9Rn-VU,100 +onnx-1.14.0.dist-info/entry_points.txt,sha256=l3zggZCce6pRcl7vU8Kd1A5l4GMaYMdV7LCKJtH97Fg,157 +onnx-1.14.0.dist-info/top_level.txt,sha256=fok5iu7rojicZZye7lCMdLme_jvte9jjDqYyhL0Kg6E,5 +onnx/__init__.py,sha256=LnOoq0kw67NH5RAw_cabj_M1d-XZPUZqjwDyvT1ybOw,9516 +onnx/__pycache__/__init__.cpython-39.pyc,, +onnx/__pycache__/checker.cpython-39.pyc,, +onnx/__pycache__/compose.cpython-39.pyc,, +onnx/__pycache__/external_data_helper.cpython-39.pyc,, +onnx/__pycache__/gen_proto.cpython-39.pyc,, +onnx/__pycache__/helper.cpython-39.pyc,, +onnx/__pycache__/hub.cpython-39.pyc,, +onnx/__pycache__/mapping.cpython-39.pyc,, +onnx/__pycache__/numpy_helper.cpython-39.pyc,, +onnx/__pycache__/onnx_data_pb.cpython-39.pyc,, +onnx/__pycache__/onnx_data_pb2.cpython-39.pyc,, +onnx/__pycache__/onnx_ml_pb2.cpython-39.pyc,, +onnx/__pycache__/onnx_operators_ml_pb2.cpython-39.pyc,, +onnx/__pycache__/onnx_operators_pb.cpython-39.pyc,, +onnx/__pycache__/onnx_pb.cpython-39.pyc,, +onnx/__pycache__/parser.cpython-39.pyc,, +onnx/__pycache__/printer.cpython-39.pyc,, +onnx/__pycache__/shape_inference.cpython-39.pyc,, +onnx/__pycache__/utils.cpython-39.pyc,, +onnx/__pycache__/version.cpython-39.pyc,, +onnx/__pycache__/version_converter.cpython-39.pyc,, +onnx/backend/__init__.py,sha256=HiuD-U6YHJwWikkemKJqBq-35U8KJ9LDdAwdisi7OlQ,85 +onnx/backend/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/__pycache__/base.cpython-39.pyc,, +onnx/backend/base.py,sha256=7u6geTVT7AWKxNUzdOzWCutZpHktk1z8sg1wGKvxbFM,4564 +onnx/backend/sample/__init__.py,sha256=MjnSJkhE5WRkgjDth11gAVMfwxSlx0ovv7aIX2e6L8g,84 +onnx/backend/sample/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/sample/ops/__init__.py,sha256=zf3CEzbcJnTanRw-mDRnMwFibu2fvUflOzD0xJ-z2MU,854 +onnx/backend/sample/ops/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/sample/ops/__pycache__/abs.cpython-39.pyc,, +onnx/backend/sample/ops/abs.py,sha256=Gw4N0HjGtNC8xikiDQSF96XGjR4DqvJWjLEJ4RRJ4ek,165 +onnx/backend/test/__init__.py,sha256=5S8xMcgTHXxEh_GVF5EHUppM7Qhar-8zjnzrpsbmz9Q,204 +onnx/backend/test/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/__pycache__/cmd_tools.cpython-39.pyc,, +onnx/backend/test/__pycache__/stat_coverage.cpython-39.pyc,, +onnx/backend/test/case/__init__.py,sha256=pyZJLaPE5b2baJuwZPMNVleuIHhPPAyy9GJDO-eQjOs,378 +onnx/backend/test/case/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/case/__pycache__/base.cpython-39.pyc,, +onnx/backend/test/case/__pycache__/test_case.cpython-39.pyc,, +onnx/backend/test/case/__pycache__/utils.cpython-39.pyc,, +onnx/backend/test/case/base.py,sha256=Em2ccStUqDnY0kOwqXPtJvDVYr7Ea4w6mbAQmCXp_aI,1520 +onnx/backend/test/case/model/__init__.py,sha256=u0Mjj1Vy4FMS0sBvUrS45Tvk41qIbbc35XRVC6a9Xu0,2239 +onnx/backend/test/case/model/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/case/model/__pycache__/expand.cpython-39.pyc,, +onnx/backend/test/case/model/__pycache__/gradient.cpython-39.pyc,, +onnx/backend/test/case/model/__pycache__/sequence.cpython-39.pyc,, +onnx/backend/test/case/model/__pycache__/shrink.cpython-39.pyc,, +onnx/backend/test/case/model/__pycache__/sign.cpython-39.pyc,, +onnx/backend/test/case/model/__pycache__/single-relu.cpython-39.pyc,, +onnx/backend/test/case/model/__pycache__/stringnormalizer.cpython-39.pyc,, +onnx/backend/test/case/model/expand.py,sha256=JUj0XXNYUmfRBEPkWUll0MrR14vsMBfw6z5tP8j1i1U,3314 +onnx/backend/test/case/model/gradient.py,sha256=9S--mmzK5Hb9A8uKFue3uraYScAY-C4Wx0GTP688AjM,4084 +onnx/backend/test/case/model/sequence.py,sha256=7gdNQEv4wBg87G5f7wayUnxuEnq315ZXfdeNxZSOyuw,16988 +onnx/backend/test/case/model/shrink.py,sha256=Rs5afaaTAznFYgUlsxk-dEILG7dq0bdYnSc1FHtzrAU,1206 +onnx/backend/test/case/model/sign.py,sha256=ua6dvQozKLCwzlLrcxykoFR3P3g0nh7z3RLnOW_ljDk,1151 +onnx/backend/test/case/model/single-relu.py,sha256=zFSV3yVV02dn4UT8oL_hPXAt1IUHU5qpVb7nxjKEKMc,1086 +onnx/backend/test/case/model/stringnormalizer.py,sha256=p5dapxdh4aGCETHNXQh87wB3Mf8hlL7HDxwm12iyNds,6349 +onnx/backend/test/case/node/__init__.py,sha256=odHzLwD-o_RRS7Dms2rl7MVxqsGtojIINHiRb7spWFc,15715 +onnx/backend/test/case/node/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/abs.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/acos.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/acosh.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/adagrad.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/adam.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/add.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/and.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/argmax.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/argmin.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/asin.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/asinh.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/atan.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/atanh.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/averagepool.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/batchnorm.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/bernoulli.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/bitshift.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/bitwiseand.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/bitwisenot.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/bitwiseor.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/bitwisexor.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/blackmanwindow.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/cast.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/castlike.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/ceil.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/celu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/center_crop_pad.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/clip.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/col2im.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/compress.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/concat.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/constant.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/constantofshape.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/conv.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/convinteger.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/convtranspose.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/cos.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/cosh.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/cumsum.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/deformconv.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/depthtospace.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/dequantizelinear.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/det.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/dft.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/div.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/dropout.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/dynamicquantizelinear.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/einsum.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/elu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/equal.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/erf.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/exp.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/expand.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/eyelike.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/flatten.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/floor.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/gather.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/gatherelements.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/gathernd.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/gemm.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/globalaveragepool.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/globalmaxpool.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/greater.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/greater_equal.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/gridsample.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/groupnormalization.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/gru.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/hammingwindow.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/hannwindow.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/hardmax.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/hardsigmoid.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/hardswish.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/identity.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/if.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/instancenorm.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/isinf.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/isnan.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/layernormalization.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/leakyrelu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/less.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/less_equal.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/log.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/logsoftmax.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/loop.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/lppool.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/lrn.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/lstm.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/matmul.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/matmulinteger.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/max.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/maxpool.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/maxunpool.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/mean.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/meanvariancenormalization.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/melweightmatrix.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/min.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/mish.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/mod.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/momentum.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/mul.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/neg.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/negativeloglikelihoodloss.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/nonmaxsuppression.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/nonzero.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/not.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/onehot.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/optionalgetelement.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/optionalhaselement.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/or.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/pad.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/pool_op_common.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/pow.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/prelu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/qlinearconv.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/qlinearmatmul.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/quantizelinear.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/rangeop.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reciprocal.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reduce_log_sum.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reduce_log_sum_exp.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reducel1.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reducel2.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reducemax.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reducemean.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reducemin.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reduceprod.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reducesum.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reducesumsquare.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/relu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reshape.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/resize.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/reversesequence.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/rnn.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/roialign.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/round.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/scan.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/scatter.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/scatterelements.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/scatternd.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/selu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sequence_map.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sequenceinsert.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/shape.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/shrink.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sigmoid.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sign.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sin.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sinh.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/size.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/slice.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/softmax.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/softmaxcrossentropy.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/softplus.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/softsign.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/spacetodepth.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/split.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/splittosequence.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sqrt.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/squeeze.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/stft.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/stringnormalizer.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sub.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/sum.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/tan.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/tanh.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/tfidfvectorizer.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/thresholdedrelu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/tile.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/topk.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/transpose.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/trilu.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/unique.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/unsqueeze.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/upsample.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/where.cpython-39.pyc,, +onnx/backend/test/case/node/__pycache__/xor.cpython-39.pyc,, +onnx/backend/test/case/node/abs.py,sha256=RBfzepQNsr-IjM03bvCm865oYD6B-IpX2J2AJQ4GkFA,597 +onnx/backend/test/case/node/acos.py,sha256=AKANeRyLZk1z4XtXVe2EvLe9d_paOXGK0r518zPsh1M,718 +onnx/backend/test/case/node/acosh.py,sha256=gB-VP6wMvYlu7MhoV6TqNBKIA58rJus1Re3PFo7g_zc,789 +onnx/backend/test/case/node/adagrad.py,sha256=8TRECQRjfusWnI0_R4DmQBLdx9M6LYkXaR2seqvimp8,3811 +onnx/backend/test/case/node/adam.py,sha256=mf7bOZJLCEXddiCbpEwNZep9FS02B2sidUrLAhSI858,4494 +onnx/backend/test/case/node/add.py,sha256=jimqUMeTfX2S4pPqOQmi_QqsBgyrcgNtlHVXgR7XbHY,1387 +onnx/backend/test/case/node/ai_onnx_ml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +onnx/backend/test/case/node/ai_onnx_ml/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/case/node/ai_onnx_ml/__pycache__/array_feature_extractor.cpython-39.pyc,, +onnx/backend/test/case/node/ai_onnx_ml/__pycache__/binarizer.cpython-39.pyc,, +onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py,sha256=t5EKOtgQNy_5R-fzYvE_qZNRAEHs2LmVmKugyZkgFPk,821 +onnx/backend/test/case/node/ai_onnx_ml/binarizer.py,sha256=Gh466mWWMEZRwJAYrGcX3120PnhxArb77GQCEOc6arg,773 +onnx/backend/test/case/node/and.py,sha256=8CB1KZFAgryfLmPVzvuzNt38VeYpyXuozJPeh7-tNXE,2544 +onnx/backend/test/case/node/argmax.py,sha256=tOW1Shz852_niwhyGASasb6rBk6cb9pdkEyoOaWJ-JM,8580 +onnx/backend/test/case/node/argmin.py,sha256=TjNXPcbc6hDAcoNSTJXlJ9SO1MLdTpufTZpXXonoa3U,8662 +onnx/backend/test/case/node/asin.py,sha256=6t160N-u_Fo58qEDRuUcucumoY8wybFKg6ovWlGIbOI,718 +onnx/backend/test/case/node/asinh.py,sha256=yV0NjgaQKQC0F4shc3fIhgz7mrkDITxDPwIrLTnLK1o,772 +onnx/backend/test/case/node/atan.py,sha256=dhsMycFILHxUAwrKnfxdhrwb09PpJ1YHk98gqO9reXo,715 +onnx/backend/test/case/node/atanh.py,sha256=f4_imuKc6cq0YXtah6pGWAScIJw4A0oqFlqbSEID1R0,790 +onnx/backend/test/case/node/averagepool.py,sha256=HHBjVX-viJDLezqhvhN40XxLqe_lRYPaoCwiwZebh8c,15654 +onnx/backend/test/case/node/batchnorm.py,sha256=uOTmYD6vyh4dI_Y_pcvdvERMIdlK0O8HiJrSSsf0DFo,4865 +onnx/backend/test/case/node/bernoulli.py,sha256=gNc357ZsJArquIvGi6ZhGmv2G9xkgiZfRLwJL3hfww0,1909 +onnx/backend/test/case/node/bitshift.py,sha256=_u1KTijrr84NREDhTPXPcjeBfWCDWJlPcvDbehzTMBk,3645 +onnx/backend/test/case/node/bitwiseand.py,sha256=oJmtyHDWe4i-9hwsX2VM66_iRVffHmzpZfwROBj2D_s,1708 +onnx/backend/test/case/node/bitwisenot.py,sha256=XRW57NfcO7LoycCA4dk7h-1k93ORdD2HuYmAED1CA5A,1021 +onnx/backend/test/case/node/bitwiseor.py,sha256=MVhAOweUPXhQQR-iWu1aKZvgRUvpyDgvHaPoPl2neoo,1672 +onnx/backend/test/case/node/bitwisexor.py,sha256=jd3H089qlL1jKkCIB3tYGT2NQr5IGtBkUVJadOuMh0I,1707 +onnx/backend/test/case/node/blackmanwindow.py,sha256=ibxHbuj7Tvsuwc4eDJKjE397OjDy7GqaOW3Vu4D74yI,1397 +onnx/backend/test/case/node/cast.py,sha256=J5k_RPvcFqLqRisb4tFj2rPIASLzWSmGIWEA2oZJwZI,14281 +onnx/backend/test/case/node/castlike.py,sha256=a_Fm09MzD4GcNpk53xLroFYj-8ppcMpNi3zIAbwk7Rg,9796 +onnx/backend/test/case/node/ceil.py,sha256=JJC00exuaBbmMK-ktb7ec_yqpX7PlyxTvmS824003vU,741 +onnx/backend/test/case/node/celu.py,sha256=_Prleafe_PZKATvg-mj5LYjlofgpvZeQ0a0iogCWONI,1584 +onnx/backend/test/case/node/center_crop_pad.py,sha256=8XgDSdMOzKLLezf4CoY60zfJGn__Ql46oNDyHWMuE5k,4033 +onnx/backend/test/case/node/clip.py,sha256=FJGc-mka84_ZxgeA9lSRg6F12HmDpnAofG5xOO62ar8,4349 +onnx/backend/test/case/node/col2im.py,sha256=9SPSnQ6xr9rhzv49h7jgYYm8MCqOamRsS4r09riL9us,11468 +onnx/backend/test/case/node/compress.py,sha256=kTJNkFlzx_LutIb-TdKTHnyDHsWpFcBEaCuWDw1rlXU,2809 +onnx/backend/test/case/node/concat.py,sha256=RMQkGNTOMqY0_bCkZWC_xZXje8CUw-kABic8CCGxFak,1914 +onnx/backend/test/case/node/constant.py,sha256=f2d2dbQ1P3hZivRXcxdFVsb9TeViWnOApZn8OoeqI3k,794 +onnx/backend/test/case/node/constantofshape.py,sha256=I6pxOMu-hbldJ3E_JFUL4ckp6drJLBiskXOvkBvjAY0,1900 +onnx/backend/test/case/node/conv.py,sha256=gsfmgQm1B3jzl-0fETTaQMwED9W9EPVRv43izwr4F58,8394 +onnx/backend/test/case/node/convinteger.py,sha256=6BfHtCkF2s8y4kdbq3iCQFX-Q0QDMUcqsJmvvQeRm2k,1940 +onnx/backend/test/case/node/convtranspose.py,sha256=t6ixDwQbQ3Jg-2PNj5dwax-dFBInKgHJauE-ndCtR08,16822 +onnx/backend/test/case/node/cos.py,sha256=Iqu8yEAI4NQu1b5vVXal45vrJwyrS-YsR4CL-J1M5p4,705 +onnx/backend/test/case/node/cosh.py,sha256=paohiM1-bYV3Uq5AeXM1MCXW_kPPabXA6vG7htVotfY,761 +onnx/backend/test/case/node/cumsum.py,sha256=dtoV_Rg1opPwMpx-jW6ItihP8roPkn5Ymp0brSt5jOQ,3482 +onnx/backend/test/case/node/deformconv.py,sha256=0kKFJlA45N3OE4YuSr_abaYqIXyDYEAnoEmiO1SyTKw,5647 +onnx/backend/test/case/node/depthtospace.py,sha256=UEryt7YdGewSq0dD5yzN5EVul5yOBkjaUFna9bt2h2Q,3632 +onnx/backend/test/case/node/dequantizelinear.py,sha256=xj1EyQRHP1D3TKkmRPPs8QYZxA4QyEVLDAEbyGPEHOM,3144 +onnx/backend/test/case/node/det.py,sha256=aYZlgjZu0qmYUuuv6-6lZ4tW9CHr2PS6VU3wAL9KJ-U,1012 +onnx/backend/test/case/node/dft.py,sha256=9Mh4n6idB69edwxUK4EssbT0rbcNQqoLrLwlxzoI51A,1553 +onnx/backend/test/case/node/div.py,sha256=ae1QwxAnnhDkISGSWNDVNsScveoTTYDkqSRSYLWuro0,1475 +onnx/backend/test/case/node/dropout.py,sha256=b-QKqUFH9QE83bKgAn6XB47Mn-MmNhCoQPc7GbC17RI,6572 +onnx/backend/test/case/node/dynamicquantizelinear.py,sha256=skAc3Jtdsf17l5kj3QCj4wA0qNvsE1Q2yKmez9-jPA4,2511 +onnx/backend/test/case/node/einsum.py,sha256=RU6eRYkPccaryXt6KTmdF-_8Nd5cs4kYJ9r8GQ80R58,2414 +onnx/backend/test/case/node/elu.py,sha256=TyDE8lxzVqh5KvioCR9_NRw202pYJnEPLbzxRHdujh8,1260 +onnx/backend/test/case/node/equal.py,sha256=kuNB7U2DbO2Af_5ybKzWxmRYjl9VP9UuQC0vXfg61Fo,1943 +onnx/backend/test/case/node/erf.py,sha256=-ycgPKYQRHkGjkmfVxTmOHqFsaM1IrcJPQNetlRvo0A,610 +onnx/backend/test/case/node/exp.py,sha256=A-IhToYyLv1EC-h7NMp8oyXEI6s3RRd8lcDtnJNG24Q,753 +onnx/backend/test/case/node/expand.py,sha256=bRy5JQzBTihoI3UmfHxPWgHzK2kKTQSPCNLbLXK1yok,1977 +onnx/backend/test/case/node/eyelike.py,sha256=eSwgqOd7BS_8wO5PLks9yaW20_smRu_t8NLiib0smk8,1773 +onnx/backend/test/case/node/flatten.py,sha256=WuVnLB7ilSUoAxzLbYGZj9Ai_7tZgAD61_55-70PnRQ,1961 +onnx/backend/test/case/node/floor.py,sha256=rFm2LtaR4HaKJZKK6phUBddxoS99M9BLVdQakq3YY-s,754 +onnx/backend/test/case/node/gather.py,sha256=FOlQm6jfEQTB7kO5lM9zHhjc_LZVvnYsvC66AbQVo3c,2433 +onnx/backend/test/case/node/gatherelements.py,sha256=lxe8-vzwORGVxpI6rMfxlHlKiiRbEZOG5rpf8wj7Mws,2748 +onnx/backend/test/case/node/gathernd.py,sha256=LOg8hzJOZPgbrUoqj4GuobJS_sjdVROaCAPpZoumeqE,4128 +onnx/backend/test/case/node/gemm.py,sha256=tLBS24QYvh4m1t3vVHBo4jO1S5LSmxWwWqMa3hIXthg,6077 +onnx/backend/test/case/node/globalaveragepool.py,sha256=lm-cNtoM1GxpJ3qhg36vOMeZZ4nPLs5r0Ds4kmSNCvw,1282 +onnx/backend/test/case/node/globalmaxpool.py,sha256=mJCSOreG3leR0zgrR_eY11M_bZDZlf_R5wv8W_5x4Qc,1257 +onnx/backend/test/case/node/greater.py,sha256=CblNiI3LVv5CTVn2_SsA6AtcE9F2hwMIn0V96R878cM,1068 +onnx/backend/test/case/node/greater_equal.py,sha256=VjKtEMOp323V_Ns_4vuTccGXsuBmf2L3D_J7kJfFZQs,1118 +onnx/backend/test/case/node/gridsample.py,sha256=QdtTuwKY5Cnho_mkwLh0GzWSl8kM5rP31HeZD33L69A,10856 +onnx/backend/test/case/node/groupnormalization.py,sha256=OCTuWoc0BzFVawzhCabsg6juxg_v4TxQKO6J9ZK7FIw,2474 +onnx/backend/test/case/node/gru.py,sha256=HhkvWMnj29t-7bEPteK3SSYFTfHDQ5zhNNQ3H8Vj-hE,8124 +onnx/backend/test/case/node/hammingwindow.py,sha256=1FSdXcwG50-OrSP17dv16ys9f5VIEZGnHq3tYf-s6-Y,1160 +onnx/backend/test/case/node/hannwindow.py,sha256=NqKFRQwvBBgnr9WF07i9jWZYGmrty8bgARCX93-kZg4,1131 +onnx/backend/test/case/node/hardmax.py,sha256=8e_vVto8LPaOCS8GiHVihEpBFZatr4Zb_aBxdtMoREE,2715 +onnx/backend/test/case/node/hardsigmoid.py,sha256=BqWfQ-n8Tj2vnDyHoezt_COkqkCiR3ZVFFHxrRHsBAs,1259 +onnx/backend/test/case/node/hardswish.py,sha256=IN4WzGQqxfI0YN9SxYQtcxwGAokuQEnLiZG8aIVkYb4,728 +onnx/backend/test/case/node/identity.py,sha256=oYx37jq_a-8hpni8pn7fktF9GL_EOcDWkTRQWsJiiio,2426 +onnx/backend/test/case/node/if.py,sha256=VeJutW2yiYCxDwjyewkI4evI-HU3UIEVBos_MfIJOBE,6680 +onnx/backend/test/case/node/instancenorm.py,sha256=OzS3A-kW8vJF5M8hsX28hA3I5lOteBkB6u7MBX5aoak,1965 +onnx/backend/test/case/node/isinf.py,sha256=IJ-1NdmnOJTM9P4UBawgazwx4895N7tERmbM042Bqhk,1364 +onnx/backend/test/case/node/isnan.py,sha256=2ypmdyvsDSszIzXHRWbkiVn9D72v0pII6oGd67XzhB8,574 +onnx/backend/test/case/node/layernormalization.py,sha256=qMrsw5l3fjgll-noebNtXqG4NppvufxDjuQflPxKcXI,6491 +onnx/backend/test/case/node/leakyrelu.py,sha256=HM1yPN9NB2oVWINulZPr1WrcN13etBOg-hqB0c5ISXc,1279 +onnx/backend/test/case/node/less.py,sha256=j-hcre56nDUVlp-uml66g5ZPaRJy81baUOm5s1EXbHM,1038 +onnx/backend/test/case/node/less_equal.py,sha256=fwXjoVSCC_D30I7n_Y7Fcm-kpMtLyfyQc_KRJsfNeIQ,1088 +onnx/backend/test/case/node/log.py,sha256=7XI8ZBxtu6eqPoBOZS-KisBMvg_Iq5vpNvGq0g2GcAw,746 +onnx/backend/test/case/node/logsoftmax.py,sha256=4t0Fn7Vm_wFLAhynuMXzUN5JzMpz0L7KIT7zYH_wk6s,2829 +onnx/backend/test/case/node/loop.py,sha256=ywCTLrnAzG-o466POT_Ww_EHOWmMkQdqCl226-ISKZI,15176 +onnx/backend/test/case/node/lppool.py,sha256=TinzEnsWNrjyOf0qv8I5fgCdjg71AF9l6NAGxpCBgmo,8746 +onnx/backend/test/case/node/lrn.py,sha256=g3z8BZwIBhjH0XbCXb_HQLpjlluV1JPgK-oj-MyXV94,2150 +onnx/backend/test/case/node/lstm.py,sha256=gECdrFbEVVPdYGB3gAAW-9Kk6ecDavxePQNLNp5mL1M,8537 +onnx/backend/test/case/node/matmul.py,sha256=Imyh6ACatzG4OSAzFdYFD8A9HbY_AvslZBPb_Gx6jVY,1116 +onnx/backend/test/case/node/matmulinteger.py,sha256=c2CBzRt-Kil2GBR9hyP997cAuayuufjuVKsTp8Ja_po,1355 +onnx/backend/test/case/node/max.py,sha256=pRC6brP6A6P7buf7hUe5uv9_QiA-_mvA1hMnoVHdmFs,2074 +onnx/backend/test/case/node/maxpool.py,sha256=qUj3M-W_aWoXMupndFFZQNMDFjxOtKYkR0sMYsfv5BE,16291 +onnx/backend/test/case/node/maxunpool.py,sha256=FIW7ih5PJrAbZgaMoHUAQ8JpBC1-TOK6vmIJK23Ylck,1985 +onnx/backend/test/case/node/mean.py,sha256=SNwYH0o7-4nybtk1JLgNW8Twp2tXpEuVgZ6qTmhniD4,1378 +onnx/backend/test/case/node/meanvariancenormalization.py,sha256=15ub97LVsB61jakyPzYqQMu2kq-GbJmMj3eR_sm83yY,1735 +onnx/backend/test/case/node/melweightmatrix.py,sha256=dLNBX9h56t09-qa_zEhnWD7HALFo_IalEDdO_YYai54,3754 +onnx/backend/test/case/node/min.py,sha256=TWsKC5EJ0T2iGO1Tzkahk-T9G0LjZQdyT3Lh2pym7uE,2074 +onnx/backend/test/case/node/mish.py,sha256=lCh2qsME-ttOCdR0-G0GDoSOwW-apZ4Td8tu5NU-0A4,642 +onnx/backend/test/case/node/mod.py,sha256=kopByyPkJGMNf4eHjY7v2fQUPtnNRQPbKL0FlLwCHNs,6392 +onnx/backend/test/case/node/momentum.py,sha256=eKludRu0L63hBT_7ENEvbOkGs5nXhJwy1pAfSgT23vQ,5451 +onnx/backend/test/case/node/mul.py,sha256=5gAaj1wkZFIhrHG-jkuK813dQ2rUVK_kJH4YeT51P74,1471 +onnx/backend/test/case/node/neg.py,sha256=6eCnBhgh0neipZJwOACgXUHMT6bIdtFQehlB79r80sE,742 +onnx/backend/test/case/node/negativeloglikelihoodloss.py,sha256=erC7RL7OG3uj4_iyd_cIzRbIcxHjv33hLU5x4843dlU,20200 +onnx/backend/test/case/node/nonmaxsuppression.py,sha256=S7hus38R1hHXkEi_RDcbcyqkTGvMqtJsDa8U5UbBATs,14277 +onnx/backend/test/case/node/nonzero.py,sha256=uvkfhBB6d5Ol6SXxdNn_Cp4Qc7GPiMQSsaRIMG6QkRo,713 +onnx/backend/test/case/node/not.py,sha256=R7wk1Z_J3JK3x_YFmAE_F-AsPNVaPZtJS5h3KprYdPA,879 +onnx/backend/test/case/node/onehot.py,sha256=0vvPfgAh0Qv-eShtxL2yAZmarE-UKUDr_teCRGpx_9I,4070 +onnx/backend/test/case/node/optionalgetelement.py,sha256=kgHkVB5iXH66GNi8nbQgkUk0korRjeh6iSk4gT-QPSg,2603 +onnx/backend/test/case/node/optionalhaselement.py,sha256=NlDQ-pS2DB7eQXdndyMyBLR3EpACAsJGg5BRvQVK4KA,3487 +onnx/backend/test/case/node/or.py,sha256=sgNQ4B2d1HYyhnqg6r-sdPaMf-suPn8ZltLAKKRdt9s,2522 +onnx/backend/test/case/node/pad.py,sha256=7uMhkILi-GHqZJLdt6izsafw8casSDEnY-GG36CfKpw,4118 +onnx/backend/test/case/node/pool_op_common.py,sha256=HtK-EpErUsKcH8BF_XwR34-argquc5c5i2pnpHfpaCM,3755 +onnx/backend/test/case/node/pow.py,sha256=JW6nUmdkIG6Ny8rRQavEhyMlJYu-ywzE-RJ6YbR9kng,3945 +onnx/backend/test/case/node/prelu.py,sha256=2mc_P13n4GYWE50wcvIhNoyIxmppmrBqq0et5O5ZEck,1160 +onnx/backend/test/case/node/qlinearconv.py,sha256=NcqkNkS24rCnTDHpLTePunkIwSdHt6mAlNLGF800oEY,2341 +onnx/backend/test/case/node/qlinearmatmul.py,sha256=YYFL1T-bEfJmephO6k2m6uokJeZNWBfubV8oiyt4AXE,3226 +onnx/backend/test/case/node/quantizelinear.py,sha256=EAwAvfvgjsl64B0gFTjAYKQ6KN8ymcLBGefWWtbmaXg,3242 +onnx/backend/test/case/node/rangeop.py,sha256=p7Lz1xygHPHRUrfInf5FS2RBMhFL67kdLbyQxvxE2Ls,1491 +onnx/backend/test/case/node/reciprocal.py,sha256=34LwMciBx7lM5-KpzaDSCa5dL3VXblfLVpwoF8N1_48,782 +onnx/backend/test/case/node/reduce_log_sum.py,sha256=r8odZYy5asYa-13qwTsUDQ4SGKa3z3zKFD9mAmFilPM,2448 +onnx/backend/test/case/node/reduce_log_sum_exp.py,sha256=jrbH3rv7tFQSa_TdmkvM5BmAQwd3yhIapi7dmFygZOs,5217 +onnx/backend/test/case/node/reducel1.py,sha256=66kb_gI2tBZociS1I3IGDZC24L7iOiOYM8iEJ0IuG8o,5092 +onnx/backend/test/case/node/reducel2.py,sha256=yyAmEgXM_izhdj3uwaOFLJjwahiYTZyyhUehfM7j_DM,5518 +onnx/backend/test/case/node/reducemax.py,sha256=8ppJKK05PlKnsmNF939mHpns_7Je1xfL9rBsGjM4d3Y,4860 +onnx/backend/test/case/node/reducemean.py,sha256=NGi1BwNn32FsVFSAd7g72F3x4LAY6RrgVGN-NQ_8PMA,4944 +onnx/backend/test/case/node/reducemin.py,sha256=AFxi7V7ESa3Vke8RKpNUo3zu_pDM7e4jFhjER-jKfj8,4906 +onnx/backend/test/case/node/reduceprod.py,sha256=QrymKQvTM9Q_aZO4z8zYufKfu7QT5BhV7pQwWmz7Tqo,4786 +onnx/backend/test/case/node/reducesum.py,sha256=8eTh6nPLk2Qf2JBynkmXv9GrxwdvAWgfeiCLDwcQ4Xc,5878 +onnx/backend/test/case/node/reducesumsquare.py,sha256=8NXwXzh0QPtUullZK3ai112UAKsd3yjsxhliRMadUfc,5036 +onnx/backend/test/case/node/relu.py,sha256=WTdC50jBMZR2rctVtNrQU-UvQ5DuROMPSB1EwKZjodQ,570 +onnx/backend/test/case/node/reshape.py,sha256=Dwks9zBBuGz4kHBXOiZx5iTSKiXcArj8T3ltUhvIjsQ,2960 +onnx/backend/test/case/node/resize.py,sha256=kyJAM49qHisRr7O7_3vny9btEgeeg6AT9z_qEZURU_E,53329 +onnx/backend/test/case/node/reversesequence.py,sha256=mjWpMXMukWlw4UZmImkpABcDSbs8_ig06HLbowF-Pkk,2290 +onnx/backend/test/case/node/rnn.py,sha256=jzukI6ExNJKhlPYa9p8DPLM8udP7sSKRkYJbCFIXC0w,6635 +onnx/backend/test/case/node/roialign.py,sha256=3B9VJcY1jN3oCOO7BQ9TVUzN70LTuIztLw_b527TN3s,15330 +onnx/backend/test/case/node/round.py,sha256=-ElfKi8Z5sCrSkt5cPifbVLmALuGZJb8Tv07eZtaLGY,1362 +onnx/backend/test/case/node/scan.py,sha256=2bQx3HdcoyjmutW4Jd8dJEomvIqtuIdcRhNo7CYzdkI,4385 +onnx/backend/test/case/node/scatter.py,sha256=8CFOuXyhb-ZjrSbbZzbrhas9eEA357VcRhftimLIwlE,3354 +onnx/backend/test/case/node/scatterelements.py,sha256=8RGcHpvTAi4p1EYHjQoVeM2BYhsbRXmvAIEyeM36p1Q,7629 +onnx/backend/test/case/node/scatternd.py,sha256=b0VWnwJw4jpp8F8bSTxGDlUSI0wrgpLCZk25xolRWyk,8830 +onnx/backend/test/case/node/selu.py,sha256=3Jqr74W85o-XzvKkMPf4Q5dv1f_4AMtJBMfdxEx8vxA,1549 +onnx/backend/test/case/node/sequence_map.py,sha256=q5mGriN83qKB93Lw1HF64k6J89-z9LLyVaCrce3EoLc,11220 +onnx/backend/test/case/node/sequenceinsert.py,sha256=CuE0HchFa3b5AmhHlQHKdFyuKS4QxrBgyGllRq476qc,2634 +onnx/backend/test/case/node/shape.py,sha256=99FbM0VPVGgfv9pSBx3cpjV0WX17-7USf-5-RQ0Evts,1557 +onnx/backend/test/case/node/shrink.py,sha256=YYJIhSU8RaZf6AyZRqiHhdp0G7mTFDTSJClisqSViSA,1054 +onnx/backend/test/case/node/sigmoid.py,sha256=7Yl5VwkxtxW1IpzaI9WDUtRMrmjQaWB7567Kc8uwHpo,847 +onnx/backend/test/case/node/sign.py,sha256=Td-mRwd33PRHTHK3FpNEXXolVE7xRIJXSlVUGqNioo4,557 +onnx/backend/test/case/node/sin.py,sha256=4YBsdp7tQw_636LgJHBycStCzDw9KgIxyr6ZraCn0co,705 +onnx/backend/test/case/node/sinh.py,sha256=hr6lU5muwqnhZBZrm1Pa9Dd0up6zV0xBre76yFzsl4g,762 +onnx/backend/test/case/node/size.py,sha256=mTXvM9xhQZFjDWRaXDiqC4nSybPbCmR9__x4od1uda0,842 +onnx/backend/test/case/node/slice.py,sha256=5Y8-3T5ADfEZ21XkJ4sOWhmsDXg4r3TFJHPjKairFcE,5412 +onnx/backend/test/case/node/softmax.py,sha256=Awhlvai7B3i2cS9bPC1-T0Ag5r3I4HbVckhJ5GT88PM,2741 +onnx/backend/test/case/node/softmaxcrossentropy.py,sha256=ynxKKUZwTKpQekW8cBE4ygizxEi2kWASdLJ4FWcKXRU,36689 +onnx/backend/test/case/node/softplus.py,sha256=uRBDt7bRF2TsmA92FMOxoOCukLkENetIThYpzetTolk,829 +onnx/backend/test/case/node/softsign.py,sha256=aR55X3_0Vy0HXAZ5UDl_E2reKMrsmtS8kBsJP8Acwog,769 +onnx/backend/test/case/node/spacetodepth.py,sha256=_7WL1knRWXeoR9I4h5ForniwQ8dbclDo8BlD1loVWIk,1969 +onnx/backend/test/case/node/split.py,sha256=OM5svlonceyKpb7m4Qs56iYaBORbknEwYfh8WHHKiy8,12187 +onnx/backend/test/case/node/splittosequence.py,sha256=oXSqqjnvk4nu0diOh5n54vOJFhF6qNSSSw8_6LpxBvc,2177 +onnx/backend/test/case/node/sqrt.py,sha256=USQsvqWOrWJ_0kGiHosKcJeYQFn0NH9qTsF0rJMCr1k,750 +onnx/backend/test/case/node/squeeze.py,sha256=cdzQUDY2rwGFSBl-0sawK7o82BmsBcwmijtwrcLnAPQ,1088 +onnx/backend/test/case/node/stft.py,sha256=4E5iXLdv-b8dy4m52bvDvWwgTgbI4s-cfneOT7PLv34,2297 +onnx/backend/test/case/node/stringnormalizer.py,sha256=qq4ppjNSBm07HqyFzRR3Dkv0u5F2geZ4bvEDneVwm4c,4540 +onnx/backend/test/case/node/sub.py,sha256=iYvsLgREsRNAMyTjFLu_X3Tlu--_NoxEUuhoDGTzS0U,1475 +onnx/backend/test/case/node/sum.py,sha256=QB8OfhM0Q27U2PdJh8UE7yAmMaA90iHhVyzkQC_uTjk,1356 +onnx/backend/test/case/node/tan.py,sha256=_lMQ27GbS52rF_DSxZ0FcFfu64XI5aInnhoFi-5GWw4,705 +onnx/backend/test/case/node/tanh.py,sha256=JaxgXGGY7QjCqUqVBE88Ca1grqeEH88XR0RBAa2VunA,760 +onnx/backend/test/case/node/tfidfvectorizer.py,sha256=hAadMDUc8CrtFhR4ESdWo8i3Q3UYztViSHmCPF5rbRE,9096 +onnx/backend/test/case/node/thresholdedrelu.py,sha256=NlOKehvtFipnANZmtW1LMa6XKEYPgfmHf0Q2TcxKFoo,1303 +onnx/backend/test/case/node/tile.py,sha256=A2gMadWRxL7ZIW2hgxUrL04U0eOhAFsz6rh6l_RvcW4,1105 +onnx/backend/test/case/node/topk.py,sha256=8nTvRHGSn75ftvo8g1XSCZHeLmKXB7xGlmmsM2Kwlns,3629 +onnx/backend/test/case/node/transpose.py,sha256=yVh6-RJFDtO5eDPVQkS8GR3LX0hM83qYCD-97ZI9UCk,1402 +onnx/backend/test/case/node/trilu.py,sha256=5_VgNWUHX4rPliD6_U1aLmMoxr2Jqfyww0F-8uPw4CY,12963 +onnx/backend/test/case/node/unique.py,sha256=A6qPj27YpoBMKH0dtOPy4UAf5wlcAyGMTNnScnoqI78,5990 +onnx/backend/test/case/node/unsqueeze.py,sha256=CjIhyAhKgId1LszNOgzk9VOE2E-h6cgVeSZ-h1OFoVM,2822 +onnx/backend/test/case/node/upsample.py,sha256=PX-Kr8Vwr1xWGQmyHjWelXTHrMjT7IgnlXnOkMJth6c,1394 +onnx/backend/test/case/node/where.py,sha256=ewcNZvx-2-flKzIsVIbJLBP_Mdi0YGdQfWxULwBdZPQ,1336 +onnx/backend/test/case/node/xor.py,sha256=lhiOpaPeGItL3foXB5eyura2LMFRkNxLF8Y-KgHhcBM,2544 +onnx/backend/test/case/test_case.py,sha256=Guj0PorwgST9Nu-e8e3f-1XZCpEgICy2t7tROwpnUz0,571 +onnx/backend/test/case/utils.py,sha256=9ouupPOLY9XQZewyVLOh6wEm3QE25rmaIcUWfxVH7pg,1093 +onnx/backend/test/cmd_tools.py,sha256=r0FiUmhk6uaVmJYkZoGiZ8fgmTaGhEEW-rdLOWTN4Rg,7590 +onnx/backend/test/data/light/README.md,sha256=eYTWkgQOw8GI6ZYxtZDwQy4ry0VynJnjGmA8GCZ5nOU,482 +onnx/backend/test/data/light/light_bvlc_alexnet.onnx,sha256=Kvp4zvWoiu2dbj1j-5K9MwyRd6wVDRkYnGs-cgS6AhI,3968 +onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_densenet121.onnx,sha256=Sd21cSeX1hZPHYZL7arZJ95POQmtG0ujkKksL4FQ6fY,214344 +onnx/backend/test/data/light/light_densenet121_output_0.pb,sha256=9sxhMPy_kDFFImeGA7s9t-2POnl1SzfTrJXJouP03gw,4014 +onnx/backend/test/data/light/light_inception_v1.onnx,sha256=u3oObDcMcJ9WFe7vlhtDYo3hPQAJrk1vS_sNWupdgnA,36869 +onnx/backend/test/data/light/light_inception_v1_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_inception_v2.onnx,sha256=Ik131VsmVZqVnbYnw_QXpiP787MADSXwk5MnqpNdkz8,159024 +onnx/backend/test/data/light/light_inception_v2_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_resnet50.onnx,sha256=Bed6XJyc4JE_VJpQ1uus7V4P9oF7YeCbribkxb2QVeQ,79770 +onnx/backend/test/data/light/light_resnet50_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_shufflenet.onnx,sha256=xvQG1ivjbWtFclQsCVCiq9WfViNwaHkykGgLuon7r-U,67666 +onnx/backend/test/data/light/light_shufflenet_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_squeezenet.onnx,sha256=dwsPPIYj4Yv1i1N1TXEAUbTCaCSEIhQpgKEyu-bf6Qg,15618 +onnx/backend/test/data/light/light_squeezenet_output_0.pb,sha256=Mu7nS35YlymoBpJn3mW6aroogdDyQEGq6OUPaFMDwTY,4014 +onnx/backend/test/data/light/light_vgg19.onnx,sha256=jlR9cys6PWbuuPpkoCatuZTT21UvC71S5DbQYwDYmv4,9311 +onnx/backend/test/data/light/light_vgg19_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/light/light_zfnet512.onnx,sha256=ZES7WLmMPRT1UaO9uD7qnl234Ud5DbMRXER-nJqDOLA,4506 +onnx/backend/test/data/light/light_zfnet512_output_0.pb,sha256=l9a8wotq1zG8MoGosDBo0V-p1Th2m1skylRI6hQ9sQA,4010 +onnx/backend/test/data/node/test_abs/model.onnx,sha256=h-jIWjxawEAXgf0TJ6BKjux7j6yN9-gTsr7VE0QDkFo,97 +onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb,sha256=2BNZUVKdYf3atI3XSL8OIxRDqBjEfFBVuhwUGkp0ndA,254 +onnx/backend/test/data/node/test_acos/model.onnx,sha256=K4WDFhjPMxh8fwNbzIiJux_VbyQjjMhtigoNghdRKEA,99 +onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb,sha256=BcAjkpobMrS9vXiC_15TubU3Yu4pKcZr520PC6fKOT0,254 +onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb,sha256=91b_nhfgGTD1aqzRmvzK_7AhLn2h3sfpqHiLuu6qDrU,254 +onnx/backend/test/data/node/test_acos_example/model.onnx,sha256=BXaGG4ZgoPcLt19dp4JpRGCrBr9yeHfr0sDHckNlzH4,91 +onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb,sha256=cD3gw75QWnhZYjV4loK8Tm8OhSPzT7cxIHtMB2cBq90,21 +onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb,sha256=K2s964qJdp4TDGxtMjeynV0dAchEJfcNnxWvaSD8j_k,21 +onnx/backend/test/data/node/test_acosh/model.onnx,sha256=V7mDqrVOnldEoeSsikvbhVek3m_X4YXS5vCQWPsBIdU,101 +onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb,sha256=MKsiayDTOWEgFMmPTwo5lylyk7-MtQrhW849Ff1C4-4,254 +onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb,sha256=FpKlvkr_1yLSyC1OJu6pf8_-uF4GfnWsscu96x-kVqc,254 +onnx/backend/test/data/node/test_acosh_example/model.onnx,sha256=EdYmQO55mm3ioMis7Ib6-1kQWLeCMdPl2N3K2f230zY,93 +onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb,sha256=NXIAFi1g76Ag1nr5wiDIiE6ilson7_t0kC_Qf5Ln6vg,21 +onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb,sha256=Gz3pLNpKQQzxib-93ikXb5WzkZogQuo8gOMoAOPLPH8,21 +onnx/backend/test/data/node/test_adagrad/model.onnx,sha256=W_0zemXPwyE0IPoGhB64im07jPvvYjUJn8SVDyyUv-g,320 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb,sha256=turuCuY1a0B6_bhynwjX2Kq-OrJi3HnwRSCOt5BZBLw,13 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb,sha256=hrgodO3LVW_LxTbUiK9tBvLA2Q7WZtXUW9itP9oqfQE,13 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb,sha256=kfqSznBP6jN2IJsiqQ1IeGKqLx8m6zYDnfqkjX-hUmk,13 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb,sha256=oCKisBmEjpP3XB3VhImrZp-lrCfEuSFzdJEk7DIOAw8,17 +onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb,sha256=-92hjiJXMpo3i8AkkMBKfoU_6I8-YQetue7lzslQneg,17 +onnx/backend/test/data/node/test_adagrad_multiple/model.onnx,sha256=0GfKCSbRa93cMC5F1SMr2KKHV-IIViABzwaCNRfA-Zk,465 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb,sha256=zSCQaDJuSfjV89lOKl_e8FAvaYdDg6UrH2n4eykC9bI,14 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb,sha256=A-40FgJNucPNFb_WksbMy0Z-E_EIV7RF0DP90kqbbC4,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb,sha256=CxeZGajewrwPha-MBoCdOi3nXJYzF9DgbGhOIwIqx3A,14 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb,sha256=stCGvEbBW8itgJbkRX1pnKZir080kytSIuTmZAkh41Y,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb,sha256=1-flVrzPmKolD0GSh-ld1wYZxSEIUx0TUpi_0ywedqA,14 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb,sha256=elUimbVps7sroUEVgzsr7m7OElV1YF29zVkzYA0YS-s,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb,sha256=UKTIQ4M58_6bp-LBagOe_d4VRwris7IFZ3ni0bWiVl8,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb,sha256=ipVVDyNyv3SavMDXeF1dVfWDMwjlgqbW33nRydOBFSI,22 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb,sha256=HonHMpF_AzJUt8IAnJmpNSnf38ARw54VShRtI15DTLQ,18 +onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb,sha256=0tufwJtRaRjRTHCQZDr7_arrlGvjPhOTqvCZJT9X2yM,22 +onnx/backend/test/data/node/test_adam/model.onnx,sha256=w9Ku8dNLby8i4QDTbajJOUXBeRMdrmvFW9GX1MGla3A,371 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb,sha256=q6Wsydvsci5ZJNiqDej1Kq17QzS3xOPWEruuLIgoorQ,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb,sha256=NQkKr3rClZp31gGf1Oyh_ECrr2_5AMVYn_fNdDazT8U,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb,sha256=6upGRVU5-O-5zKXoDu6cRsc2F036k6N02w_CNPHBGqA,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb,sha256=_sQAc0yH7uQipbdJe_N9EV_eMVJNNTb0bYSrlveTHSA,17 +onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb,sha256=TVRVeKeatp47K62yu5zNe7emQcyoqRGVp2TET-REmdw,21 +onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb,sha256=rK6Zk9eax3tUns3S7Oa55LN4GA_v8Udzv6uiSt35hMs,21 +onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb,sha256=jn5qRVW1d5fDCKW6NTd6zhlOLzJWjh6PDwF_GotDvU0,21 +onnx/backend/test/data/node/test_adam_multiple/model.onnx,sha256=xOWuY-R-HxA0t0rV_ZL-H5CNzeqAWtWKKmeZO3mQJw4,553 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb,sha256=zSCQaDJuSfjV89lOKl_e8FAvaYdDg6UrH2n4eykC9bI,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb,sha256=A-40FgJNucPNFb_WksbMy0Z-E_EIV7RF0DP90kqbbC4,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb,sha256=CxeZGajewrwPha-MBoCdOi3nXJYzF9DgbGhOIwIqx3A,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb,sha256=stCGvEbBW8itgJbkRX1pnKZir080kytSIuTmZAkh41Y,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb,sha256=Rc90FrQBRUlC-TzO9j8dMroSVATSdH027FaQzEtBeUA,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb,sha256=NPcgj_9FyMIJ3Ll5ChXoHxbUNPE7QquI-gnfMq4v000,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb,sha256=NP1McfMEN1DUKgTtTrLFqX-Q6nolS8o0IdLzi8r_YrA,14 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb,sha256=I1axqZFkXox9eUbvVASQWpaGtnfeL7UNt4kOQSINWY8,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb,sha256=gn-lzXgI1hDCYZ2_9ZQMcws-c0IlriCgT4tPfdZeMn8,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb,sha256=3poCofD7Nyg9KsIYTG-pJUfEtEz-G7JNKMvVq4fAIdc,22 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb,sha256=PhEvop64Uiv1n8ikOYjsoB_Wa2-5qXCpCJteJyKtgsM,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb,sha256=OFoiZH4lHPqV4YM4sO9JAUSITmDTLcFPGsDo_8g3nWk,22 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb,sha256=93pyGZX6OvmF1axeH3eJ18jCG9lt1X_Ne8aEOp2tcMs,18 +onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb,sha256=Gxk4rHZZEsF0zHPKYjeLAOb2bgc8Ty5pp4ow68emvvg,22 +onnx/backend/test/data/node/test_add/model.onnx,sha256=k88EOHBs3av2g63IsTyKF8S4sS2LzLGwQSaOH03_Ci0,129 +onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb,sha256=n_TAJ8n2D7D_tdElxet4CQ6etKybHAJmkYM7_MSHuy8,256 +onnx/backend/test/data/node/test_add_bcast/model.onnx,sha256=1WLvYrfpVB4rm_K1rmKXv-qn0UoZxok4gxiy3Np6FVA,127 +onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb,sha256=rG38BI9ZZ1bIw-G-vQNaVea2-iEFgzlnGrSk4JRQ6_s,256 +onnx/backend/test/data/node/test_add_uint8/model.onnx,sha256=paL-5wnP160jtuJlWbv2GFpqDVJLSBw9E89HQMr8HjM,135 +onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb,sha256=wY9Jbz2HD0FM7JM6zwbBbRhGHss3cDgO6eFTgp5L7W8,73 +onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb,sha256=BhGgo5N13MdBE3iNJgN6gWCP4GSFzJZUcoAIT5jIuok,73 +onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb,sha256=zpBdHPu2qBXHaUcgo8a7xdxlrS3qOLJA6Wip2m_7OsM,75 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx,sha256=-KqAy2YBDRwyqfinmfj87kNajZdOLQ5-h_HZqnrca1c,181 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb,sha256=XI00qhavYkKl_aHKei8a3IH_dsLyhI_Y57J38wFhkU0,59 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb,sha256=6bV-LPoUKmxMZqYVh7trsIYnlXnapYVYirqTx2WlSUs,25 +onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb,sha256=cT7VjDLALeCy6aKg9Vg7K9bxY5CnvFGrq3e2QRifANk,35 +onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx,sha256=MGIz0rt69DiEaqhSFKzli15l4VhFz99Q_ysGnynGgv8,164 +onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb,sha256=IHiHIyablYLzOeKB32-oDw2gZhG5BoXro6hrposdegs,254 +onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb,sha256=WCPxC6xa9osg4LxN0y90PYcSuudpgzxjcx9gHKqwIxQ,254 +onnx/backend/test/data/node/test_and2d/model.onnx,sha256=jvhZTvomeDvtnZRjIBB5C8xGTWc-N4woaVD1pjk_yfU,119 +onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb,sha256=goZmxegiEZPjRTXScUiQU9fpxPndF4EqAZy8oeToa8k,23 +onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb,sha256=GcjmcM13wdXARvgFEuZBPW92lqso2-5sQMmJiIZovWI,25 +onnx/backend/test/data/node/test_and3d/model.onnx,sha256=jssi2o-pTtK6Si7NKEBEaxn9P5U4lmdUn0XF-YAJvnY,131 +onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb,sha256=Dr4k5dppNqEaWmFsMUXw_Pbp7QoEpqkXv4Bodqt7zMQ,73 +onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb,sha256=v5SpTzEGQijgxpt3GQdqFdpD-LCqlDgrPace75EL5pQ,73 +onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb,sha256=uCkMKeu3A5Fl999w3OJ0Fu3JjZpNFWJwCW-yupWBY78,75 +onnx/backend/test/data/node/test_and4d/model.onnx,sha256=fJ2a5gN50iVWK9QnSR_kCD16NE5gqeimgsReLfdAEgE,143 +onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb,sha256=sMKxU5gNQx6mv89ZOkmV0QCdEu9f8EhE-MZuoWNbcek,376 +onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb,sha256=9JaUvXVRf_NYTRwYWtPYsbSoKJDwOXPZuRBgFY7pYPc,376 +onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb,sha256=7z6DcqU4PYD4NBG0hBjBoQtn9AAU1HXoGQp_P6HX5ZY,378 +onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx,sha256=V-L6MLM5UCLYeSkG6m8eMOy6OxDYPy3XvcGgesbt76E,131 +onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb,sha256=wF52hvLEXCfryTN0FvgWPKXSx3PPlpiaC_aAZ5IXCMc,73 +onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb,sha256=0cP0kHJ95VbmGsyJW3rlozPO38YQocSctc5buLas0ZI,14 +onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb,sha256=2zb5cHudGHSOWOFcjgMBQtTRJe48hbld128aQ2hbCy8,75 +onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx,sha256=rkO8gZJ6USKFYpUWgKZDOVLVKrGaXIuHU-8heVXwwHo,135 +onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb,sha256=2Hi5gZzCyk3SWtB8dhtS5tIMipISnPJGI1SIjx08Fe0,73 +onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb,sha256=J1neLsOqZHTvGdagBF8_3O6sQk1byuUIMABR0wJxASA,31 +onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb,sha256=mdG-32ANjRiRrubGWEMBugaAkJKthCw74hqclFeUg0c,75 +onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx,sha256=nQ71EhbbQRvGvdUrcCWMtA8gDvPy3CA3wyCmREtQu-4,143 +onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb,sha256=TG9PpNJBW-rhSdwYDpmwCMotWc8SOe2e2cLAoXaNQ8o,376 +onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb,sha256=D4JIlfVUzijC8rk152pkPsDWa33YJRlmutjMvkT-1FI,41 +onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb,sha256=BXDZEzEx30KZGRlX-QRAu_TfrftChYGi4jHGv64S9NI,378 +onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx,sha256=lpW4vLVgx9F7FIKrqQ2KuHAfgS3hyDrL7HNjhnP7G40,147 +onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb,sha256=1gaunFCw_HO0ZAf_sAp9bfcwVRJW_aTJIwkv-2WYWMw,376 +onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb,sha256=26gLYNI9eQESqKzWzx1zrE8YDDCNIvfAE_0m_FoeT3E,133 +onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb,sha256=S4ncrzynkHE-cPqlleaq8UutgOSmUv4roECEsfI8u7o,378 +onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx,sha256=TfEv0B9Q-1sIKlKXuKWAwVVrdJjWUkK6frFTvOHzfpM,151 +onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb,sha256=f63fGhPch5eTkAvMXCrJTC0FOIdhKnaSfJ8Ox9hnol0,39 +onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb,sha256=iCGDAU6H1-WHvqKKRCD44UWeluKsnFCWMpevbsJ5ASU,105 +onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb,sha256=WAS1y88UC7m0RqEGzxSzw4NBXEUt8_2JlykNVAzyVVM,378 +onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx,sha256=5gOsN-W4GWrgix75Y31K_ghoeSHrVbkLZ5U27gTbyvU,149 +onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb,sha256=NoozXBTfuGBGESaqTAVgvBaY_2_1KnEXaCBKowhZYgc,32 +onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx,sha256=u0lNlP1UgUDRYDOHkWuB1E_PdfT8K2RLKi9q1vfJZgo,194 +onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb,sha256=NoozXBTfuGBGESaqTAVgvBaY_2_1KnEXaCBKowhZYgc,32 +onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx,sha256=-ioQatsDKz2cdDFAFf4kVlt_rTVhEEST2Iooz_Zo_Lc,157 +onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb,sha256=DhGaHjs8SV8OufGMy1I7s0-ROoSwvKKmES2wj44RaVU,114 +onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx,sha256=8DJmQWRw4NmhbgZNFemfZDS2J1glGNrvaUFAejj1Mtk,201 +onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb,sha256=DhGaHjs8SV8OufGMy1I7s0-ROoSwvKKmES2wj44RaVU,114 +onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx,sha256=9r9MwZu1aFQ7Tuu-ALVKqHWJmPLJPAlEqr98a_PkcFg,159 +onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb,sha256=4F0-PRVXRwzEKW10dABm9QzkLNzVaRoMkYLi7CvSpnA,32 +onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx,sha256=N5h3EbEADdYKk5cC1XlMHsxpoWPXDYCbsITbAdw0m8w,203 +onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=yjB4LORCAlt1ELQfYeptdZNSWozEnXkHE_Yw0FOF4Lk,32 +onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx,sha256=etLTCThXENf6WD3LX2dOaZ2FAddcKBgIggT4QA1788M,166 +onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb,sha256=xxKUj1nPly6oZ31Db1ZlT77n2WMOc93PhGls_r46NyI,82 +onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx,sha256=xk8Wg2EFTAVwfXy_DALKhdY-MCHrdQW-9fEjHDNToC0,210 +onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=xxKUj1nPly6oZ31Db1ZlT77n2WMOc93PhGls_r46NyI,82 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx,sha256=4BvTuA4BDbWrJS-mfVHt2bFqnhLgWfn8HRJvck064co,182 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb,sha256=4F0-PRVXRwzEKW10dABm9QzkLNzVaRoMkYLi7CvSpnA,32 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx,sha256=oak-YBL_HjQVmKcqwkeld5P7mSMFHVVjk1kHxt25lkw,226 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=yjB4LORCAlt1ELQfYeptdZNSWozEnXkHE_Yw0FOF4Lk,32 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx,sha256=jNr6hd_05wJ10QiWMMLcKORD2Hk-vUqJgX3J0Vavt_Q,189 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb,sha256=rr10tTLghcLkMi30lMGX-yxUk_YBi6rKL8m3VnjtsiI,66 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx,sha256=CTLMBC-WEWztkyuVbzNLJGT2QJ-pB-pevX2SsHozLEY,233 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=rr10tTLghcLkMi30lMGX-yxUk_YBi6rKL8m3VnjtsiI,66 +onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx,sha256=rHuO3OTD5eRTyGpiTrFsGGyzDC8iDwVYuLDRbMAfRpU,158 +onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb,sha256=U570gmgD-FKNrX-L5G6HOIWOStTE8-Fpciy-B646kUU,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx,sha256=O0jhRm19HyzVNZKWKApMpgR0TJ6aJux5d7YHF9Htfw4,202 +onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=q_pzvm7B9F06AGaDCm-ypSJ7iOO4k08SqKZnIWxn5YU,30 +onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx,sha256=aM8dVMPJE1DI3Up-JVkHJvVPRj_7UW7uNTxly9j-aVE,165 +onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb,sha256=Y4g-JZ7vtzt484_YeaxF0sGDj0IUC3Ow9h7-3AMEOwM,80 +onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx,sha256=6mhwUs8s7PzTMl4Zm22UNCwAQjRhMF93a7u-BhqUVoU,209 +onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=Y4g-JZ7vtzt484_YeaxF0sGDj0IUC3Ow9h7-3AMEOwM,80 +onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx,sha256=iebLNVL1fxxh-j3DH5boBJGFNt8r2YAI_7_rP3LADu8,149 +onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb,sha256=Bj_kN290f3RUlkABfWUh5o5MQuxnM-jXtBc-onOuETk,32 +onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx,sha256=qHYIVhWQ_8CbsMYeyYUWyg5wRPK25HQfuHsz_NjSr9E,194 +onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb,sha256=Bj_kN290f3RUlkABfWUh5o5MQuxnM-jXtBc-onOuETk,32 +onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx,sha256=_spSgaLvVIIaJFONNMGKGi5lR4DHEAcd-ZA0bUdo2Pg,157 +onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb,sha256=19x-g4YHmp9zWbUdC3zmRnrC_YGZiCXOH6ZYat-OKos,114 +onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx,sha256=ONXMwWYnms6w9bXmYZQgtnyYEtnMbIa8Zg5mQb3rWl0,201 +onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb,sha256=19x-g4YHmp9zWbUdC3zmRnrC_YGZiCXOH6ZYat-OKos,114 +onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx,sha256=jG3yLmfOLrln-g0UAq1T54CRlzEEcIHedSy2su1NvvM,159 +onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx,sha256=3VpWljrpe_M0zxcrpMYgTIxCNT4_Wy_cXHs3xP5EiXA,203 +onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx,sha256=a8TjWBkgVRdOTdgVV47nuGKlqjkylM4H_7SVVa21Gxg,166 +onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb,sha256=n6D0HfXyUX61D0a6ma7Iu4yTDIR_AixA4NxI2eQ0xzo,82 +onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx,sha256=yStGGRrrd8ILfWWnSVSQh-nB9jvwj0blZHRJHbpQdVo,210 +onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=n6D0HfXyUX61D0a6ma7Iu4yTDIR_AixA4NxI2eQ0xzo,82 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx,sha256=Qdcw6P4ShcjduyyWa2edCGBhuC27PN_UAhDQCmDkqck,182 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx,sha256=nu8X7vFhj97yEguRh_mA5BiMbyiUMuSwRGR07TklqeQ,226 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=Q0yB3rE94zUcdgoZieunw0TZyHYIKv7PGv-_zINGDwM,32 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx,sha256=6J7PgD_k3Fi2wUdzP7doBFOHxEd4w4En7b9JIZ7rNuQ,189 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb,sha256=QiaUgxoImJVzGqsKXpeRoj5YIhs4TSmZNujE2jRpNYE,66 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx,sha256=LqozWLlzhVSjSmkkRy5qE4bfDHr2zjeEhz2c0eLQmSs,233 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=QiaUgxoImJVzGqsKXpeRoj5YIhs4TSmZNujE2jRpNYE,66 +onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx,sha256=xk1tQnhxenLqqiNWasT9qPvWf03sxIHmWRWpIVL8zyQ,158 +onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb,sha256=P7LmjrG5EozUQ8-DBtDjai78FFBzBbcHWYMPWxKW6mI,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb,sha256=orTottlTXJm72VAuuI4Z4Wm5MdszRna3fvV3HAflc64,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx,sha256=M9mq_Nks8i-0ic_sUhv6nJt4wTL0hdfKLYQd8COtiJs,202 +onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb,sha256=oiK8EV6rRGZdVJIrCJ0v9IVyWbWtqgZpw-MbWYg2ofA,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb,sha256=orTottlTXJm72VAuuI4Z4Wm5MdszRna3fvV3HAflc64,30 +onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx,sha256=BPo7t0D-DdFCNfgyDYp6CELjFD1Y7GOC1_b5jnpu_GQ,165 +onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb,sha256=1k5tX4X36O2Fo9-48qFsRj3eAH2qLSUtS2alMh32hKM,80 +onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx,sha256=G24mWmUuUdRohHXsk32EnB_fkE3bIDiSeetlrHg5ysY,209 +onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb,sha256=v_AV3pvz2MDGCOnzjvfj-FvbarLucYe3JAE3R_azXjU,112 +onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb,sha256=1k5tX4X36O2Fo9-48qFsRj3eAH2qLSUtS2alMh32hKM,80 +onnx/backend/test/data/node/test_asin/model.onnx,sha256=c-iJf0kSCwEzVgddUlzRKq6gFALlkPDD2UBEnCdW3-s,99 +onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb,sha256=BcAjkpobMrS9vXiC_15TubU3Yu4pKcZr520PC6fKOT0,254 +onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb,sha256=Tsha0K4mCtDqPbUqyA_e1FywMRTsf5EsbEsnAvNxoa4,254 +onnx/backend/test/data/node/test_asin_example/model.onnx,sha256=4sClXtGRSQevJ6EHxwlNJ22fmFivvXzn9L39rtKp0Wg,91 +onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb,sha256=cD3gw75QWnhZYjV4loK8Tm8OhSPzT7cxIHtMB2cBq90,21 +onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb,sha256=FllD0s9HRvharNPBoXUEszaIk91MR79Tz0s1OwzXoi8,21 +onnx/backend/test/data/node/test_asinh/model.onnx,sha256=OFzITC7NYQXYt6211GMI-DzOSTdDq0Ylv66M2peAfaA,101 +onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb,sha256=3gQlALJwXqWNp2p0nQOBZy7K4dWykOyt2VUXAxR1ll0,254 +onnx/backend/test/data/node/test_asinh_example/model.onnx,sha256=FcVkpsyH1Ngm1zwnDk0hYwl1x4tMHM0ctBT_9AxMe2Y,93 +onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb,sha256=8Fz60rR3DIxDgwmw7EMak08D9yt0M6Bb9psXbH1p8kw,21 +onnx/backend/test/data/node/test_atan/model.onnx,sha256=o_6XdZbEa_nAheUoFfn7ZSTtsvkSjpqCNi_e9eNd-uE,99 +onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb,sha256=mEA3gJcKN3-o75keUU3NjoJm-Hx9vGlAQsqgbBUcK1Q,254 +onnx/backend/test/data/node/test_atan_example/model.onnx,sha256=rPAzURgzZhhsUYg-IOLsKTgIAV_UgaQUr7SAvGS9HDg,91 +onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb,sha256=kWWl9gDeCxk2l09E1LE-fw9VMRIYYxO2XDgPuZz1Ff8,21 +onnx/backend/test/data/node/test_atanh/model.onnx,sha256=l-2bku-epRnHOcAo5KWMy8ydA9tGlHxEz8_Bds1LIWM,101 +onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb,sha256=BcAjkpobMrS9vXiC_15TubU3Yu4pKcZr520PC6fKOT0,254 +onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb,sha256=157pFUHK-c88rhL-REgpC7_Zn_aLZU6KUkZLXPHfUGE,254 +onnx/backend/test/data/node/test_atanh_example/model.onnx,sha256=TDrKdNv68FFl87fte-CBxIgmoNj9DTh1PBAJIF72av0,93 +onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb,sha256=cD3gw75QWnhZYjV4loK8Tm8OhSPzT7cxIHtMB2cBq90,21 +onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb,sha256=lnjpP4k_gQIoWj-p9POCPLQsNe7mT3U9ArJG73iZBro,21 +onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx,sha256=XGxVXuUZJaDYaJlBHJ3tNjYYAKCas_F7zBAipWVexoI,145 +onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb,sha256=Za3StahBL7BbhQGm5tBIbmHL40mPVKMeoJms01DCbkU,398 +onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb,sha256=TZiHbd4tAQX4YEoKfpv4FAfDU8Wfj18Luu5gvR5syQs,386 +onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx,sha256=Fw_0lzhJ45nf9cUdAsoXxHBOe-C29F7OTQOwfJAwmpU,189 +onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb,sha256=J_NsHn9iEsmJAHuv2HzlQWz7V96t50EsGijdfWrqmeA,31 +onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx,sha256=GTRDJ2h6QLt2eXHnUv9PKpgFJ0mlNd7CeJHSo5MRPGU,156 +onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb,sha256=WqDv_FV3cMJET2YYrTwD1QNaFS1HWX3l_wgNWu5fv8Y,11548 +onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx,sha256=3Rw-BH5vKXyn0M1G114FCw6ywEWius1a4rdogrt6SeA,214 +onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb,sha256=W0xv7zagmB-A0lWKOzPp6y4w5v8iBNre0k8VvAb23es,31 +onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx,sha256=8rXDpuSWjpGXP4R_-P9DstYcmuTfa_To0QXbkmBsZP0,172 +onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb,sha256=zFviiXMYWWVgabusMEGvLMEybZSq7C296tqaNQL6kf8,10816 +onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx,sha256=Tcar-PxrN3gQO2ghXmUTUd5HT1jq71G3wduvkHY7pMI,216 +onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb,sha256=5U46RW5XBKUVs3UYsbuPPOqxyVl-Bs5cqdlmg3zBVjs,10816 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx,sha256=-vOeN6LHMAqcozCy_ijYCpUTqg9GC42TKRxVjL1BAXs,184 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb,sha256=Ecxo2QxKQku1MYTr16hK8pervsU5PyL_fGNkROknnP8,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx,sha256=ocJT1xMaMEte6DJIZDi-YNn8H3gvvUJoqR6ytoH2rdo,228 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb,sha256=2xNtCtCrswd372GDRTeANsSwrjEvCEBD52M4I77kG8U,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx,sha256=NzQZV7uUhp4gx2s0smMDWIHMt7s7BhfkGJJZaaosV9w,216 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb,sha256=PXPhQwNqHdL1LZx5KD3oGFGzjLnNpPSRRUEzLfDeflM,51 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx,sha256=ZXyTepIY0qtR7sJGjF5KRupQ-WsxG1CibtDsGXBA4Q4,186 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb,sha256=6kurBL2grQAt9ZKHrnJkfWS3ZP-ToeFCUf4U4ZcVcJ8,31 +onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx,sha256=FIOQrCExRc7_Ridv7KQZBnRSOqBu5uILR8xRh0GbvHs,186 +onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb,sha256=-5ZZi0sQTaBI0T6CQ1Sv1ifyPAcHKzpYLJfVbGyk_qw,12304 +onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx,sha256=zlG3ufx_f3ntHSpYg3AbjwwzbSFA8nqk5JXbMpHfU7s,186 +onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb,sha256=0dyD3w375fMoeUr4L5i396MTxAKFnGEc0E4FPhFOhwM,12304 +onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx,sha256=KtGE2-WFqNeokJtW-cKCQwk2qDPcYByzQWGamf-LlAg,174 +onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb,sha256=IR_Q7lYkCMSUqv7Rvjth91C6d2O0alfXQxjoPdDuMhA,1216 +onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx,sha256=vXnFse9St86WS8KljU4-LeGfSqr9H9q_-Z-2GPaidGA,166 +onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb,sha256=L_c9P56CmA7WzPjy1TlkWrKgYm0YkeXEYxiPZ6VV1wY,393235 +onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb,sha256=bWn81UGs4Eu7uQ-sAsgNLoy5M4lo5LZ8qLYoC87yC6g,357511 +onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx,sha256=cD_1tCjoZkjAcpIi0QNzqmmbpV_AGw_2r03lgcxQFZY,201 +onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb,sha256=RnJVWHKql-4c51A3JiCTvFe-ry8o5bavOnIotOzZFK8,115 +onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb,sha256=_LQ6Gcbvv-Twct7wPuCO5Hk3vIzVJ6zAJjqsCUTiESs,115 +onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx,sha256=-9Rdgv4ilXQLar82r8TBkda5LM3noubb0QGZBVJ9-mA,204 +onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb,sha256=RnJVWHKql-4c51A3JiCTvFe-ry8o5bavOnIotOzZFK8,115 +onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb,sha256=K4v6OtrT-N3QKnkBVUq6hzq-cwsWe0UFSldl-Ue2gBo,51 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx,sha256=fs-2bZMq7JxyOAnLmk1E7EYxGkgDl5yFjQvK-HhQHOs,308 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb,sha256=4Ki_u3n_9JzedrVVClMoOCDVY7aP6BJSo_YgoX_n3EM,31 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb,sha256=ubxlpp8Ok84plEXefjcKBNLmtjYWHyW8lTBySGpXiVY,546 +onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb,sha256=Irv1r-kaSImnwtIZkxyVkxsEt5PsqthjzKxqarimwTk,92 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx,sha256=-2wpGLXM87GIGDsKgf2iiKgF8E2FR37BBA1YsFMkC3w,323 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb,sha256=4Ki_u3n_9JzedrVVClMoOCDVY7aP6BJSo_YgoX_n3EM,31 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb,sha256=X6j9HPA1XkWmfq_jLD2L8xChvOSYaeHC866XeRYcjYI,165 +onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb,sha256=peJJza0T-DL7-QEaZxSV3xP-Dw7ZUQF7DAoh54hXozo,47 +onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx,sha256=NXo3bdeikoeDCYmkO46QlVY4bBGEZfKsFlRE7Pw5RtI,250 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb,sha256=8uEeu7nwOZUkfBuA5bw-ePBY0x7IS3e44oNXGMyGbkQ,496 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb,sha256=OBGvvDW2vXlYrjwA7mwO12Os-DSXirqdY2jD0Oy6CpY,21 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb,sha256=3wE1u1KcTYpoMTF-wBk003DsXnUc9oEGTFycIU4jCXM,24 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb,sha256=T8_L--XgZOdbDGUSHIWGNqYTLTv1yFq2oH487fAI0tk,24 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb,sha256=Ti6CdJotPj-3-v8kHqk-YWnNLFRA5W3Ggebr1lG_QiI,23 +onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb,sha256=n6XFIIVyNJbcQt5Mj2SKHyj8_vjkASjh5KIlzVwFbi4,496 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx,sha256=SAramxkbImr0vmaRPxJA-1RLrQaTx8rud89R0WuZ3JI,364 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb,sha256=8uEeu7nwOZUkfBuA5bw-ePBY0x7IS3e44oNXGMyGbkQ,496 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb,sha256=OBGvvDW2vXlYrjwA7mwO12Os-DSXirqdY2jD0Oy6CpY,21 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb,sha256=3wE1u1KcTYpoMTF-wBk003DsXnUc9oEGTFycIU4jCXM,24 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb,sha256=T8_L--XgZOdbDGUSHIWGNqYTLTv1yFq2oH487fAI0tk,24 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb,sha256=Ti6CdJotPj-3-v8kHqk-YWnNLFRA5W3Ggebr1lG_QiI,23 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb,sha256=WTc4mm4mdiyNSmlgxnwB17sNnDNlw_i_mHnXabAsE9o,496 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb,sha256=jHTM3xrd557eg6TzhgmP5mMHNrMCIlsBuK6OZqnnKkc,31 +onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb,sha256=N5551G0V8glw6AyG4jMpqsOL3dLoLlP8UUWNEoz_VZ4,30 +onnx/backend/test/data/node/test_batchnorm_example/model.onnx,sha256=ub690uwc1r-R7fxX6EtJDAMIF4aI4YfzhMCkkhGH7yQ,231 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb,sha256=SYKd5PF5vM-bKNrV8oTKPGHvYE0twyvHWdFt3T67zDY,496 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb,sha256=AI-3RnrtRdqYWsuL7R4_zbZ0Vb7zfnaDEBYsm0i2kvY,21 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb,sha256=2oNlXxvO0WnQ0oLXr0SuQwOm4ErOca8R9dkNLwewDK4,24 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb,sha256=d60mjqff9zbsLGnRD8GG9bbEk2qyV8UaYde7LaB_myc,24 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb,sha256=EyHoNru0GPIaJLApYVvbQ1CqR67ReuX4wdywoIWBV5o,23 +onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb,sha256=oeWjuEbXwDN3lB6trNUoMhzjqR-2WCk-Rt9KbKy_lJs,496 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx,sha256=DAaPW_k2UOPYfvNEk00CEgz2yHtNbpttW9kpp5z49cE,345 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb,sha256=SYKd5PF5vM-bKNrV8oTKPGHvYE0twyvHWdFt3T67zDY,496 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb,sha256=AI-3RnrtRdqYWsuL7R4_zbZ0Vb7zfnaDEBYsm0i2kvY,21 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb,sha256=2oNlXxvO0WnQ0oLXr0SuQwOm4ErOca8R9dkNLwewDK4,24 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb,sha256=d60mjqff9zbsLGnRD8GG9bbEk2qyV8UaYde7LaB_myc,24 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb,sha256=EyHoNru0GPIaJLApYVvbQ1CqR67ReuX4wdywoIWBV5o,23 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb,sha256=e-lIEIZD_v28N7-cbLdGgQKaTqsjUA7tmsc3OGNwz8M,496 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb,sha256=B0lT9yeJL76Z8VJvMM29lFzBBqzZ7ifQi0nP8Rrih8Q,31 +onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb,sha256=Hb31AnNOCJ7SIMDkm-IuS8WJaRwxB1qvuSJedInfXUY,30 +onnx/backend/test/data/node/test_bernoulli/model.onnx,sha256=DfSgPcWcc0wpNRXOvnl4eId8A_Q7yaHI63nS__C1tus,93 +onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb,sha256=hyJJsFqjdZ5XnAjaaBhB0YNRxb9AuGsGsBdSS1te2iw,89 +onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_double/model.onnx,sha256=x0PDwvY_R5GtvN2pM9bGlcU5g2g_EklNdv5zTpIOhF0,114 +onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx,sha256=VrJk8c6NU8o0Or2sqjvIVkqY65pqaHpmcVgjkfecCJY,446 +onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx,sha256=yLUsgRq72OZR2yugRd3N4WyH3a9ko47PpEj35crnCP0,409 +onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb,sha256=hyJJsFqjdZ5XnAjaaBhB0YNRxb9AuGsGsBdSS1te2iw,89 +onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb,sha256=xs9aCuRMT-QHKEFQ0SiknUjFyecsDJLJJ1TQ9BQh2os,89 +onnx/backend/test/data/node/test_bernoulli_seed/model.onnx,sha256=nKQzzOSvENBJFqRa8O5jzVgFSS8BnQs9b1oz_uoiGZg,114 +onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb,sha256=wDTjyEkwQ92j1RiXjUtYJjS14OwkKkkTih0mdFRpGGc,49 +onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx,sha256=1hhf3qKyziZ8eVwUIHh_tX9Zzb2ETpZ8GwSG8yqmpfo,452 +onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb,sha256=cuPUsQEt8rLSUYiu2PhyXLudD1nqEYaXqoG180s6eiw,49 +onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb,sha256=wDTjyEkwQ92j1RiXjUtYJjS14OwkKkkTih0mdFRpGGc,49 +onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx,sha256=LnZd_SO9L1dOzaN11XKMPNWZCPRE96L0NT-xnJTOBtY,145 +onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb,sha256=jQ176jxBAIMO5ulz_2R2t_RMNCYxBhWBKtEQvp3VPnA,15 +onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb,sha256=d_wFROmBvDAar5EVjiFwX-5HWMz7-3X15eaoWQv8BAQ,15 +onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb,sha256=FIj-kC6QX69gcjY2ZLPbJAeYeTxYhDoTphdZzBHyxr4,15 +onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx,sha256=Xbshde1wAgne2pBGkwDnLbZJFsZB-nH8INUp_fyKsH8,145 +onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb,sha256=n0jmfIFAkvhmvSsxFmIhij1NKAC2rZ0GZjPUvl0OvpM,21 +onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb,sha256=LPGgfy0kWPfzwbePS63zlBnHRcjnKVmTNhl56DQT_LQ,21 +onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb,sha256=UHau1j361dwNuOuv9GVClDPrEvAsEMDnU7kZ9Ka9XEM,21 +onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx,sha256=uitk2ZXsCBnTzjWPhsF5PNoiwI5ECCfQvp9EGR19MOo,145 +onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb,sha256=gdItplXa-gah3kzYq0cb4Ny7SwnrQpNjCBu9BwvRWs4,33 +onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb,sha256=srzREYqcjuSETV_il_0QENxQV8EbW-IHk_e_wnZX_s0,33 +onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb,sha256=uv291G2Nz0ctLLM_ZjvaFsSQLkB6Ywj1QJ2am6jrAOI,33 +onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx,sha256=2hKErCnyvnmUegUBOX3i_-OWYfrGyErXp3n4NlviXww,144 +onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb,sha256=Npre_kHciTwjklfqHpxJJP6BJTCF638zHABwLLSJLVc,12 +onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb,sha256=OmXyE8_Mj-VdKRY0dsUACEnjcieoln-kaSNRW1ulqnU,12 +onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb,sha256=htgT0sbAbcKHka93qygml6m7QOyV_RNBGZ-7Bfh8VWg,12 +onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx,sha256=dMuztKV5VcxFmhxYQ_w9wEofyRNitDf6dXlT8OpOh4g,147 +onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb,sha256=jQ176jxBAIMO5ulz_2R2t_RMNCYxBhWBKtEQvp3VPnA,15 +onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb,sha256=d_wFROmBvDAar5EVjiFwX-5HWMz7-3X15eaoWQv8BAQ,15 +onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb,sha256=OWgso0Bd4H7b02Z0t-9C6BIe0JqxZPl4x5pLDCuH-6g,15 +onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx,sha256=ZSUngGFGhJm4frc_N6LC_nOTHfOmgcEpVBloBXbfhY0,147 +onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb,sha256=n0jmfIFAkvhmvSsxFmIhij1NKAC2rZ0GZjPUvl0OvpM,21 +onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb,sha256=LPGgfy0kWPfzwbePS63zlBnHRcjnKVmTNhl56DQT_LQ,21 +onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb,sha256=9HW8Yn_MW2Ply6yspxBbl2QGTJwZ6HTfx7F2ZWCB8ks,21 +onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx,sha256=3TJliEGizBkKgJoqU47jiojDGC7a1JJyt1OGJ9f_zjY,147 +onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb,sha256=gdItplXa-gah3kzYq0cb4Ny7SwnrQpNjCBu9BwvRWs4,33 +onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb,sha256=srzREYqcjuSETV_il_0QENxQV8EbW-IHk_e_wnZX_s0,33 +onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb,sha256=cIXEma3tYpCdRIYdSiF8UH4PveH4LSu3mBe9eKtaxRY,33 +onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx,sha256=FiyhL_aDh3eJggmM0yqczmC9_K4z4r-NVC3So1zoX_I,146 +onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb,sha256=Npre_kHciTwjklfqHpxJJP6BJTCF638zHABwLLSJLVc,12 +onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb,sha256=OmXyE8_Mj-VdKRY0dsUACEnjcieoln-kaSNRW1ulqnU,12 +onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb,sha256=xQwf8_nlX7DpOs61hkVxH1caC4G9PqWOvYdUgQCFFs4,12 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx,sha256=yc-YBEB-A5u1Ji2mSkoNgGF87Q901mX8Wzh_CxOZecQ,166 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb,sha256=51_g10nhl3pGMHzIZPb9uJiIkLoqLtARgYxBZRXFJ8A,133 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb,sha256=cHjBuAqlCncTYhGLbDmLR1oHQbjNdpHVt6Mo7Cg31To,133 +onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb,sha256=HnblxbS-jMUk0JpLSVezpf9X_qP2I_E57Vv_TXxNubY,142 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx,sha256=VI5E4eNL7PdENxiR7BWHTpJQH4J22TwDIyYo3i6x2f4,154 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb,sha256=GLkOWs-6gJxZOVVgeCGpbbxY4U3jqjvRYYSunDQHxjQ,59 +onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb,sha256=zSY0bjB6kO8gOdTaQqGVJstGswRtTnQ9hofYX2DVZII,68 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/model.onnx,sha256=0ilxxehkgXk3mDGpu7uXqdCoc65XmidwPzqMi0gwbAw,167 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_0.pb,sha256=yyF0q6vMUHrYoNxDxHkS1M1J57ABoWCxVPikiSbgt9I,494 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_1.pb,sha256=yhmmpWW5p4InqcZXi6vWNboAzILeHxIStUce2hV1TeQ,49 +onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/output_0.pb,sha256=YjQjN5VK40lEVH99dAAz4EeIEq9g8MBODn-ksUV8UUE,503 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/model.onnx,sha256=NAzIiuPcp2ykmd0Ylcqs6qC1itlr9FNG2Fct6GAxXAI,182 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_1.pb,sha256=cmiv6qNYN8mNf9Mbmi3IZSAgZ1arXHV1abF_FizB1vk,133 +onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/output_0.pb,sha256=k58qWsuM9aJahBM4EBl-PRJW_vtQ2_MJe4DIdHgKzcE,385 +onnx/backend/test/data/node/test_bitwise_not_2d/model.onnx,sha256=Hi968CmDbvXJ6F-QnnsvEsuBm1PJG5mOddx40P3JTEA,127 +onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/output_0.pb,sha256=Igvz3l6da-yIIbb1dHK45BFXJl8FWckYz7UCN80_p84,69 +onnx/backend/test/data/node/test_bitwise_not_3d/model.onnx,sha256=li1vHDxnTXPyVVg0BX3sL0009QiN_vXxIjz0j-zbPnw,135 +onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/input_0.pb,sha256=-GvODn13fY7XtP0uHpumPLmhhvPiYGG-4gplBNAZrt0,133 +onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/output_0.pb,sha256=979pI-QykNeUo-B8su5J9nc-VBzqJoNMUOGhs1B88xw,143 +onnx/backend/test/data/node/test_bitwise_not_4d/model.onnx,sha256=InYj3ToYFWonqMUxkfgDCVZDYHtSr1QC72QebAd_4CI,143 +onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/output_0.pb,sha256=cCdeum9xyuJG02YEHo7w2P15mUmeFWkAUufvJbL-wuA,386 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/model.onnx,sha256=enje0I-pI3bLXqGYCBGKlQWK0PFdl59_PwDjwafql3o,174 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_0.pb,sha256=PnxxwiX86m3d_QkLdl3Asalt7yqxjGmgck55zPjA2tM,376 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_1.pb,sha256=dESyvCmUTodtbWS3T_t5OMVsH0XWXdlE-pNDsdco8AU,376 +onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/output_0.pb,sha256=QeGUOBMBMRUWqrTa7bHM36t2Emg8OQwtVE0wLVO3Cpg,384 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/model.onnx,sha256=McwgQLlT_EdkiUFBxBM3MASoBLHnDGhilM4N0nONxOk,149 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_1.pb,sha256=GLkOWs-6gJxZOVVgeCGpbbxY4U3jqjvRYYSunDQHxjQ,59 +onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/output_0.pb,sha256=PWwPYI7MIgvc8DurWpiRPeZbG0vMzQ4m4jGGmC2OZT8,67 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/model.onnx,sha256=L_BirEZ6MunAtXPvm2htIlr8oVaFerC3x3TRibbuB1g,163 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_0.pb,sha256=yyF0q6vMUHrYoNxDxHkS1M1J57ABoWCxVPikiSbgt9I,494 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_1.pb,sha256=yhmmpWW5p4InqcZXi6vWNboAzILeHxIStUce2hV1TeQ,49 +onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/output_0.pb,sha256=gnw5KbwNGy3mtEYVA0VpILmEYsuxCZe1wGgEKHyNT5o,502 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/model.onnx,sha256=VF0_AxeWLUOiz_0T0ghcsMW6_ePD9xlS9XERYlKQoqc,178 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_1.pb,sha256=cmiv6qNYN8mNf9Mbmi3IZSAgZ1arXHV1abF_FizB1vk,133 +onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/output_0.pb,sha256=Xb3ol4eZSuioqDtjcIDOyOCendI-ptK9UGFpi5tIWLc,384 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/model.onnx,sha256=NsWTaACGKoFPWQFATJhi26d7Ad7E1awRbgc3CnH7I8w,166 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_0.pb,sha256=51_g10nhl3pGMHzIZPb9uJiIkLoqLtARgYxBZRXFJ8A,133 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_1.pb,sha256=cHjBuAqlCncTYhGLbDmLR1oHQbjNdpHVt6Mo7Cg31To,133 +onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/output_0.pb,sha256=25Ra6ldrJ6PLqEEDgZYtL1vFlIf0_C9SO0UPBHeRks0,142 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/model.onnx,sha256=0QLOP7dIxQdVWZMwH3iA41FMg3nSJgH_KlpdF50dqS0,154 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_0.pb,sha256=vBRtRagPhbZGk_pp35bJnnqw8va3HLQEeA-gRpGr_cg,59 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_1.pb,sha256=GLkOWs-6gJxZOVVgeCGpbbxY4U3jqjvRYYSunDQHxjQ,59 +onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/output_0.pb,sha256=e61ZBx9CxyY306l5aTy6WcFQLoN6X93lXGQ6bjJl1NU,68 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/model.onnx,sha256=LG4PKAQcvKETW_3kJrSXGFi1WrP_osg47XdIotLXITc,167 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_0.pb,sha256=yyF0q6vMUHrYoNxDxHkS1M1J57ABoWCxVPikiSbgt9I,494 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_1.pb,sha256=yhmmpWW5p4InqcZXi6vWNboAzILeHxIStUce2hV1TeQ,49 +onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/output_0.pb,sha256=qBxhB5FE97cuhUy9PLy4vufyWq3WslKpVW9AszsMxoQ,503 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/model.onnx,sha256=HELtLeN0P__CPF4SuXLa8Qkam3xmJp-Wt4S0DpQmfrk,182 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_0.pb,sha256=M0-FUiXusNZj8HLlUaJlCacWI_VvmB7CXwEQm7W8-_o,376 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_1.pb,sha256=cmiv6qNYN8mNf9Mbmi3IZSAgZ1arXHV1abF_FizB1vk,133 +onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/output_0.pb,sha256=WbhBsgrQao6_fBtCLQYp6UGrGmVRcnMk1H7xyusFeG8,385 +onnx/backend/test/data/node/test_blackmanwindow/model.onnx,sha256=Nx4NbJvhAjOy2ul7cNMiqQFvHzyHF7xBvyni8rB0c8E,99 +onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/output_0.pb,sha256=QEyFOY7f7d5d6hXJXS2YcofZOC6EvZ9P5Z0EdnwSZfw,49 +onnx/backend/test/data/node/test_blackmanwindow_expanded/model.onnx,sha256=05pJhIQZB2um1j-TNW7okCAE3V_VDP6y3so0xkUc_Y4,4244 +onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/output_0.pb,sha256=QEyFOY7f7d5d6hXJXS2YcofZOC6EvZ9P5Z0EdnwSZfw,49 +onnx/backend/test/data/node/test_blackmanwindow_symmetric/model.onnx,sha256=X26VKulL-8l4oQJJbri3-rauH9EmYfdOt95QNjx5sIk,126 +onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/output_0.pb,sha256=GouRkZAQK55fAvVOQrmvZTSQ2Jfvsa2jDGWVIAc6gS0,49 +onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/model.onnx,sha256=PcLK0s5KHCgn2quKjikZV8V1ouRwP7Y06MbWwXStF9w,4814 +onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/output_0.pb,sha256=GouRkZAQK55fAvVOQrmvZTSQ2Jfvsa2jDGWVIAc6gS0,49 +onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/model.onnx,sha256=YUGbe3mkcONpMmBiFXNDkABN_fAmVzhOlK2drGk3Ngc,138 +onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=7PtSEfkVZD2hMxs2mjj8K-ie6Rcy_-janaLIcnczEFs,39 +onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=n02cVMmSsmO-C3IqgA3VI65Qt0Mb4nA7308NU_hKx_k,64 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/model.onnx,sha256=ktzB5kiA5Z_8mZ2LMZOUZUQ5oflBTAP5zWi2YIeKYlg,136 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb,sha256=6HkDTeUmWLg8PEFbpSpZLMj7vMfJhi7QuVjK6KzI06Y,111 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb,sha256=C9cN3dfDqwak6remmnIK_aV-FQtJ7ySCfkuCIExKauQ,64 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/model.onnx,sha256=xjx0HgIhT7xF5uEYTBY1pUFrh-EqiDOExLX0wf5mkYk,138 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb,sha256=8mxoy6mEAhl8zQHvPiK2JLR4boRN-SMAUSPCrKsiD9o,111 +onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb,sha256=OcElOz0iQh2Eia2AnUOusERUmJcH7mFl2nFWCgGdc-w,40 +onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/model.onnx,sha256=xDcYeJ8e0GIpKU-Go0rc27SsepZrqRiBz8Km28446JI,138 +onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb,sha256=I2V7DvRr6upYRyk34-P96yMvuJWhF4Sz_7_XZyVkwsI,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb,sha256=n9sfW336MaQ4ijNNykK-UBxM36StBFmAcPedaSQJDsw,112 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/model.onnx,sha256=gXGmktgTmB1CNVKWDMvWh4fnEuEIRI3pfjbUN61-Q00,137 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=ParyS-aBVa8GjFhnqm1i1f4rEDEdtTz-ynPUUMXKqDs,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=qiswSIR8nu6bG-QLS9Qaw9QiA8_EejF0tgaSLGkh0lY,64 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/model.onnx,sha256=JbPMj33Q5PYiBMBKTpkubUtcfEpSaYGMVUFc7XaYj1c,144 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=LtBhzivB33A2b0LCsUfHt5Y6RrzLdifXm_szEZxTUeI,24 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx,sha256=WtIgjGP9M3PHLGX7E91L2e655Qas4B-kE26KuddIGVk,146 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=SZBarEXLiAmmMtV6e2aOt4SOvh64FJ4rEsQKhHGX_eY,25 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/model.onnx,sha256=YAtXAF9CUPHtDSj54NEzfP0TXA_ctyu5F686smbjdtY,142 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=7Qz8Lo4E-yy0GAXUonuuwRh0Z8Jc1p1wxeW7HkW-xTw,24 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx,sha256=FGNnwAJFDcHl_GMnAdOx6ynBtWPLv8FjejsF-1jyCz8,146 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=h039zyELcZcpQhersHdamwP90FnjTa10kcnJey5R8aw,25 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx,sha256=Zsx5aLgXOgRjD44NoL8B-3-K0LtkjSZOeqWEsuXOua0,144 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=SZBarEXLiAmmMtV6e2aOt4SOvh64FJ4rEsQKhHGX_eY,25 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=6EqKANtEJB2xF8YGXM1CDK1DwS3DlyAop1STxjilaXw,59 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx,sha256=CkgVeO9R-XyRTqVbESVNm89h1Jm5xVOrrwFz4_qhRvg,146 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb,sha256=SZBarEXLiAmmMtV6e2aOt4SOvh64FJ4rEsQKhHGX_eY,25 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb,sha256=ZT6CalLiZzWjyWFEpr6xB4ak696o1vWVXVN3RGhrVjw,39 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/model.onnx,sha256=n7XSkIJhyrxS_yacUBhMplbx5mW0M1IWIftM1ohBz6k,142 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb,sha256=LtBhzivB33A2b0LCsUfHt5Y6RrzLdifXm_szEZxTUeI,24 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb,sha256=kC4bOooA-vaomDF5e9FmYqgjyqceE_FtpFJ5hs8U-Eo,59 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/model.onnx,sha256=h5i0zN-tLOpe_0wOiHPEBKV-SyJGQNkMZVB5NYVUYCg,144 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb,sha256=LtBhzivB33A2b0LCsUfHt5Y6RrzLdifXm_szEZxTUeI,24 +onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb,sha256=8e7_aLpslEN2xhMxK1pH8qGRug9HAyxdEPNXYZ6ID64,39 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx,sha256=JD2-849kGHMI4x2cHXa9U6TmO2sAkZ3gJ_HBbN1ii04,144 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=h039zyELcZcpQhersHdamwP90FnjTa10kcnJey5R8aw,25 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=v_5rzjBTkxzt-_ICVoQgnB_eV1Tnie5q6JjkJ0QKP-4,59 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx,sha256=eluBzmOGShhCCXJArq3r1mUV1NNoPQW7ENZgt6KnxEc,146 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb,sha256=h039zyELcZcpQhersHdamwP90FnjTa10kcnJey5R8aw,25 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb,sha256=FT2Z7uIu5ESy2Zd-HDx9UpqQpQwkSyTcx359XIuEqYE,39 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/model.onnx,sha256=hzePSQvmqiLxPtD8ebZ_aX8-zqh5lxErxh_dhSr35jk,140 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb,sha256=7Qz8Lo4E-yy0GAXUonuuwRh0Z8Jc1p1wxeW7HkW-xTw,24 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb,sha256=v_5rzjBTkxzt-_ICVoQgnB_eV1Tnie5q6JjkJ0QKP-4,59 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/model.onnx,sha256=AV_6YXYlvJKqXT-vRB1L8jFRHvjUZqcCfDPz1pCJAYk,142 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb,sha256=7Qz8Lo4E-yy0GAXUonuuwRh0Z8Jc1p1wxeW7HkW-xTw,24 +onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb,sha256=FT2Z7uIu5ESy2Zd-HDx9UpqQpQwkSyTcx359XIuEqYE,39 +onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/model.onnx,sha256=UmYw2eGyZ74l6dEKYIwIfOBeIORqmU3FVvfRYWKmk58,138 +onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb,sha256=hwIS-rCpVNRgrx9XXtrf4dmhBQ1PbmRzGsSyuzuG7WI,40 +onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/model.onnx,sha256=JJiSGPIuc54lFz16r3mMTbSqvEp1SOvTDSI8v5IbM20,136 +onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb,sha256=8t0QG5JpWVp5SwuBXkzB4NV12BBiHg7Fl58ELPZ0wcU,63 +onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb,sha256=2Rax3-J6ALt-LF7sbmKz6c5PZ0ubZP67DWTBd-E6B_Q,112 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/model.onnx,sha256=5BOYUJJhp-HCRSAGL0yQW4rKhb2Dy4KZrLWGCKIg2TY,137 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb,sha256=ftxQiq2nN6IAr8JHRIQXxG3vMB8Ra957fhAnBRn6HAA,63 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb,sha256=i1o3756jog8U36GzZ8lCj2V6TpOV9DiGMDsWZgVC_58,40 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/model.onnx,sha256=PDUzTIOD_9XfQ28lXpus6bOgXyMOah7hFj03G5rfAEM,142 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=LtBhzivB33A2b0LCsUfHt5Y6RrzLdifXm_szEZxTUeI,24 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx,sha256=drpwgtk8qYAoSW2vdAsEib-BkcWqUFlLxYg2zFybaIw,144 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=SZBarEXLiAmmMtV6e2aOt4SOvh64FJ4rEsQKhHGX_eY,25 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/model.onnx,sha256=l30PrrEcU8x1tJC4Dy-qCrLhjpw9ERBj-PLzQjJUT4Q,140 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=7Qz8Lo4E-yy0GAXUonuuwRh0Z8Jc1p1wxeW7HkW-xTw,24 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx,sha256=thHIELTgNvZO5lYzIIJtBlSct1ezzk65gey0gSYy9RA,144 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=h039zyELcZcpQhersHdamwP90FnjTa10kcnJey5R8aw,25 +onnx/backend/test/data/node/test_cast_FLOAT_to_STRING/model.onnx,sha256=oXjp_mtFxOy8ri3KXT_PxKTYsoou2No1D5zA6P0xXHo,136 +onnx/backend/test/data/node/test_cast_FLOAT_to_STRING/test_data_set_0/input_0.pb,sha256=JnNpBHNwQmCts1dqNwxlHQe57ohJ0IXxvibJD_HNEPM,63 +onnx/backend/test/data/node/test_cast_FLOAT_to_STRING/test_data_set_0/output_0.pb,sha256=v40vkBihrsiWNAdrfrIp7q4NL0jW69jAVuhJPFMDUW8,155 +onnx/backend/test/data/node/test_cast_STRING_to_FLOAT/model.onnx,sha256=lSZIg2abxNg7NSgdr_X3bIP_qj1T33HzjcAGXl3ADSM,136 +onnx/backend/test/data/node/test_cast_STRING_to_FLOAT/test_data_set_0/input_0.pb,sha256=Lk6xhMerJC15fOneCl4LUJFMKPdWwhs9XpoU2KT9Dbk,128 +onnx/backend/test/data/node/test_cast_STRING_to_FLOAT/test_data_set_0/output_0.pb,sha256=0jolK7AVdqKeYqxXZl_bMAlnbkHhPocU-fidVgDsG9g,64 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx,sha256=YQ4ZCMwh-gbOBlr3rdugNFOp72VaRtIeOr1f3kYoYZo,174 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=rQf9LxLJpkVz1NF3Qz9Kl5mVhP47vUN1yYXF20JTlek,24 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx,sha256=WiyOOX-Y-6P3faSmHs-Cjuz-Z-f5-RqF_Ekm7ratf7s,176 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=QM8hnPTZ33aYdSJgsPJvqdyptgAVPUAUodmmH8L9TF4,28 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx,sha256=tWdxCxKv5gVAxIs_HX_WgjlUfdfzeK-f8tfe-kFx1yU,172 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=_vDEFU57JT2za_jNyF-ZHu_57Bz6qCs-Dvq0uS6FO1Q,24 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx,sha256=yIf1mekJb4xVOLhZ-jzFVspkhZP6AqoodN9Xzw9oYJw,176 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=PZeCyweX3VwJui52Ui3kl4hTH7vHKjsoTtuQvlCTgOA,39 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=AzBoOCQwvyfWbloJz8R6GnyZwRP52aEUFZcV6t5aHT8,28 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx,sha256=dHPvOMc_zFu8Cq4uV_IvBY1SbLZ0FWB1NlGYNSSy-g0,172 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=rQf9LxLJpkVz1NF3Qz9Kl5mVhP47vUN1yYXF20JTlek,24 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx,sha256=8xiEfi1Au1nTncFnWS9Ax9JBR-LhI-P8HeO2zUR63UY,174 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=QM8hnPTZ33aYdSJgsPJvqdyptgAVPUAUodmmH8L9TF4,28 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx,sha256=E5Gx8glEdHFa0mKne0QjBEECt480UqPf6IIC4IBL33k,170 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=_vDEFU57JT2za_jNyF-ZHu_57Bz6qCs-Dvq0uS6FO1Q,24 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx,sha256=Bn-zRSV38n9IWoz-LRfPPQdsHAfJTejDMfHgOwqAq7k,174 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=1cYXy_vEumy7czuFWv4GoKLnGJKHuB5c3YRtsToZ6Ew,59 +onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=AzBoOCQwvyfWbloJz8R6GnyZwRP52aEUFZcV6t5aHT8,28 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/model.onnx,sha256=DnwIcxZh2cIZwqijE6VzVQ7et2j-zGA4bwloJ5mEa_8,166 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=7PtSEfkVZD2hMxs2mjj8K-ie6Rcy_-janaLIcnczEFs,39 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_1.pb,sha256=eVvVIPFvWexMatIK3osv-P9GpyKJVe2oZOQcMAqBIUc,16 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=n02cVMmSsmO-C3IqgA3VI65Qt0Mb4nA7308NU_hKx_k,64 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/model.onnx,sha256=njhZ1OydpvIZtZXI8xyTKksTfNJ6eHMcIEAMOUO3dvg,178 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=7PtSEfkVZD2hMxs2mjj8K-ie6Rcy_-janaLIcnczEFs,39 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=eVvVIPFvWexMatIK3osv-P9GpyKJVe2oZOQcMAqBIUc,16 +onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=n02cVMmSsmO-C3IqgA3VI65Qt0Mb4nA7308NU_hKx_k,64 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/model.onnx,sha256=7B7d3D1qmT2LkJdP8SdUkQn9Dz3nyZHRltZC-fE9usg,160 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb,sha256=6HkDTeUmWLg8PEFbpSpZLMj7vMfJhi7QuVjK6KzI06Y,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_1.pb,sha256=MYlnUln6bu-TntGNfFLCBihv1cs-8cz1xCxWjfka80Q,16 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb,sha256=C9cN3dfDqwak6remmnIK_aV-FQtJ7ySCfkuCIExKauQ,64 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/model.onnx,sha256=5oLy0QhHnMA1g52CPPFIRq-xTCbh4LnJMJ3XoWa1NiE,162 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb,sha256=8mxoy6mEAhl8zQHvPiK2JLR4boRN-SMAUSPCrKsiD9o,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_1.pb,sha256=N-V-03btMN0Lrpbsfmgs7wWH-4OWb2xxPeGE0rKB3b4,14 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb,sha256=OcElOz0iQh2Eia2AnUOusERUmJcH7mFl2nFWCgGdc-w,40 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/model.onnx,sha256=YRz8tBVKC-mJKiElO-PIX9kb6HcPiZjMhGM--5Xnpr4,174 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=8mxoy6mEAhl8zQHvPiK2JLR4boRN-SMAUSPCrKsiD9o,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=N-V-03btMN0Lrpbsfmgs7wWH-4OWb2xxPeGE0rKB3b4,14 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=OcElOz0iQh2Eia2AnUOusERUmJcH7mFl2nFWCgGdc-w,40 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/model.onnx,sha256=k7iwKihpVFbELSK0xZ8CR87GMm2CMYwWDFZMG3yc_uc,172 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=6HkDTeUmWLg8PEFbpSpZLMj7vMfJhi7QuVjK6KzI06Y,111 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=MYlnUln6bu-TntGNfFLCBihv1cs-8cz1xCxWjfka80Q,16 +onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=C9cN3dfDqwak6remmnIK_aV-FQtJ7ySCfkuCIExKauQ,64 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/model.onnx,sha256=VBai4YMbWPo6w6_GJrKSfgQk5zEQXOfHrs_SUY75Y7E,162 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb,sha256=I2V7DvRr6upYRyk34-P96yMvuJWhF4Sz_7_XZyVkwsI,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_1.pb,sha256=vhTwWTCgkF298o_bZZUOH-ibrd0YoXZ01obPMsL4Oms,20 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb,sha256=n9sfW336MaQ4ijNNykK-UBxM36StBFmAcPedaSQJDsw,112 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/model.onnx,sha256=x0BW4kXZXOjW0jE7L_Qq6mc-BCUpgLS-Rn0uTnRj9PU,174 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_0.pb,sha256=I2V7DvRr6upYRyk34-P96yMvuJWhF4Sz_7_XZyVkwsI,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_1.pb,sha256=vhTwWTCgkF298o_bZZUOH-ibrd0YoXZ01obPMsL4Oms,20 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/output_0.pb,sha256=n9sfW336MaQ4ijNNykK-UBxM36StBFmAcPedaSQJDsw,112 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/model.onnx,sha256=Eu1V1mEbu_80W35n5zgep9f0Vu02olDBWkdHSUajBoE,161 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb,sha256=ParyS-aBVa8GjFhnqm1i1f4rEDEdtTz-ynPUUMXKqDs,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_1.pb,sha256=KIwhetRSPHhtBbjTD_bTqAHja__yW558rw5Wnw71d2w,16 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb,sha256=qiswSIR8nu6bG-QLS9Qaw9QiA8_EejF0tgaSLGkh0lY,64 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/model.onnx,sha256=Y1RHQkNmTHdlVlQx41vPLTi6eZW74MScYXes4HaX9uA,173 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=ParyS-aBVa8GjFhnqm1i1f4rEDEdtTz-ynPUUMXKqDs,39 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=KIwhetRSPHhtBbjTD_bTqAHja__yW558rw5Wnw71d2w,16 +onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=qiswSIR8nu6bG-QLS9Qaw9QiA8_EejF0tgaSLGkh0lY,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx,sha256=_7rBNP5_tcT7G95L7-r7VPHjrbLdrNufuQrOpmDgIqg,168 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=-uKNW4mpQwdgDLta2kcp4pDg80rP_hPfNQjxU0CKXsM,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_1.pb,sha256=KkaD7OPzRa7CZ0KlWn_HP0vSR0gnNEauMENHnDPLD0A,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=01vlJpEb85X8qTFoKW7K1G5MAeh2DTJWVL4w8YuhWEk,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/model.onnx,sha256=YHDuhsKsteY0sDXHF6BRkfWI6ksqQVaVXE_ww8u5ihk,180 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=-uKNW4mpQwdgDLta2kcp4pDg80rP_hPfNQjxU0CKXsM,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=KkaD7OPzRa7CZ0KlWn_HP0vSR0gnNEauMENHnDPLD0A,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=01vlJpEb85X8qTFoKW7K1G5MAeh2DTJWVL4w8YuhWEk,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/model.onnx,sha256=P0K2sstfmNNxV-Zxcgy0D2S_KeZTFNZEwR8ozbSaDtg,166 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb,sha256=-uKNW4mpQwdgDLta2kcp4pDg80rP_hPfNQjxU0CKXsM,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_1.pb,sha256=KkaD7OPzRa7CZ0KlWn_HP0vSR0gnNEauMENHnDPLD0A,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb,sha256=01vlJpEb85X8qTFoKW7K1G5MAeh2DTJWVL4w8YuhWEk,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/model.onnx,sha256=rkURUkwyGldol1Q3gFhiVLOGRjnP2KZrwk5hwOuk-sE,178 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=-uKNW4mpQwdgDLta2kcp4pDg80rP_hPfNQjxU0CKXsM,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=KkaD7OPzRa7CZ0KlWn_HP0vSR0gnNEauMENHnDPLD0A,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=01vlJpEb85X8qTFoKW7K1G5MAeh2DTJWVL4w8YuhWEk,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx,sha256=CbPHcPiclakhyVubekP2tAAOVwpHfEeGIL5N4DuhGaY,168 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb,sha256=GbmXPGmbF_NpMG0S3l3HT0svUuj6oSl7XNEP8dZjJ2c,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_1.pb,sha256=JUazImFbYsitER0t-H_pod69ENTey8wUpl7mqRCY6ow,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb,sha256=MVDRtjmyPqffFU5o1xbqz9xN8QDJU90w6EDVObeUpgA,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/model.onnx,sha256=qodp-vPzGeY9sXLy-RUScjd1nOVK3z_n_EQ3k6DhNLQ,180 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=GbmXPGmbF_NpMG0S3l3HT0svUuj6oSl7XNEP8dZjJ2c,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=JUazImFbYsitER0t-H_pod69ENTey8wUpl7mqRCY6ow,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=MVDRtjmyPqffFU5o1xbqz9xN8QDJU90w6EDVObeUpgA,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/model.onnx,sha256=61ngT7DdC4KaRASuPBEafIcvkFxVVREi9bS-fqdzKhk,164 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb,sha256=GbmXPGmbF_NpMG0S3l3HT0svUuj6oSl7XNEP8dZjJ2c,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_1.pb,sha256=JUazImFbYsitER0t-H_pod69ENTey8wUpl7mqRCY6ow,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb,sha256=MVDRtjmyPqffFU5o1xbqz9xN8QDJU90w6EDVObeUpgA,64 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/model.onnx,sha256=6GsUAAhG7k0dYHGI9RVtIq0zRPgvoDGjZFS91yvxlWc,176 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=GbmXPGmbF_NpMG0S3l3HT0svUuj6oSl7XNEP8dZjJ2c,25 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=JUazImFbYsitER0t-H_pod69ENTey8wUpl7mqRCY6ow,16 +onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=MVDRtjmyPqffFU5o1xbqz9xN8QDJU90w6EDVObeUpgA,64 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/model.onnx,sha256=_2MqwOb5eCZjJci_vBnCsCMF9nPjCIVL7A0v2zip8VI,166 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_1.pb,sha256=kSiWwieTCrJq7AJKpR9ekqOqJBTrdY-bCM2yOCaW4iU,14 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb,sha256=hwIS-rCpVNRgrx9XXtrf4dmhBQ1PbmRzGsSyuzuG7WI,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/model.onnx,sha256=AtB7w5d7DSR6icDcU0aqRSGioa4x9cvalbb--JsUoBI,178 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_1.pb,sha256=kSiWwieTCrJq7AJKpR9ekqOqJBTrdY-bCM2yOCaW4iU,14 +onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/output_0.pb,sha256=hwIS-rCpVNRgrx9XXtrf4dmhBQ1PbmRzGsSyuzuG7WI,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/model.onnx,sha256=EtQCv-7ST7fh8KY-Wr5j9OaCrl8OPM5mT0OsmFU-oXM,160 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb,sha256=8t0QG5JpWVp5SwuBXkzB4NV12BBiHg7Fl58ELPZ0wcU,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_1.pb,sha256=7HlEm9eEzvEsmzdE9hUccjLKqLBR_MWT1p_wtmFSK6M,20 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb,sha256=2Rax3-J6ALt-LF7sbmKz6c5PZ0ubZP67DWTBd-E6B_Q,112 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/model.onnx,sha256=_5Sa-wa8Q1Hl_zhj_22Jl4YIiPXSiE4WagPGi67gWEM,172 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_0.pb,sha256=8t0QG5JpWVp5SwuBXkzB4NV12BBiHg7Fl58ELPZ0wcU,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_1.pb,sha256=7HlEm9eEzvEsmzdE9hUccjLKqLBR_MWT1p_wtmFSK6M,20 +onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/output_0.pb,sha256=2Rax3-J6ALt-LF7sbmKz6c5PZ0ubZP67DWTBd-E6B_Q,112 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/model.onnx,sha256=_CaKqMq8j_A8C1LvQT3Fgqfc-FEjzbR8rp_2gKaVcL8,161 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb,sha256=ftxQiq2nN6IAr8JHRIQXxG3vMB8Ra957fhAnBRn6HAA,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_1.pb,sha256=Pqb0Ny8b8X1hdAv4KOUYnn0WdFc9nvx-PivzwOErd7I,14 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb,sha256=i1o3756jog8U36GzZ8lCj2V6TpOV9DiGMDsWZgVC_58,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/model.onnx,sha256=TuNswukPgNPKHW4Wu4aPM_Vc6XPZU67vlhs9D8Cc5MM,173 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_0.pb,sha256=ftxQiq2nN6IAr8JHRIQXxG3vMB8Ra957fhAnBRn6HAA,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_1.pb,sha256=Pqb0Ny8b8X1hdAv4KOUYnn0WdFc9nvx-PivzwOErd7I,14 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/output_0.pb,sha256=i1o3756jog8U36GzZ8lCj2V6TpOV9DiGMDsWZgVC_58,40 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/model.onnx,sha256=nUWiPHHN7qMMbZJ4nk1xlnRIDdVL8u6J4CMNYg7jS2c,166 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb,sha256=NFS3HAOUuoWCepp_Zv1q6mjU1O4_wD8KDsZ2QeMWHU8,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb,sha256=7TfQhmVJAE-kiPL5eMn9NFlaqawzV9JHI5Us8Pt3sgU,24 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx,sha256=SzU8hYdSz_szSQgFCegEKOtuo687h03fUQH4GoIqtsM,168 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb,sha256=LBeVefhklG4MWxt46AVYXNURCljJYQrXKIm3Abk_TwQ,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb,sha256=-uKNW4mpQwdgDLta2kcp4pDg80rP_hPfNQjxU0CKXsM,25 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx,sha256=MKATB_5xAakfmSC1ofVF39SdmC75UZeizlvB3JavbC8,180 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb,sha256=LBeVefhklG4MWxt46AVYXNURCljJYQrXKIm3Abk_TwQ,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb,sha256=-uKNW4mpQwdgDLta2kcp4pDg80rP_hPfNQjxU0CKXsM,25 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx,sha256=IisbvvI-LCryEB5n9eXsGnaR25c-RktTn7GkWAgJixA,178 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb,sha256=NFS3HAOUuoWCepp_Zv1q6mjU1O4_wD8KDsZ2QeMWHU8,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb,sha256=7TfQhmVJAE-kiPL5eMn9NFlaqawzV9JHI5Us8Pt3sgU,24 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/model.onnx,sha256=Kq3rYR4dkP3Fn87gxhAJm8Zbu9ELxXk-4yI9gpQW_cM,164 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb,sha256=KQoS32qw37lSLEaIjNMT7vpg8pcVkqdPbOY7jR6LzFQ,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb,sha256=fFXiNax37-Vw_Hj5HoaUS1DHonjd4lUuJEJUj4WA_zo,24 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx,sha256=vS3zWRN3jNwwwRepF0BgtUTdvS5XmxSU2o8hXzZjkYo,168 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb,sha256=CJtjieFVi77kv2L3Uyg0HJOWnnF10wHYN6XnQ6CYrkU,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb,sha256=GbmXPGmbF_NpMG0S3l3HT0svUuj6oSl7XNEP8dZjJ2c,25 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx,sha256=jsHsXPPvoUiqE4AsV6FhxLEJ-ftRcHfVk-q3ZGFLZ5A,180 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb,sha256=CJtjieFVi77kv2L3Uyg0HJOWnnF10wHYN6XnQ6CYrkU,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb,sha256=GbmXPGmbF_NpMG0S3l3HT0svUuj6oSl7XNEP8dZjJ2c,25 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/model.onnx,sha256=iPcJEbvH8QMkN71Obm87CB820t0GlYGmnWf9lNgepnY,176 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb,sha256=h-Mw8kpqdER-gQV9wnNRomY7p72FnbzKkvgjriulnMI,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb,sha256=KQoS32qw37lSLEaIjNMT7vpg8pcVkqdPbOY7jR6LzFQ,10 +onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb,sha256=fFXiNax37-Vw_Hj5HoaUS1DHonjd4lUuJEJUj4WA_zo,24 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING/model.onnx,sha256=w589WZH9PSqlDFQ9vAWc0YgmX53W4bsRFr6mF5vYPHc,160 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING/test_data_set_0/input_0.pb,sha256=JnNpBHNwQmCts1dqNwxlHQe57ohJ0IXxvibJD_HNEPM,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING/test_data_set_0/input_1.pb,sha256=jfaZUJmaBdOG733Ji57TEocDjiMfW1mvNCBdAwAEWgo,21 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING/test_data_set_0/output_0.pb,sha256=v40vkBihrsiWNAdrfrIp7q4NL0jW69jAVuhJPFMDUW8,155 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING_expanded/model.onnx,sha256=1XY1VsuSBJkfL4Fo8lmTYYntK_ki3_UYpr8IrNwh6Tk,172 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING_expanded/test_data_set_0/input_0.pb,sha256=JnNpBHNwQmCts1dqNwxlHQe57ohJ0IXxvibJD_HNEPM,63 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING_expanded/test_data_set_0/input_1.pb,sha256=jfaZUJmaBdOG733Ji57TEocDjiMfW1mvNCBdAwAEWgo,21 +onnx/backend/test/data/node/test_castlike_FLOAT_to_STRING_expanded/test_data_set_0/output_0.pb,sha256=v40vkBihrsiWNAdrfrIp7q4NL0jW69jAVuhJPFMDUW8,155 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT/model.onnx,sha256=T3kwM7x-IYfd27SIoiCVj8xouHNE7RaE6n7J-aplxak,160 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT/test_data_set_0/input_0.pb,sha256=Lk6xhMerJC15fOneCl4LUJFMKPdWwhs9XpoU2KT9Dbk,128 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT/test_data_set_0/input_1.pb,sha256=SQtYejRQrhm-hC4PVdWO2parwQBWBNcBOGwdX55zpdg,16 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT/test_data_set_0/output_0.pb,sha256=0jolK7AVdqKeYqxXZl_bMAlnbkHhPocU-fidVgDsG9g,64 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT_expanded/model.onnx,sha256=o96PDcXHi0JzT0dCXxsmDdNVG5UmAEFC9ZDDzvbbrsk,172 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT_expanded/test_data_set_0/input_0.pb,sha256=Lk6xhMerJC15fOneCl4LUJFMKPdWwhs9XpoU2KT9Dbk,128 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT_expanded/test_data_set_0/input_1.pb,sha256=SQtYejRQrhm-hC4PVdWO2parwQBWBNcBOGwdX55zpdg,16 +onnx/backend/test/data/node/test_castlike_STRING_to_FLOAT_expanded/test_data_set_0/output_0.pb,sha256=0jolK7AVdqKeYqxXZl_bMAlnbkHhPocU-fidVgDsG9g,64 +onnx/backend/test/data/node/test_ceil/model.onnx,sha256=zYQ7FyzP6UWksThCpmDNZVL7ACGAVk45wCUk7MSpMPw,99 +onnx/backend/test/data/node/test_ceil/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_ceil/test_data_set_0/output_0.pb,sha256=zFFujcTZbJ_iUdvnj1WgKihPqud_iXTK61jQn2s3fkU,254 +onnx/backend/test/data/node/test_ceil_example/model.onnx,sha256=8MRvY_buZ3kwGWbrH3N9AtIKqYnHsubJWQBe-Uk8wDg,91 +onnx/backend/test/data/node/test_ceil_example/test_data_set_0/input_0.pb,sha256=oA0la8_u-_HaZWXeP39QnRf3LzBFm_z-OT5ubTiMa_U,17 +onnx/backend/test/data/node/test_ceil_example/test_data_set_0/output_0.pb,sha256=B7VTcXhgHNoWwox6O0nLSYo-xZkobaTvtkPnXWM8T8w,17 +onnx/backend/test/data/node/test_celu/model.onnx,sha256=cAr7drqDNV5RDqzClNfkslVJ4K89Qlj0ywgg_uwHiiw,124 +onnx/backend/test/data/node/test_celu/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_celu/test_data_set_0/output_0.pb,sha256=6P8qt55BKmIbeRKrDDUb_9L_ZZgD2nf7uJFA69OD8Os,123 +onnx/backend/test/data/node/test_celu_expanded/model.onnx,sha256=HfTUwa-nDKvHFYB7ANwkEKpTexAJAuNrhXUSPIPIX8Y,485 +onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/output_0.pb,sha256=6P8qt55BKmIbeRKrDDUb_9L_ZZgD2nf7uJFA69OD8Os,123 +onnx/backend/test/data/node/test_center_crop_pad_crop/model.onnx,sha256=_UO9zWEcYILyGcbCnjQg7KHg2LFJw7PxdNFcUlmO68g,153 +onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_0.pb,sha256=gf54Qr4guDZleIe2sau8YNEx-dDwW55nJJ5RqhWYCHk,2414 +onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_1.pb,sha256=azvnzc647fD3maqvDtZTEwrGWfugxBxPHJAPz7424Qk,37 +onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/output_0.pb,sha256=SNJXACP7f4r8OFKE3X8vI4Bfu4kXNPTkemOqeuQifTc,854 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/model.onnx,sha256=2yQn_WyWM7819hVHdgPRMNyxAI_6pTMS5dH_ahRzZrA,161 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_1.pb,sha256=XE-LFxtx5KK6KyhPjIx-Hp-i_db8kg7viI8PN8SDXnc,37 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/output_0.pb,sha256=NwJcXJ-I3-LwyTwk8F6WaLvoITXD4jynu8BnWdMfxdY,1214 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/model.onnx,sha256=3SXsErt7mt9BpECaXiK4kW66R7xeU072PARgYd_fQmc,2658 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_1.pb,sha256=XE-LFxtx5KK6KyhPjIx-Hp-i_db8kg7viI8PN8SDXnc,37 +onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/output_0.pb,sha256=NwJcXJ-I3-LwyTwk8F6WaLvoITXD4jynu8BnWdMfxdY,1214 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/model.onnx,sha256=NxTo_Ni7c8YpJj640cd9qoXA_GdxapFiCCSeLbH_7Xw,177 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_0.pb,sha256=5bJVCfNa9wvtQv3XL4MKOfrM0RylCo4e3iKMenFQojw,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/output_0.pb,sha256=golyE5sd9CtwPUzy7oEWi2ovFIug8BohD5b2N7o2_Xg,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/model.onnx,sha256=WyXAtrdbAMR_xZYhE9W_iHz8P2V3DbLLhVeY2lFeSlI,3485 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_0.pb,sha256=5bJVCfNa9wvtQv3XL4MKOfrM0RylCo4e3iKMenFQojw,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/output_0.pb,sha256=golyE5sd9CtwPUzy7oEWi2ovFIug8BohD5b2N7o2_Xg,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/model.onnx,sha256=ViKPMOcZcmDs3W72cKydVNfdXiz7BzXrzuTJD2BWa-M,177 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/model.onnx,sha256=Na51-QkGvR8-oGz-1V5aWseNqcPL6KwnfSRCrGe91gg,3485 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/model.onnx,sha256=i3QMXxhLCRMRCXHiDBj9X5IwPjkexZK_mCyKeXgBO00,2410 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_0.pb,sha256=gf54Qr4guDZleIe2sau8YNEx-dDwW55nJJ5RqhWYCHk,2414 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_1.pb,sha256=azvnzc647fD3maqvDtZTEwrGWfugxBxPHJAPz7424Qk,37 +onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/output_0.pb,sha256=SNJXACP7f4r8OFKE3X8vI4Bfu4kXNPTkemOqeuQifTc,854 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/model.onnx,sha256=SG0akIxqpCM29L2aTKW_NVPJr9KxJWBGJuENM2EH4o8,204 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/model.onnx,sha256=bH3jKyXyTbQO1v4cdRYuri9vJ78cWi8tR9co_Ihg-ho,3864 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_0.pb,sha256=SIiEQh9DWWergN3i0O3OXxsIpYNH0cA1hQCksZCA6EA,1934 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_1.pb,sha256=4yIx4EW1uo-c7xiAkhnpKeIm-RWjL8oFEHUqTc2ieMM,29 +onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/output_0.pb,sha256=ywUWnOKgTUDpebF1B3HI5cEuEAvmvdsA13IZEnfncZY,1094 +onnx/backend/test/data/node/test_center_crop_pad_pad/model.onnx,sha256=ZsLLWWeEugG7qfPtUUsbt7iBfXtdL1Qoq3zFJ-gyM-A,151 +onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_0.pb,sha256=Brb9NNYy61mIqV0k6WJ2uoox7QOgy-TI61uJhMg0QZw,854 +onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_1.pb,sha256=MicQ1KFx-S6_RlEPgAe1cyjiu2xloE-vov752d7v394,37 +onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/output_0.pb,sha256=TqD45G9p_DkrIF5wtvJXaOW0ls_XSgER9EsfKT66no4,2414 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/model.onnx,sha256=rIrnvjLpY-MpX1WgOkSabprL4n8fLeTTlPfJc9ZCCHc,2379 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_0.pb,sha256=Brb9NNYy61mIqV0k6WJ2uoox7QOgy-TI61uJhMg0QZw,854 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_1.pb,sha256=MicQ1KFx-S6_RlEPgAe1cyjiu2xloE-vov752d7v394,37 +onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/output_0.pb,sha256=TqD45G9p_DkrIF5wtvJXaOW0ls_XSgER9EsfKT66no4,2414 +onnx/backend/test/data/node/test_clip/model.onnx,sha256=LeRDoahciHypJ9D7ArLrfQwYmGTzb2Mco1syI1Dpp4w,139 +onnx/backend/test/data/node/test_clip/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip/test_data_set_0/output_0.pb,sha256=0Mj3n7O3-ghXihrxNll_6tjrgxFo27H4atMMfljBuEg,254 +onnx/backend/test/data/node/test_clip_default_inbounds/model.onnx,sha256=K4rP6tKhvLWvZ25uFXfcgzpjmeBe4fodMVdEp6TWncw,104 +onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_default_inbounds_expanded/model.onnx,sha256=dtxZlZ7xu_1pfCXBFLU8V_bS-YBZeWCxB9mmT1rXhMU,115 +onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_default_int8_inbounds/model.onnx,sha256=gUowpb23puqbhCvxUPiduQpf5-uoFRVsf_28cLYT99E,109 +onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/input_0.pb,sha256=vG4b7OylZbXs1oNvJh6N2DD10wdfMSnVxkKOz7zbvwA,12 +onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/output_0.pb,sha256=p1SpO2Oa2tZ9dMA6FVWw3xl2fU-OVpuE21zP9E4rquQ,12 +onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/model.onnx,sha256=GFvqxihYvSo_9PG2IQbf-cvnA6E56Hkv_VzP1lYBuYM,120 +onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/input_0.pb,sha256=vG4b7OylZbXs1oNvJh6N2DD10wdfMSnVxkKOz7zbvwA,12 +onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/output_0.pb,sha256=p1SpO2Oa2tZ9dMA6FVWw3xl2fU-OVpuE21zP9E4rquQ,12 +onnx/backend/test/data/node/test_clip_default_int8_max/model.onnx,sha256=EtzpiOh8w6lp9tqy_kO-yRryxqohJAFuZskjyH-ctgQ,138 +onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_0.pb,sha256=rzR9S2WkPtQ_eTqlg48tVCWUU-HSMIndc3aNczLLc8I,73 +onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_1.pb,sha256=CEHeigf36q5XZtDez_5a1gT5ZJRMYNVEBF9z_OHEBEU,10 +onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/output_0.pb,sha256=tO69iQwwhb-FI6NNsgjnmVvfGzuTybog0CfmVRQ3lfY,73 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/model.onnx,sha256=h1njraDyzwOWbA8QLswnmldaGPRfHrV2lzjSi-3FFyw,311 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_0.pb,sha256=rzR9S2WkPtQ_eTqlg48tVCWUU-HSMIndc3aNczLLc8I,73 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_1.pb,sha256=CEHeigf36q5XZtDez_5a1gT5ZJRMYNVEBF9z_OHEBEU,10 +onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/output_0.pb,sha256=tO69iQwwhb-FI6NNsgjnmVvfGzuTybog0CfmVRQ3lfY,73 +onnx/backend/test/data/node/test_clip_default_int8_min/model.onnx,sha256=StI7Sylxxi_7VU7dPaKQ3MFSOkXIOuFMgIbcmZ7SVYE,136 +onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_0.pb,sha256=jlYHFzRpo9mRew7WTiCIRuEiMgtorH1Bs1r4lKBBdz8,73 +onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_1.pb,sha256=6kLq4kB4db3nFcoSmyNZk_unkHDDP5rztDpt8kwhzD4,10 +onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/output_0.pb,sha256=cxOphxSnH_muVv845xL_eqeIP1yVmxRCqmu92YISig4,73 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/model.onnx,sha256=CTaB_ZhST7UKYki3k9KcHg_d7Ov6pv2sZIo_A239SBo,309 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_0.pb,sha256=jlYHFzRpo9mRew7WTiCIRuEiMgtorH1Bs1r4lKBBdz8,73 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_1.pb,sha256=6kLq4kB4db3nFcoSmyNZk_unkHDDP5rztDpt8kwhzD4,10 +onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/output_0.pb,sha256=cxOphxSnH_muVv845xL_eqeIP1yVmxRCqmu92YISig4,73 +onnx/backend/test/data/node/test_clip_default_max/model.onnx,sha256=FL6R-HHUIBFafkhbS6htUeEGGIEAZ-1TdQJKD3gPGMI,133 +onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_0.pb,sha256=bLIkw3E_ZyNzOrq7tsNCLynmVOluwxDhZiJUPP_menI,254 +onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_1.pb,sha256=-8abKXDhQDgDtXksv1K3VkLu2XJbj3RVgko0p7nK-8o,13 +onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/output_0.pb,sha256=I04WldqbkTeeL0KpKpuo4Aw_r1J6E5FHlnYOTQjMQxU,254 +onnx/backend/test/data/node/test_clip_default_max_expanded/model.onnx,sha256=swEbjGDk9FNUHy4gDxWQSCJ5BNna0Co1PGXv9lyKzrY,296 +onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_0.pb,sha256=bLIkw3E_ZyNzOrq7tsNCLynmVOluwxDhZiJUPP_menI,254 +onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_1.pb,sha256=-8abKXDhQDgDtXksv1K3VkLu2XJbj3RVgko0p7nK-8o,13 +onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/output_0.pb,sha256=I04WldqbkTeeL0KpKpuo4Aw_r1J6E5FHlnYOTQjMQxU,254 +onnx/backend/test/data/node/test_clip_default_min/model.onnx,sha256=HXEnek_-WWBF-8Qh73uGU59Os6hZDH2x71kE2X35ZnA,131 +onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_1.pb,sha256=YN1rp1oEc2SLKQVP1qKZlBVrrUYAUCXA0Ids1IC8cVo,13 +onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_clip_default_min_expanded/model.onnx,sha256=dqAs6KUlnP5pfOaHxVCo5kEycyWSywvoqVANWd4waEo,294 +onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_1.pb,sha256=YN1rp1oEc2SLKQVP1qKZlBVrrUYAUCXA0Ids1IC8cVo,13 +onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_clip_example/model.onnx,sha256=jmMzre4t9LogRagPrYJD0Qk_VHljfUufDPpUJWTFj04,131 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_0.pb,sha256=9k-PJmwQ91koTiiJe8X4rULQA1y9P3aSpPPuUdAwT9E,21 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_example/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_example_expanded/model.onnx,sha256=eM62MADuYthk8xV0LVHcf8-wSqROjU_IgJXQlg9RGyU,578 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_0.pb,sha256=9k-PJmwQ91koTiiJe8X4rULQA1y9P3aSpPPuUdAwT9E,21 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_expanded/model.onnx,sha256=bTXSndV3iagfSKE9Aw3psPNzl6a0l7_M_iLpujEm7n4,530 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_1.pb,sha256=BRepSTg3YLUzFaeEDm7kjV41FnB7WdzkW7ynoPYkPGs,13 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_2.pb,sha256=qLMCCKsNYs42OTq0_Gwqq2h8q5iUz8-GZ2CCZo1GGT4,13 +onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/output_0.pb,sha256=0Mj3n7O3-ghXihrxNll_6tjrgxFo27H4atMMfljBuEg,254 +onnx/backend/test/data/node/test_clip_inbounds/model.onnx,sha256=idZxS7uYmOrM7b4yKftomS-sd83XIBs8zBIZAEEWXf8,132 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_inbounds_expanded/model.onnx,sha256=OvcxAGIGUWSIMmNoGIUt6XJRdTRgGIvhveBRAaoM3sc,587 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_clip_outbounds/model.onnx,sha256=DKK18noAKi9Btc-47_kGK2uuLsHlfmuRs-bXv1P6wh4,133 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_0.pb,sha256=V0F1iOI7iAm2K90hqNNItzlFwxXH3rKXm9a5wXB-qYQ,21 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/output_0.pb,sha256=vvqmqBIu_2d9LT3R85W2RtMis_GI5BLVrhWdaGNRMB0,21 +onnx/backend/test/data/node/test_clip_outbounds_expanded/model.onnx,sha256=lGBTvlb3SGg-7LQFxUUhPvDYorM4NudbNqk3khkv8HI,596 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_0.pb,sha256=V0F1iOI7iAm2K90hqNNItzlFwxXH3rKXm9a5wXB-qYQ,21 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/output_0.pb,sha256=vvqmqBIu_2d9LT3R85W2RtMis_GI5BLVrhWdaGNRMB0,21 +onnx/backend/test/data/node/test_clip_splitbounds/model.onnx,sha256=57xFzbLRYD7xPA_1rSX225JFx7FpBqe-TxAh0yRGutA,135 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_0.pb,sha256=leQohPrMDQG6Z0CCWG_wiYb4jpwYZA2BG_LvQcmbl9o,21 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/output_0.pb,sha256=15BzcxfrfHAuKkv7YEqCqM0o_yR1xECA5GJqzFGwo0Y,21 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/model.onnx,sha256=EfcHHaSmBKZEG32NdMfGA8XQmcxTQrCEHz1Xznl9zC0,613 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_0.pb,sha256=leQohPrMDQG6Z0CCWG_wiYb4jpwYZA2BG_LvQcmbl9o,21 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_1.pb,sha256=DyQyzAiPdgNHN3peR3o7xZVckmF3lQneq_S8M2AMI9w,13 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_2.pb,sha256=3sy_5aJR44lfPhtuIRBCqv9TlSqgBMK4u192l4On_5I,13 +onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/output_0.pb,sha256=15BzcxfrfHAuKkv7YEqCqM0o_yR1xECA5GJqzFGwo0Y,21 +onnx/backend/test/data/node/test_col2im/model.onnx,sha256=IOf8vTDwhQGOtllNTnICmKiz07hm1rxWD-Nc7NNADfk,206 +onnx/backend/test/data/node/test_col2im/test_data_set_0/input_0.pb,sha256=5A3VwvCazC3A3QMIcJp8G1vvMKrc67-pH8D3QiYJxrw,117 +onnx/backend/test/data/node/test_col2im/test_data_set_0/input_1.pb,sha256=sC33YEdMBoSDhAdtQ124hhrmtKVAxoV-pDz8e6zRvRk,35 +onnx/backend/test/data/node/test_col2im/test_data_set_0/input_2.pb,sha256=dDzuXwdlcFBeNNxzJK0GQtcMTbb_H6Y32BCWnvDooDU,35 +onnx/backend/test/data/node/test_col2im/test_data_set_0/output_0.pb,sha256=xEQ2Kj9FDYM_Uu6NEhi2oPAvBijU8rklQamYJqr4AYs,120 +onnx/backend/test/data/node/test_col2im_5d/model.onnx,sha256=k-5N3_FUpbwT1QXtMqOufg0uQsJxnV4rqswqe8D-NXg,213 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_0.pb,sha256=10NWZ13V9CcUU08fb3zJSdT9Wn1ykGAMSmEV63jwgSc,498 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_1.pb,sha256=mSuKXNsMN1uBSUQ6osPvFSCLieHyPCHcY348CC0BAZ8,43 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_2.pb,sha256=KWWYXJvC1NdLgGh8u0n8JUmPG2N9Ykdsp9YVT_8huiE,43 +onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/output_0.pb,sha256=iEagmo2f_5o9u1f8VbWM0axVO6jVi8PqZ0Kwqew7g8M,503 +onnx/backend/test/data/node/test_col2im_dilations/model.onnx,sha256=V12TeDt8MRMS_EvbIKGg8G1SwMdC75kU_h5nk862Nww,236 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_0.pb,sha256=d9wmnv3b9dr2kDj10v5X5wkY0lIAaxqSoVm_FGKz2TY,97 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_1.pb,sha256=4GVa_GmgAg6wnfkkTNNgGTYtMDQuUT19vWfeDA_9GVw,35 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_2.pb,sha256=bLrs_xcBqV1BYkqqtdhN8gk07hFw_rfW0NpC3S8enAw,35 +onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/output_0.pb,sha256=jZt6LpawiR5-xTQ4emYrD7LTWpTpe3GbIbSV5oKlPo0,165 +onnx/backend/test/data/node/test_col2im_pads/model.onnx,sha256=FszV1KU3PR-9pZE7t4lltctCRUPjhT5FFIUdhGh41mo,230 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_0.pb,sha256=FJT7adhospTzI4VyMN70Qk2Ijori7V0uLua2eLO3wGI,318 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_1.pb,sha256=sC33YEdMBoSDhAdtQ124hhrmtKVAxoV-pDz8e6zRvRk,35 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_2.pb,sha256=dDzuXwdlcFBeNNxzJK0GQtcMTbb_H6Y32BCWnvDooDU,35 +onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/output_0.pb,sha256=Wi5m8n4bgmc9Fvl68grDeS8VTj3pkvBlVCr9wp9QjT4,120 +onnx/backend/test/data/node/test_col2im_strides/model.onnx,sha256=wdgnYE0Qeoy3xRKLMUpR4NOymjxDg9SNtvTbvEkAK3M,232 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_0.pb,sha256=bATQTJp-m3z-CD8kdkzPCHqEkGQCZWzeYH1luHYPsLs,162 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_1.pb,sha256=sC33YEdMBoSDhAdtQ124hhrmtKVAxoV-pDz8e6zRvRk,35 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_2.pb,sha256=zrcpb5IFLjcr6h-Ze3T0j8tMq-I7sAJZD1TULUur5Ew,35 +onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/output_0.pb,sha256=3SveaOMPddbY4IP1dOqylTuVoz7a_KyOLxB45bgvhIo,120 +onnx/backend/test/data/node/test_compress_0/model.onnx,sha256=nodKtdil0L0jbH4L5wO-v7yOu-BP0BkZlQEJDVbvvf8,169 +onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_1.pb,sha256=jw39JH8-z2Ji3LtSHV2AWRWenNBHag9p9CIi0kH0WHs,20 +onnx/backend/test/data/node/test_compress_0/test_data_set_0/output_0.pb,sha256=REWTt5gfMJMzFJqlXfEgkPunKMIa4ztIMdbazCALGAY,32 +onnx/backend/test/data/node/test_compress_1/model.onnx,sha256=QhUJpXVhlcZ5jAmQFQY0LAvCYLZKqCpUxk7bLn-_WCM,169 +onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_1.pb,sha256=cU3M65jPa3QTEGyHULlR-gk02IKzUg28hWixar4xdQ4,19 +onnx/backend/test/data/node/test_compress_1/test_data_set_0/output_0.pb,sha256=P-YBRUIo2dEPuIakb5wO4LXMR_mhYPCtGflcP-3B-qk,28 +onnx/backend/test/data/node/test_compress_default_axis/model.onnx,sha256=Tia1aeKj5DAQqe23y8WKMYY9LzJHn_rWX4hYA189-N4,163 +onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_1.pb,sha256=As8vdbdiBHE5yy7e9p1d0ztqpDC8js6Dnzj3Sz7uWMU,22 +onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/output_0.pb,sha256=5m4bYUDPwIjGY_qUyTFXAxuUzstD-Vi3TTFlwkdjp7w,22 +onnx/backend/test/data/node/test_compress_negative_axis/model.onnx,sha256=qSUsJJPWf-fDfmbGlU3sG-j968n09FJ95FgTeFUhx3U,190 +onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_0.pb,sha256=46laMzhSwTujxNC5wdf57VFKvfNtw0oXjGKcn85m99c,39 +onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_1.pb,sha256=cU3M65jPa3QTEGyHULlR-gk02IKzUg28hWixar4xdQ4,19 +onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/output_0.pb,sha256=P-YBRUIo2dEPuIakb5wO4LXMR_mhYPCtGflcP-3B-qk,28 +onnx/backend/test/data/node/test_concat_1d_axis_0/model.onnx,sha256=UD4hvQQPsO5mdTW7kHiWrpisTxd-QLk_Jdn854AlV0I,161 +onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_0.pb,sha256=M_zmlmaj7q-xos1LgfEPC1kNNKTsWO4Fvr1h-Ep1zaM,22 +onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_1.pb,sha256=ALDN6Sc9t1SBGFf3S6VjvzHPLi6FM7bqSzORcQ78E3I,22 +onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/model.onnx,sha256=YoSMpWext44eCDoh2QV4N8J2chRPhYI2t4bjYD2n1L8,179 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_0.pb,sha256=M_zmlmaj7q-xos1LgfEPC1kNNKTsWO4Fvr1h-Ep1zaM,22 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_1.pb,sha256=ALDN6Sc9t1SBGFf3S6VjvzHPLi6FM7bqSzORcQ78E3I,22 +onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_concat_2d_axis_0/model.onnx,sha256=e2A3L9ryrB2kVlNKX4dcF1wAIQuk6eLWJgJ35yvurSM,173 +onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/output_0.pb,sha256=Ta3eaIezq0mRJM1A9OsJDF7hyiipBPfqZHsahXM5SNo,48 +onnx/backend/test/data/node/test_concat_2d_axis_1/model.onnx,sha256=rFTQnBxGEZCLdelAGH1xXRLwPrJ4bgeZUFcNAtGEctM,173 +onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/output_0.pb,sha256=9BvkeNloIrO5LNPMggPhy2lcCqOOU5HHPdQPj7sEfvw,48 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/model.onnx,sha256=zzVnaH5YLO-T0lWGv-Bexq56fxLAtm9JkkFyQ-0HU4U,191 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/output_0.pb,sha256=9BvkeNloIrO5LNPMggPhy2lcCqOOU5HHPdQPj7sEfvw,48 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/model.onnx,sha256=nR004XJROokQER1gioPgrJx4lNbMRKr53nGnBj8L9EA,191 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_0.pb,sha256=FF2sDSeoQuwLOa3kNb3bHbtcVNAifeP-yk4AM9YE9A4,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_1.pb,sha256=x9-oIRV3uL9uNyxiTOG7Q5zHYeT9DketTiY7dySqaKc,32 +onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/output_0.pb,sha256=Ta3eaIezq0mRJM1A9OsJDF7hyiipBPfqZHsahXM5SNo,48 +onnx/backend/test/data/node/test_concat_3d_axis_0/model.onnx,sha256=LN-VZp2V3JT2FAMnwWn97NDFexgJj7xpOwyztM1GPBA,185 +onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/output_0.pb,sha256=dUvwM04_dv9m8UaqWmWl0QjkurUJSN_oRSXorZ97h2Q,82 +onnx/backend/test/data/node/test_concat_3d_axis_1/model.onnx,sha256=QLwkJrU-3hhnPEFv5-9DAukR_kvj1CGb0CtqmImkYRc,185 +onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/output_0.pb,sha256=2aOEqB0HzGWyPK-b-x4GY4_rB9VAb3Xk195r28cSNMQ,82 +onnx/backend/test/data/node/test_concat_3d_axis_2/model.onnx,sha256=WBBOjo3hw1d_0I7ErVWfYps6q03HwpcoUSGKewUFlhg,185 +onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/output_0.pb,sha256=83yvsYA4HAppNb6e1qyXLKZZOFJwpFvQkNmBQ6VXvgg,82 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/model.onnx,sha256=aywEPDxFVmIGoIi8rFzzhSfsIK5gZ8vk9CLymObB-LY,203 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/output_0.pb,sha256=83yvsYA4HAppNb6e1qyXLKZZOFJwpFvQkNmBQ6VXvgg,82 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/model.onnx,sha256=DzSa3Qr5LYMmo9J8lcvgq86FUEg5Wj9t5zJ31-96l4s,203 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/output_0.pb,sha256=2aOEqB0HzGWyPK-b-x4GY4_rB9VAb3Xk195r28cSNMQ,82 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/model.onnx,sha256=kN_yeyuEFOOXREufwa55NK5mRhj64blkAd1Zcixp3B0,203 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_0.pb,sha256=81NAfcLNqQRpHPhx5OmEJSm6F4NEGzhRgBLOLjv9Kx4,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_1.pb,sha256=msjjoWLAIXh4e0fgz6zQH_f98YwZNfdBOfU870P_dug,50 +onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/output_0.pb,sha256=dUvwM04_dv9m8UaqWmWl0QjkurUJSN_oRSXorZ97h2Q,82 +onnx/backend/test/data/node/test_constant/model.onnx,sha256=2LIGsFcXxxN3I4FhTBDItc8ztDJaDWdmWgAGebfwLMU,224 +onnx/backend/test/data/node/test_constant/test_data_set_0/output_0.pb,sha256=ZtZq7biLE0YlYjO3sb2Ior_w2EOqzpNpNMCGHbGmiVQ,116 +onnx/backend/test/data/node/test_constant_pad/model.onnx,sha256=jrOvIAWfAF0ypDoVNeyQMQwo7iIG5YyIHv68gBkkXZA,186 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_1.pb,sha256=ATAqLmSfBqkY7YZcsD06zkF3azvPnL7hkoPMm3R__Tc,76 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_2.pb,sha256=-iWKiqLhApsL8FEiLSrlvrdAGtuBlTxHvG7p-_FNqzk,15 +onnx/backend/test/data/node/test_constant_pad/test_data_set_0/output_0.pb,sha256=0e78ZdrtxNO0GEW3dObwOBqTpBycxQUoInBNVhnLm7w,1024 +onnx/backend/test/data/node/test_constant_pad_axes/model.onnx,sha256=W0OBa-Xd6snRA2-N9apq1T0zjrZUONgRYHff6PLhbVM,217 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_1.pb,sha256=tY8h_wDfpSXDPKmu9zOpH_G0C_JlFYFRLs84BZy2vw4,44 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_2.pb,sha256=-iWKiqLhApsL8FEiLSrlvrdAGtuBlTxHvG7p-_FNqzk,15 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_3.pb,sha256=pX9n5VloYbf2naQVDVOgUQjBFu_mcvPOWkP1mH0Fwp8,28 +onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/output_0.pb,sha256=32CHhoVQ_jOuUuNIFNIYKynezo6BafmF2Eyrkr2uNjE,592 +onnx/backend/test/data/node/test_constant_pad_negative_axes/model.onnx,sha256=EGqqfYxz807bWrfMqYc0D_vpfv_5WCeVBqq7-6i2XiE,226 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_1.pb,sha256=tY8h_wDfpSXDPKmu9zOpH_G0C_JlFYFRLs84BZy2vw4,44 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_2.pb,sha256=-iWKiqLhApsL8FEiLSrlvrdAGtuBlTxHvG7p-_FNqzk,15 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_3.pb,sha256=jOLO9c9UDkiTUsrm1piTLJODPkSHC2uDBWr6sbTixtY,28 +onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/output_0.pb,sha256=32CHhoVQ_jOuUuNIFNIYKynezo6BafmF2Eyrkr2uNjE,592 +onnx/backend/test/data/node/test_constantofshape_float_ones/model.onnx,sha256=sQCwDpNo0PqmsVKkQol3el-eHjqTOfjbeCVpItZwQv8,156 +onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/input_0.pb,sha256=SF8xOIzH7O17I29ISO9iIIogd75Kt4opGiw4UN5z9Ig,33 +onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/output_0.pb,sha256=fM51l16xt2ADixD3tubDFSZJhvp44ltpkzuAZo1D9tg,109 +onnx/backend/test/data/node/test_constantofshape_int_shape_zero/model.onnx,sha256=LJaRXJUfsvRDgSI_7LXQdGeWF_CPv9xV9NsAs8PTqs0,148 +onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/input_0.pb,sha256=49_f6waZPNPplh_reb2omwHhFxvAn7iTR__LuEBk59Y,17 +onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/output_0.pb,sha256=0v9IGvSgdFHNbGSEn5hgWuc58i5GJAQPlXlTW3A7nQQ,9 +onnx/backend/test/data/node/test_constantofshape_int_zeros/model.onnx,sha256=P0VsXExpr-ki3KRH-86eFFc3yfouXfX2Lsl--VQgf1E,147 +onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/input_0.pb,sha256=_VQY3wcZhcCAEZwbELNR-ceaJwmhW-uKL6DcRBVX2Ks,25 +onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/output_0.pb,sha256=lKYhgMCsEKm6_R6aX9y86EzA3ZggFUKai7DekgAn9rY,252 +onnx/backend/test/data/node/test_conv_with_autopad_same/model.onnx,sha256=JRAdcTUyYemWrJ1WfSemMdVe0o6-oKUQsgowkKNyQ3k,226 +onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_0.pb,sha256=RnJVWHKql-4c51A3JiCTvFe-ry8o5bavOnIotOzZFK8,115 +onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/output_0.pb,sha256=fBuFid7X2GAEdW-WKUKklPs4CDHcf2SMq98fX9QICIQ,51 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/model.onnx,sha256=y8V7Oi4cpuZKy-L9YuLkUGLyUKiGv3XIwv0SOKpsVks,236 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_0.pb,sha256=EKni8PMyz3jKiEUekWtHFQJ_0vQqMDykmd7ijlyvmUk,156 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/output_0.pb,sha256=zWxG_I4hksIoNyVDyHd3focjwFyOzpjzxRY0lKt8hLc,47 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/model.onnx,sha256=YtFVp-6n7Dz2vct6Evkp8n7i76Ml7k6T_GA7MMf6-jk,224 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_0.pb,sha256=EKni8PMyz3jKiEUekWtHFQJ_0vQqMDykmd7ijlyvmUk,156 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/output_0.pb,sha256=jpWXQcHC97bNhULIDaC1cTAxCzLIRdQDp6Uujd7Vt2M,39 +onnx/backend/test/data/node/test_conv_with_strides_padding/model.onnx,sha256=AlxPB95Rk740RmbKoBn3b_TL_3olp6__FCrXvDTITNQ,221 +onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_0.pb,sha256=EKni8PMyz3jKiEUekWtHFQJ_0vQqMDykmd7ijlyvmUk,156 +onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_1.pb,sha256=i8uYkxFsjmh4jNDwmgCtV7jQtF11nwCwISLTKf1COgg,51 +onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/output_0.pb,sha256=KJnfa4Bs2wm6SwFgzBZZWQuQ3rrG5KOYY9bZH4G2toQ,63 +onnx/backend/test/data/node/test_convinteger_with_padding/model.onnx,sha256=rZ9_v1mn3tlT0c4QYmCDv_CsMuzobV9qzFVsA-YiXT8,224 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_0.pb,sha256=Blk9OpAbYayI22rinL6HBBpGT7VxJcAbgYpPMNlfDLs,24 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_1.pb,sha256=6DoOKAFFqEvwzMlQqPnfz-Y99DBZgq3zfgSBJrrG-1c,19 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_2.pb,sha256=ZeQpztgb7wGWXMWNAGDKbvP-wyc-Toe88voMPU1aWKI,19 +onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/output_0.pb,sha256=LvjQOQRGMuP3X76zTRoANF8n3mcJfiY9CEdCsLOXnJs,79 +onnx/backend/test/data/node/test_convinteger_without_padding/model.onnx,sha256=3f-BSu8df7zOqub8da6dejeGah2S4HCeiwgKcb_4W6s,208 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_0.pb,sha256=Blk9OpAbYayI22rinL6HBBpGT7VxJcAbgYpPMNlfDLs,24 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_1.pb,sha256=6DoOKAFFqEvwzMlQqPnfz-Y99DBZgq3zfgSBJrrG-1c,19 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_2.pb,sha256=ZeQpztgb7wGWXMWNAGDKbvP-wyc-Toe88voMPU1aWKI,19 +onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/output_0.pb,sha256=yXCRQ-429TJ61mZfgaxJtnt0Zp5_EEQzBLY_Dmf0on4,31 +onnx/backend/test/data/node/test_convtranspose/model.onnx,sha256=CDTHThq7eKmq4zxFCSKmpFGAv8V8wxb6w9dGOY0p-Tk,158 +onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose/test_data_set_0/output_0.pb,sha256=HneG-T3MmfaylD4KMxnOwosFJxoRtZraGOg0lU_Hsc8,216 +onnx/backend/test/data/node/test_convtranspose_1d/model.onnx,sha256=0BBNTQlSdqJxCX5iAsFBCDgidprv_1JRFEpBj3u_Di8,148 +onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_0.pb,sha256=DugdB8mDd8zLjys9Gz6guoROF5WniAbCMOYxTsRL2yY,25 +onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_1.pb,sha256=vqReEteH3D9QNgAwAcubV7ohKew3T-tgB6LOqwzNZYQ,37 +onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/output_0.pb,sha256=m82EQ2cpDznkgM3kvHq8Zg7BXP7GHlUqqHAeLFknzNA,53 +onnx/backend/test/data/node/test_convtranspose_3d/model.onnx,sha256=RLn0FqHMYwJpDmmvMRwN75HfXW5H6OqY5K21aJNiDKQ,173 +onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_0.pb,sha256=yzJg-6Mo6S_Ii0J_O6ARrRuJRKm2GYYzSfoKJBTl1Tw,258 +onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_1.pb,sha256=bJ7b_MaU60hfPdSePVI_fuAX-u2abWHoX3JjQuEshOw,234 +onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/output_0.pb,sha256=Ko5haeAPyeETXCurwHh_K-3n6hM4JTBkT8074b05hGc,1698 +onnx/backend/test/data/node/test_convtranspose_autopad_same/model.onnx,sha256=qrFgpAHwcIcDD9fIeoAmBxlx94VE1YoUizBdZShRVlA,216 +onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/output_0.pb,sha256=mz9atUy2Vn7Nr6d5zIB8psRUkJh1hDQTt__CSBYXiA4,304 +onnx/backend/test/data/node/test_convtranspose_dilations/model.onnx,sha256=jArWIBpWosKKV7zBNP0AwM4KuouRt4M4oLn5FDiF78Q,188 +onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_0.pb,sha256=bzWXnz5LvVN9kq3fKc3EYBxkwZ6KmN1FMR5y-0duD9E,51 +onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_1.pb,sha256=4MwrDO_hTzR2PV0ke-Q-ESpzROSmpcoPTLu20GNZ2oc,31 +onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/output_0.pb,sha256=SU_6_ceIvxcyEkY5cIaxfpxFOO7o08pElgWQJXtUQao,115 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/model.onnx,sha256=I8QXD3tFjk3p1FCCnIQjCgknxaZOVLkoECrSI-qFmlU,266 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/output_0.pb,sha256=cNpj1cm-VSGhzBRQ9cssIsBnwZsZIiYwXeSfSRj7hM4,656 +onnx/backend/test/data/node/test_convtranspose_output_shape/model.onnx,sha256=7BkUxaL84IIZrqG2MChkLp_TWBjcPpbhlVhYFH3ireE,212 +onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/output_0.pb,sha256=cNpj1cm-VSGhzBRQ9cssIsBnwZsZIiYwXeSfSRj7hM4,656 +onnx/backend/test/data/node/test_convtranspose_pad/model.onnx,sha256=t_OVRUoCr-fcAkOOL7GCwp6v5Jx4XXVDmcrw0vlxFmU,205 +onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/output_0.pb,sha256=cNpj1cm-VSGhzBRQ9cssIsBnwZsZIiYwXeSfSRj7hM4,656 +onnx/backend/test/data/node/test_convtranspose_pads/model.onnx,sha256=O9N7MfV1Cqc-i1y3jrpHzhQ4z4ybm7xhvaYk_3kHaoE,200 +onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_1.pb,sha256=QtNDpr_tblKea9uJw7Ndo2VwZsE_YR0zGs3GxkA2F1M,87 +onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/output_0.pb,sha256=shm1OKRrwwW7T6skwkeDpmN7KA1v3qUgB75cH9Dl8qc,184 +onnx/backend/test/data/node/test_cos/model.onnx,sha256=JqQPABFwNetJ8k3TM1FfhaFBZFKxBM9-dMU185AcfDg,97 +onnx/backend/test/data/node/test_cos/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_cos/test_data_set_0/output_0.pb,sha256=xwExE7n32GQjc8I4MyAWZBOXoLeSnXllZfK9b67amvY,254 +onnx/backend/test/data/node/test_cos_example/model.onnx,sha256=FUqkvGLPtpq9uZdbTqecqfuJY4FWt3uEs_Ta_qIiZ58,89 +onnx/backend/test/data/node/test_cos_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_cos_example/test_data_set_0/output_0.pb,sha256=F4c54AgTxALn0fDkECFlprJnqpteSyq28Lwua7w37OY,21 +onnx/backend/test/data/node/test_cosh/model.onnx,sha256=N1IXHy8bV58Y7jmdMESPpE5GfVdMyKU2_VGN1KEEAJk,99 +onnx/backend/test/data/node/test_cosh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_cosh/test_data_set_0/output_0.pb,sha256=XnUVCOBvze089QqE65mHTGO0qrKRGEJIBPgzrQOJHYs,254 +onnx/backend/test/data/node/test_cosh_example/model.onnx,sha256=vt7YBSVolYtenXFTRSneZJFXVn1BAGRfYBT6h7--R1g,91 +onnx/backend/test/data/node/test_cosh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_cosh_example/test_data_set_0/output_0.pb,sha256=5zBfI_66Bj-xHkKeQjU7ExsAzYQ3svYlk2gScUs37_s,21 +onnx/backend/test/data/node/test_cumsum_1d/model.onnx,sha256=a0-USQspl-Y7FCLaopAcOcXl8YJMSHZdoJVuiabnwxc,112 +onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/output_0.pb,sha256=8u6a-CH_s8CSSeDu2Xkey9IkVrCxfGeK1zruGN-GBZ0,49 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/model.onnx,sha256=8roorRSX_UmgltqXKhlqq700efdCxQvgbtUQp_pXdBk,140 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/output_0.pb,sha256=KxZYZON3hTdtJo13FySOB4-9VcLllUPVPRiYl6J5jKc,49 +onnx/backend/test/data/node/test_cumsum_1d_reverse/model.onnx,sha256=GJVic393uVQwWZIITwyUiXJEdeE31PCfaREaa0V47rs,136 +onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/output_0.pb,sha256=Qx9JC5x68xbCSGlmcVAfxcPWBfRq4XWTKX9vcU4v7lM,49 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/model.onnx,sha256=Hx4GBa3gVcU6OeG4waFSxEAa7r_VvPZDa4C4HLv6Bno,165 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_0.pb,sha256=i6b0KGwNGodlhQS6I1bvaD0TN1xGWnLEfwEfYQp_T7o,49 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/output_0.pb,sha256=WQ4WtDbRG6kYBvqYrMr2Tqz1nyUugHKzXw6_kIKreGU,49 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/model.onnx,sha256=RKckuBZhpqglL2dviFPjshMDeazp7lc4RovX29mqtpw,127 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_1.pb,sha256=c4GeiTmXkiID1JY-ipXQzRl59ZLUi_imaNYP8eLM1d4,14 +onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/output_0.pb,sha256=uIQ9aM_YHV83ShrV9fZREjUB_1AzsmlyFmksuyGpvQo,59 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/model.onnx,sha256=kLauNIYFM7TmL27su7h41eon9EoCo_hIDgFo2prXd3Y,127 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_1.pb,sha256=NMmvV9Gd72jAqm4CVKvPfg5tsoTU35TpnJO8I3QgmOM,14 +onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/output_0.pb,sha256=fjOhNqyyw_q9RM3Q_tHH-zo5LyuiIIPlnwg_ikn-G1o,59 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/model.onnx,sha256=PzI6naK8X5kO2jZohlXfYB8Y8Iu7veFMLxVIGThBJ0Q,134 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_0.pb,sha256=HYbXouTLeBCL2-7g5q5Mc7Fbd-enOZs4KSp57C0c_X4,59 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_1.pb,sha256=VFp0AgVnZO0DGSm4jbAffIBQgezMSIif_MjDWojRRFQ,14 +onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/output_0.pb,sha256=fjOhNqyyw_q9RM3Q_tHH-zo5LyuiIIPlnwg_ikn-G1o,59 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/model.onnx,sha256=mk3rYBKtm10EG-6qGMY8LaQCBQWRUOe5ez7KSuakdQg,310 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_0.pb,sha256=dBjaBXzMfFIovF45VFTSKa1SzvxiDU2cnrAzM3tOY7M,51 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_1.pb,sha256=4Ki_u3n_9JzedrVVClMoOCDVY7aP6BJSo_YgoX_n3EM,31 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_2.pb,sha256=EhURFxsdfyOamsaS1dDwOw3rNpUzQFR_rV_PiCUXGgQ,149 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_3.pb,sha256=bWxbblK-zibXhuqJnlYY76Q-CMwp2JIBxYU-OSpIJlg,13 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_4.pb,sha256=aAzeB402zdR1RgnF4bwrRmCAJqeefsffEwh6adi3hFE,82 +onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/output_0.pb,sha256=QDXvxD5as96MNzcX4VyrYjfyUVh70ERSgZWsbhUYAXc,31 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/model.onnx,sha256=1L6a9siQ63csRt6V8CzYe_5WziCUFIkzsYmv04O6xzA,286 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_0.pb,sha256=mz70lzdE3dV9eCVSeVw1IPD0yxzuvQww2K-IygMsQ8U,87 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_1.pb,sha256=owMofin1vCKYHIHkslh4bPVinD0BZTgNyltN7xiGjjY,47 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_2.pb,sha256=GZrP3XBGQvMlDDHBU10iOG6UcGOI8RsMTWFJPM1XXhc,277 +onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/output_0.pb,sha256=1GKwquiq34PG-gdNzkcEMTVkLLXkM1fDY3jlkYLS1do,31 +onnx/backend/test/data/node/test_depthtospace_crd_mode_example/model.onnx,sha256=NKPEJg_MCvJ1JpqkMeaVOv8i6mDopHCUnypY29SNBJc,175 +onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/input_0.pb,sha256=RgEVxMZP6lyZL5iCrvplZ59lKVjVOqOK6HbeXaJvtBg,208 +onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/output_0.pb,sha256=jcnCB1p-6U2LnnzjM5JZTSv-wLkadP8R8T7xDtBZf2M,208 +onnx/backend/test/data/node/test_depthtospace_example/model.onnx,sha256=aMvte-8S8rfH8edeajpPdRSDpxRnhjv9Pvf_KOwbFdk,166 +onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/input_0.pb,sha256=RgEVxMZP6lyZL5iCrvplZ59lKVjVOqOK6HbeXaJvtBg,208 +onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/output_0.pb,sha256=XZsnoNSiBEpeUw5duLl02ij6y-CLa75VFwa6fK9CW-U,208 +onnx/backend/test/data/node/test_dequantizelinear/model.onnx,sha256=w1XuFaL8H4BpUflB4HjVHdqoqRgN3xCZZCkhIr2wtWU,174 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_0.pb,sha256=EmysV2w6e9A4gkikFxjf-h5DEDE-xLzeoN7oYeCQE04,13 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_2.pb,sha256=lFnABk3b12PAd-w6LAhH1aQBJ4jE7GVjHeT6rBlLPHQ,19 +onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/output_0.pb,sha256=PY_Zk5COHTEuddMpyFjKHFk5E6u4xQQEXMiAU2kHfd8,25 +onnx/backend/test/data/node/test_dequantizelinear_axis/model.onnx,sha256=g0xhe-2dn1lhgq9p-4o1s1TZQT68pvVCguum1IkKRro,211 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_0.pb,sha256=F1clPA2jDiRJvIkJOrVW4-uWrMCe3ci36ERppwWeFr0,33 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_1.pb,sha256=8153V3qlOWYhYmsbcUqVSI4UZKUMFAC9iONtVWruuDI,27 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_2.pb,sha256=AX9gtY0YGg4meweG0-gBYu8fbZQMaFj-4ePD0AVE23U,23 +onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/output_0.pb,sha256=clTyPPD3CizDRWpK3EKw1PsOobgue1JHzKmFMlVf8XA,87 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/model.onnx,sha256=gdA3aYCQP-L6lByosNFvJUDeVGI3iIwHcP_XREUshaY,142 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_0.pb,sha256=QFTzUoQFlNgLmZpL25m5sGrk5-Cb1LVl-OIGCAaPa-4,14 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/output_0.pb,sha256=DC1EVhkVxI1z4u7QbOnMC632StZu-TOmTs25spcjCok,29 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/model.onnx,sha256=cJ8KdZN74PU-kzuHoAIM8WLymzBkOmcUEGvreZycEvw,140 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_0.pb,sha256=TQ_7QEg8laasmWBKCvvRHbI1Hpzz7yTnJNBjvAsTBSk,14 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_1.pb,sha256=qN7egCoW3Tix8QKnMxT243blKL-WqkjKisULKpcdBdY,17 +onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/output_0.pb,sha256=5bh0wpoKBkT1RWKlOVbyvBfq3-KlG8Sx5zylKTRETrA,29 +onnx/backend/test/data/node/test_det_2d/model.onnx,sha256=OW5mSOi7fO6hao91GdGbPZF9JKegWWmf7ZkgSHmS4vM,84 +onnx/backend/test/data/node/test_det_2d/test_data_set_0/input_0.pb,sha256=0phUVbSY99aYNDvbb4I7ZwTF4_oqB7I9Teh_3LZTlfk,27 +onnx/backend/test/data/node/test_det_2d/test_data_set_0/output_0.pb,sha256=b25eApoGtGI7BEKuAIjKZCC5IY5G7F_xvMlh9QxE7Og,11 +onnx/backend/test/data/node/test_det_nd/model.onnx,sha256=3IqPBQkthO88FwEuPKYbVpNE9Q_fDbVtXLkI03BFrIg,92 +onnx/backend/test/data/node/test_det_nd/test_data_set_0/input_0.pb,sha256=8YluWZgsAsrlB4CYnJbRuf7gscfo9QKQNTqVdfYttvE,61 +onnx/backend/test/data/node/test_det_nd/test_data_set_0/output_0.pb,sha256=4i7Hs35s1K_MXnQ7ljAM-dfHG1YeQVsSls_jDMSmxWM,21 +onnx/backend/test/data/node/test_dft/model.onnx,sha256=cFQCJipKRlRPNX8ebwVAIceqrzPz1rf5gfppu9qvNOg,118 +onnx/backend/test/data/node/test_dft/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft/test_data_set_0/output_0.pb,sha256=FIC9_IUQkvqOO3xkJXw7X5pYOXf6MV_hYPccpDfuUtA,816 +onnx/backend/test/data/node/test_dft_axis/model.onnx,sha256=afEnjixihraJK2TzsEzhnTSW_e7uyUqYhBhtEp2_fbE,123 +onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_0.pb,sha256=BIHO98lzVkUyYknuhq6si9MRulBqSgXJNCwPwn7ZzUA,416 +onnx/backend/test/data/node/test_dft_axis/test_data_set_0/output_0.pb,sha256=HDPqr6hb2bvmQljkRaFU670JrBKdKHGBQDQHONjjr8Y,816 +onnx/backend/test/data/node/test_dft_inverse/model.onnx,sha256=aSrOepvhSx3lAY5cSvbFM09xvB-zZXhfSBPqlwQK7Xw,142 +onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_0.pb,sha256=7PtwIwLGEO0OFI_rXNZqOmtnlBQExbdZcxeeOFm4aug,816 +onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/output_0.pb,sha256=tKtsuSQuh-ZK-2V8d9lDhjcIq6KtEVGaJmoGT_TXxQc,816 +onnx/backend/test/data/node/test_div/model.onnx,sha256=BC7Wj-nywr5jTxV_jbCcDkgEkPD_yoQ7KQRk5zTinKs,125 +onnx/backend/test/data/node/test_div/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_div/test_data_set_0/input_1.pb,sha256=EdnSdDX16HmReb_YAemagUKjdzJfVyWKaqThtG0XUdo,254 +onnx/backend/test/data/node/test_div/test_data_set_0/output_0.pb,sha256=oDeGZ2kWqr-qxEt70OvpI9yKHxxk-U0_Fd5toUxgNO0,254 +onnx/backend/test/data/node/test_div_bcast/model.onnx,sha256=m0B1sh2gk5LB6GaJ3ncV0reTkUkWdxBk3TafRd8MPW8,123 +onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_1.pb,sha256=MqH-1RsmHArvXfx7K35Qp2E8yr83igIRnQTj67suDHA,29 +onnx/backend/test/data/node/test_div_bcast/test_data_set_0/output_0.pb,sha256=2yycZqpnMyKEloUowJhkwXjK-IE9yPRd1T7TWPBxvvk,254 +onnx/backend/test/data/node/test_div_example/model.onnx,sha256=-V4U6W3JAnNtGcoXj-90cNrefeLcd1WzODbJxSLNCLo,109 +onnx/backend/test/data/node/test_div_example/test_data_set_0/input_0.pb,sha256=5m2PEEsKXQbJNrLR6JC_nvLRZCEVZ89U3jSEZ7Zcn2g,17 +onnx/backend/test/data/node/test_div_example/test_data_set_0/input_1.pb,sha256=UpYzYhBYwWnWsKo320h6NtTBuKOsfvvObUYElou6U1Y,17 +onnx/backend/test/data/node/test_div_example/test_data_set_0/output_0.pb,sha256=F-A7vcHWnvj2qwZVhcZLvB4sACk6jmYJEidt7RNhvcE,17 +onnx/backend/test/data/node/test_div_uint8/model.onnx,sha256=73xGoanAmgvFoxnmeY70cMDJMj_tiw_G2UXfL1xHP3Q,131 +onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_0.pb,sha256=o1qOEpD4OnCp_Ziad-Zczbkof8qMJSVo_uGta8KkmYg,73 +onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_1.pb,sha256=00CeSgyLXpakzaeaUlt-h0hU3j3N0Lc1Vt0LPjvqa1Q,73 +onnx/backend/test/data/node/test_div_uint8/test_data_set_0/output_0.pb,sha256=Bh8cQ09M3qXcpCqGWHhkvbw0L_aYN2JcPN1UVDo-ZV4,73 +onnx/backend/test/data/node/test_dropout_default/model.onnx,sha256=c512IB8jo0CP0zbx_CJu7shhixogAi6OttlsCDO_KpM,126 +onnx/backend/test/data/node/test_dropout_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_default_mask/model.onnx,sha256=EtzWiXHC7M1GwwL0errd19mG5mSaIxdkob5OzzBWYyc,160 +onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_1.pb,sha256=4sWzAHgaDiZSCGEr949BKLl9dNfAyqyQpzL1ccqJJ2M,73 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/model.onnx,sha256=xPZNDfgDNzJeTxiVHxuHQiVl1QbxqswOY3APQZxkALY,182 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_1.pb,sha256=9FZuwRdGL9lHbnD4w8PpG6fdJjuBpsU9Ei8UsUTXsgA,11 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_1.pb,sha256=4sWzAHgaDiZSCGEr949BKLl9dNfAyqyQpzL1ccqJJ2M,73 +onnx/backend/test/data/node/test_dropout_default_old/model.onnx,sha256=ukHf_-XR4gMOPC5xA7oRg6a5E0bdXsrkl7H6oScsLBE,101 +onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/output_0.pb,sha256=lezr2GRMo0JWUSPIQ-nlrz1YNhYT_XpoHnO0oq6y-ic,21 +onnx/backend/test/data/node/test_dropout_default_ratio/model.onnx,sha256=LFW31ngqrdSkn0eoF1qWXpkVVWwaJZID64p_UFiciKE,148 +onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_1.pb,sha256=9FZuwRdGL9lHbnD4w8PpG6fdJjuBpsU9Ei8UsUTXsgA,11 +onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dropout_random_old/model.onnx,sha256=indJUl0_xdJkjHL8itDQnja4iDBaut3bkRryOv65Ajs,133 +onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_dynamicquantizelinear/model.onnx,sha256=I5Nk7KgdM4PiZcv5toOWiQZNASMP7H1-BVip_TM4zVM,184 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/input_0.pb,sha256=GzpMBt69V1vDS1x0m43plOXtiv0KATlGTtFlf6wKT58,33 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_0.pb,sha256=ry3_qJJ8NX3XhMicOdeNEia49jnRgxG2mYxsRuCNIqA,15 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_1.pb,sha256=_qXCs5BSE3SUvlSSmCKQs09zGQDHtxBxiiZA6tT1pds,17 +onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_2.pb,sha256=AlfPMoClolzBruTVYhCw3YMjy4RinXVFQpOJ4568epw,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/model.onnx,sha256=y0RptQ5zEM33enw0M1lqkW8WMzTf1M1OU5CXFRV_shc,3145 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/input_0.pb,sha256=GzpMBt69V1vDS1x0m43plOXtiv0KATlGTtFlf6wKT58,33 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_0.pb,sha256=ry3_qJJ8NX3XhMicOdeNEia49jnRgxG2mYxsRuCNIqA,15 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_1.pb,sha256=_qXCs5BSE3SUvlSSmCKQs09zGQDHtxBxiiZA6tT1pds,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_2.pb,sha256=AlfPMoClolzBruTVYhCw3YMjy4RinXVFQpOJ4568epw,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/model.onnx,sha256=sQDOYQy4OZq0Hh-EeM0hb5nEsMZaNAGnOzeDniTnIJY,197 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/input_0.pb,sha256=5Sw2guhx2Fx5oLhz2en7hvFuDC4Ch7l4rDCamVC0X94,33 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_0.pb,sha256=o7JvKwH0WX9r2TNocBXFjxns3RpyEmLMEPxlzT225VM,15 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_2.pb,sha256=Ew0CDXUBMf1O1PCpkeQ-lLgahqVnxe0ydyS5jeyNuCk,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/model.onnx,sha256=TehN-V9Yqegtvra-N4OTEq_TJ5LfgjOpihSxyogHuI8,3600 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/input_0.pb,sha256=5Sw2guhx2Fx5oLhz2en7hvFuDC4Ch7l4rDCamVC0X94,33 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_0.pb,sha256=o7JvKwH0WX9r2TNocBXFjxns3RpyEmLMEPxlzT225VM,15 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_2.pb,sha256=Ew0CDXUBMf1O1PCpkeQ-lLgahqVnxe0ydyS5jeyNuCk,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/model.onnx,sha256=my7WaurE-jr43TsIE5cuj87Sy7n28aDqgboGieSu0Rg,205 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/input_0.pb,sha256=8wCIWAmNy9W1cv2n1Cqyir5HR5RnEIoXCiO3nqkK_kU,59 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_0.pb,sha256=iwSG6hTgbf_TtcdovQLDsNtTlht754rvSfq5hg2SP-g,23 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_2.pb,sha256=L2h2DxO9c7IdJJkT8HsuYfIREZMgRoyy1cA8eeD-F6g,19 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/model.onnx,sha256=TVtsc5K3LrPgDkW648mwTQ7Oq73tVvfGy7INcf3gg0k,3608 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/input_0.pb,sha256=8wCIWAmNy9W1cv2n1Cqyir5HR5RnEIoXCiO3nqkK_kU,59 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_0.pb,sha256=iwSG6hTgbf_TtcdovQLDsNtTlht754rvSfq5hg2SP-g,23 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_1.pb,sha256=pVez9xxtD7ltZc4oLTF3NrV30IFL9ogVC7eseamvAco,17 +onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_2.pb,sha256=L2h2DxO9c7IdJJkT8HsuYfIREZMgRoyy1cA8eeD-F6g,19 +onnx/backend/test/data/node/test_edge_pad/model.onnx,sha256=NZL9V009im_IQTUbWnJMZrkR4oCr01GSmNB2rruwPFs,154 +onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_0.pb,sha256=cOtF8vlVdG7QMT-RPMc2QVp7RFd7GBwL0kJdZpJtZMc,256 +onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_1.pb,sha256=8s4uRhNf19t1kZ-BWDxuitcnY9MeHgkG6w6i1Sghnz0,76 +onnx/backend/test/data/node/test_edge_pad/test_data_set_0/output_0.pb,sha256=Qv3dfFBzQiAv5a2UJMcD3Imge8rs9Lhddyi-ZA2vxXw,520 +onnx/backend/test/data/node/test_einsum_batch_diagonal/model.onnx,sha256=4zTeWtGLnr0OVE8J7llox-D3bgsWZlqPWZAYOTzVPSU,143 +onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/input_0.pb,sha256=sHXqijBwpgvbMjoAuwT6ee_BgNE5XxZNjbh9ezoAJ5A,614 +onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/output_0.pb,sha256=bW-C_Ix72YDKjjTC486yi59ehsLSuK6zTphLx60y15w,131 +onnx/backend/test/data/node/test_einsum_batch_matmul/model.onnx,sha256=JLgXzilgY10tl-yILQhGZI2n83SmH9sjBZYamf6_FOE,177 +onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_0.pb,sha256=XA6uNuRQNZT9t697igygft7fS_BrWdyvbkDTJ1ycv9o,254 +onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_1.pb,sha256=Rb-T5LOsdM55duFCcf7_kuymX-A1Fh1JItpbSdYdohQ,494 +onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/output_0.pb,sha256=btxQVcOiJhZxHjzD9JlDtX7mMumNmOmQNf4XQwP_AnA,334 +onnx/backend/test/data/node/test_einsum_inner_prod/model.onnx,sha256=m0BWV7SrmniOu6XKl0_czSFiH5asoxj7aJtes0U6YPM,134 +onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_0.pb,sha256=6ALN9kajvwedycdrXcEwbCbOklCh2-IRC2ow--sBu6w,49 +onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_1.pb,sha256=3zewJx5xB7-0SZf2259wx2ILafmvfob_BJq1cOs2fdM,49 +onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/output_0.pb,sha256=MUB8WvKbPcte5zUbCNfBkkxdgJyMr-1_W3OnGT4dL9s,15 +onnx/backend/test/data/node/test_einsum_sum/model.onnx,sha256=QWE5X5J5jTX5g5X9_cNfJ_Wx54sighP2-RzVLmvIA9s,117 +onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/input_0.pb,sha256=kaRz7Spymj6w1xeS_WNmXkA4FBwzOeDwZxGKrDqtMUM,107 +onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/output_0.pb,sha256=mmH-SDsmj8Pcm24YqzLTL4nZ6CPuL6qZdB7UBTKmDTM,33 +onnx/backend/test/data/node/test_einsum_transpose/model.onnx,sha256=HmVAMMWlGNC3EwszWdTE3kVxq1mZYxlpAbLe5VJkpFM,128 +onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/input_0.pb,sha256=kaRz7Spymj6w1xeS_WNmXkA4FBwzOeDwZxGKrDqtMUM,107 +onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/output_0.pb,sha256=D8CgoMhtm2b7opWaiN6AUgqbOtpSxhagaUexmJr0-pE,107 +onnx/backend/test/data/node/test_elu/model.onnx,sha256=0XbXdjHnYZN-wl-d6J6EdWFr8JT4-EsTazhUfnmtLg0,114 +onnx/backend/test/data/node/test_elu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu/test_data_set_0/output_0.pb,sha256=1qikqd90KnVBAo1LXaZuZ_plZqqyNCGPaXg7nndxHaQ,254 +onnx/backend/test/data/node/test_elu_default/model.onnx,sha256=XQTxlJDS6hzf-zznRbwP_zUULWOBUkogcPbheH7JmRs,105 +onnx/backend/test/data/node/test_elu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu_default/test_data_set_0/output_0.pb,sha256=R10e2MFkJdT7LXU0o6fWwpUeMNIrnT9xSP45r1r6KIU,254 +onnx/backend/test/data/node/test_elu_default_expanded_ver18/model.onnx,sha256=cLYK-eJjTul0ne919XzExJWx4eqzVZOo1v1F5QMblas,1317 +onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=R10e2MFkJdT7LXU0o6fWwpUeMNIrnT9xSP45r1r6KIU,254 +onnx/backend/test/data/node/test_elu_example/model.onnx,sha256=KrYe-L_vMuNzyLPvF4t-jDUWQVoVIEHOVdtOiBvsxqA,106 +onnx/backend/test/data/node/test_elu_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_elu_example/test_data_set_0/output_0.pb,sha256=BagtTGVCh4Fl4wKScganoM7CS_gWaMK6AlPDEDAksnw,21 +onnx/backend/test/data/node/test_elu_example_expanded_ver18/model.onnx,sha256=KR8nIfX48GdYT6AZkavN6z305oe7Hw7gcK04dShq2g0,1301 +onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=BagtTGVCh4Fl4wKScganoM7CS_gWaMK6AlPDEDAksnw,21 +onnx/backend/test/data/node/test_elu_expanded_ver18/model.onnx,sha256=2JjMB9lsE_l7VxXofbpqL9pqcTcKwubvEzDzODSxt78,1147 +onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/output_0.pb,sha256=1qikqd90KnVBAo1LXaZuZ_plZqqyNCGPaXg7nndxHaQ,254 +onnx/backend/test/data/node/test_equal/model.onnx,sha256=lwmcVb5UafztmJnMu-R95GH3ckvfjLXyLtiN8MxniVc,129 +onnx/backend/test/data/node/test_equal/test_data_set_0/input_0.pb,sha256=MKLPWH4JsioIIdvp1FcMaVkAvmJInLU3evdsDMTfU_k,254 +onnx/backend/test/data/node/test_equal/test_data_set_0/input_1.pb,sha256=4NP29YAJAKfKqC62zG5fj4kjHkgVtZNubPKm6-TtGiM,254 +onnx/backend/test/data/node/test_equal/test_data_set_0/output_0.pb,sha256=ttqpyVFrpeKQuRmyvcAQBtR70YTBB24AYZ3ObZ-r4hQ,73 +onnx/backend/test/data/node/test_equal_bcast/model.onnx,sha256=bFxea4JWRlSryQN79E6QcVCanmIKm_3FvCiUpvY2Zac,127 +onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_0.pb,sha256=MKLPWH4JsioIIdvp1FcMaVkAvmJInLU3evdsDMTfU_k,254 +onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_1.pb,sha256=PSjreW5uEBtMh7ZA7HYMm-dNGY8_FOGUWvaQf6vqo1I,29 +onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/output_0.pb,sha256=FDjiiT-UI1Vmyv7YZPwrXo1-PrlbunLjj4OJ41_aAjs,73 +onnx/backend/test/data/node/test_equal_string/model.onnx,sha256=0FKXgIuUUzbp_zfW68dk4nfjNABehY7u60xHCnjROZc,112 +onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_0.pb,sha256=JL7-CwtjtjFEHwmsDSxw-GA7U5qY0iV3bQVs_6zFmTw,25 +onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_1.pb,sha256=MuifKJHibr3zcpvSLMjcRVz4751u9shjGf9us1VbCI4,25 +onnx/backend/test/data/node/test_equal_string/test_data_set_0/output_0.pb,sha256=vuGdPlSHGdS-OGbB7phc5TqRuC3BQcpJCN7BrvD7pMA,11 +onnx/backend/test/data/node/test_equal_string_broadcast/model.onnx,sha256=_48qehgyKwmUXNKC97eMVRBYwZg5KSt-o_jE3K1KW2A,122 +onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_0.pb,sha256=JL7-CwtjtjFEHwmsDSxw-GA7U5qY0iV3bQVs_6zFmTw,25 +onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_1.pb,sha256=isHWUq2j_Iwbwc2dyAmnF813WI3zs4sENKnIvov_e50,16 +onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/output_0.pb,sha256=vuGdPlSHGdS-OGbB7phc5TqRuC3BQcpJCN7BrvD7pMA,11 +onnx/backend/test/data/node/test_erf/model.onnx,sha256=gZmISY2s3vLkp-p3hGrtYQ7g7x1ZyxPp7qBCk_BtuLo,105 +onnx/backend/test/data/node/test_erf/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_erf/test_data_set_0/output_0.pb,sha256=9sqo5UrZ7X_DtEbtytD-4yhCG-fxZN8AtpfVZnDq7IM,12304 +onnx/backend/test/data/node/test_exp/model.onnx,sha256=g1MTYxYg4MkE_ehqbgO_MDDr5izLU4lyhd2-C_dRejo,97 +onnx/backend/test/data/node/test_exp/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_exp/test_data_set_0/output_0.pb,sha256=jP7r-z7yLediEhV36ovwLP0z0r1PtySuyJ7u9FQI_jo,254 +onnx/backend/test/data/node/test_exp_example/model.onnx,sha256=I6CSuYgNQyGhCW3VGbAoB0xv_oKXZSCeFahI_t_zAuk,89 +onnx/backend/test/data/node/test_exp_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_exp_example/test_data_set_0/output_0.pb,sha256=8Z6Sn41Qmu-5DSO90Vhz6iYIY8302yNCBwlDvnxlW9c,21 +onnx/backend/test/data/node/test_expand_dim_changed/model.onnx,sha256=c4_vEqKUcEBPs4Vd9l-OA6h5GN5_rTBFnc6zkcOFe_s,168 +onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_0.pb,sha256=AoPnKt-H_dcTIDGK9TessImdkEH3HfmiW-77-3ZZIqY,26 +onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_1.pb,sha256=nz_Os8au3_CRXPk6uOHXGma3TwkLsQ0R0ZWJdZl2wYU,41 +onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/output_0.pb,sha256=Xeuh-wyUv3E_ihC7s1rogDDZI7IiZZX2Rvq8DW5LwiA,165 +onnx/backend/test/data/node/test_expand_dim_unchanged/model.onnx,sha256=_P8uTx5R3WMbSbUV8du2SdE6XirZGS41H0jzpGc8Syo,166 +onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_0.pb,sha256=AoPnKt-H_dcTIDGK9TessImdkEH3HfmiW-77-3ZZIqY,26 +onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_1.pb,sha256=DvZj0CscD2fjY1rTp_dvS7OobwuGgeXFLEfUroZjXRk,33 +onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/output_0.pb,sha256=W0FAvWPJ1K2wCIJxDV-G4Ejv6MMLgP8xZGwN_KKOEXI,66 +onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/model.onnx,sha256=2nzLdB3VP7s2WzF3PkJvvTnngfXsk9wzN48W6JK_GuY,148 +onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/input_0.pb,sha256=Tx9m2RIZI9vFt7CE3QTvOTK4cLjEh5MACeSTP1egDeA,91 +onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/output_0.pb,sha256=gXtL9SCTNQYHwx7EeNmFhxq1VmtV-WtGGJq-Jk7W4n8,91 +onnx/backend/test/data/node/test_eyelike_with_dtype/model.onnx,sha256=VZP49xyDolwSdm-hp57IdUsRsq684Z6cLo7cDoXGrbQ,122 +onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/input_0.pb,sha256=l4NjktRUQoCUFQXwkl4ZkuFX0uN_a4U3otSqPmmAL_E,59 +onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/output_0.pb,sha256=0QxDxZ7AFNB3zkhhpmKoveOZZG-yj8CEbcbprLAxmL0,107 +onnx/backend/test/data/node/test_eyelike_without_dtype/model.onnx,sha256=uwNzuWn2cEP1YL8V5T_7VUMFMZCxPnJdZTw69QXSUpQ,111 +onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/input_0.pb,sha256=1UjqCqHuod0Uy98DDsmwuxJylfDmD1WC6n1cuIaueAg,75 +onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/output_0.pb,sha256=41IuN8qkdjiw-rvD37Xoci-okMoFlzst_lOEmxMN22k,75 +onnx/backend/test/data/node/test_flatten_axis0/model.onnx,sha256=fHXm0eCrey5DPAX0CXClZn1oxRDS7uW20z53Cihhhxo,124 +onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/output_0.pb,sha256=rK76rD-Gd7pN7MFiCa4gnGDsCIaupauMseig-khoG4A,492 +onnx/backend/test/data/node/test_flatten_axis1/model.onnx,sha256=E-7WWXTsyiAAjBfRNV8ZkBTztxQjx7mSBwSJkDrVwWI,124 +onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/output_0.pb,sha256=gp4cg8vDGCIxsjAVH_C6zXUfFdU8e5Zt2rFrNtLE4qM,492 +onnx/backend/test/data/node/test_flatten_axis2/model.onnx,sha256=wKsPeyYmLfHI0B6Z_b7z56d2fQpFXlCtRHRJIfia8I0,124 +onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/output_0.pb,sha256=WxLYJ0ShJO5yi1cemMDvetHIRHssm7QET5WHVyhCz4w,492 +onnx/backend/test/data/node/test_flatten_axis3/model.onnx,sha256=vwq_Xmb9v5_C8jGkcnfdzGyF3j8Xe8Lf0mevrseI17w,124 +onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/output_0.pb,sha256=yPyzGHWmluHXMDP7BvL5BElzL7KCgMtwEH3tLKTwJoE,492 +onnx/backend/test/data/node/test_flatten_default_axis/model.onnx,sha256=fBO_3c7JSIsaVb115WP3z9rvQROpqsMFTSpSyReGauY,118 +onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/input_0.pb,sha256=hLRdvgAmmF6-VWT36JhFYz7XSQ8QBpZyobohXpWIaSE,496 +onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/output_0.pb,sha256=6rx1onyZ2U_4kN9SI-xNMUkluod27NrzqMkvO1TH9-Q,492 +onnx/backend/test/data/node/test_flatten_negative_axis1/model.onnx,sha256=5UYhabRawwqpSp1Bl_CqG-eb72ytFSQ5Yu5qZRu6h9k,142 +onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/output_0.pb,sha256=yPyzGHWmluHXMDP7BvL5BElzL7KCgMtwEH3tLKTwJoE,492 +onnx/backend/test/data/node/test_flatten_negative_axis2/model.onnx,sha256=WymVWn5oq0oSE50aZNL6TE9QcQTlXRdVmz4Y9DCaB9E,142 +onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/output_0.pb,sha256=WxLYJ0ShJO5yi1cemMDvetHIRHssm7QET5WHVyhCz4w,492 +onnx/backend/test/data/node/test_flatten_negative_axis3/model.onnx,sha256=CxOxFZ9y8Uu832jurmchPlVgyirD1P35BsPnr9Wb-wY,142 +onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/output_0.pb,sha256=gp4cg8vDGCIxsjAVH_C6zXUfFdU8e5Zt2rFrNtLE4qM,492 +onnx/backend/test/data/node/test_flatten_negative_axis4/model.onnx,sha256=hdnTEVnk5-_jEF8QUCNJEe9pEXvN7wFeoXL4gRFoA1A,142 +onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/input_0.pb,sha256=Tmfo0GyWZmCyZgxTurluTU7UqCKaAMO269Nmvnlc5Z8,496 +onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/output_0.pb,sha256=rK76rD-Gd7pN7MFiCa4gnGDsCIaupauMseig-khoG4A,492 +onnx/backend/test/data/node/test_floor/model.onnx,sha256=ys4pd-oBAvmFqHS_YNndTptJf8jJUJ25303yszFXYz0,101 +onnx/backend/test/data/node/test_floor/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_floor/test_data_set_0/output_0.pb,sha256=SLn5L75ClP1fBiBE6ZDE4VZzTrXCiWcTMy7QXKa-Ikw,254 +onnx/backend/test/data/node/test_floor_example/model.onnx,sha256=VdIVjxbhQSgQ3qGk0N-ADc6pxiVzMX5yIrBQgg2bFy8,93 +onnx/backend/test/data/node/test_floor_example/test_data_set_0/input_0.pb,sha256=ILNT9pLgfeiHDm9wzsrp3xhT2j2j7e4JJZnFxDDExm4,21 +onnx/backend/test/data/node/test_floor_example/test_data_set_0/output_0.pb,sha256=R2jpEs28Fpb5O1rged2oKCrC6rKz2V4AZANFkIZWhvo,21 +onnx/backend/test/data/node/test_gather_0/model.onnx,sha256=BVuBNnaBUTjWY0CQmPobcWUlvKhO90GmSJ0_Q-K6qos,165 +onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_0.pb,sha256=v9ro1rIfI6GdfDAOlfzMtvUqIdKvWlTBkhnXf794Nm8,499 +onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_1.pb,sha256=0Ccyp4GZ5Le6DSa9l6Ll54TxclZLEJcFSzyZNmAGtOM,39 +onnx/backend/test/data/node/test_gather_0/test_data_set_0/output_0.pb,sha256=09KeAIrn_T0fae6_KPa4XtXP6OS1dQUtxXObxyVKA3o,304 +onnx/backend/test/data/node/test_gather_1/model.onnx,sha256=-einNP84SiRXQdfqLWV_ptKuGZOfDZhxRR6PkxoA2Sg,165 +onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_0.pb,sha256=v9ro1rIfI6GdfDAOlfzMtvUqIdKvWlTBkhnXf794Nm8,499 +onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_1.pb,sha256=0Ccyp4GZ5Le6DSa9l6Ll54TxclZLEJcFSzyZNmAGtOM,39 +onnx/backend/test/data/node/test_gather_1/test_data_set_0/output_0.pb,sha256=ieyU1qyiHYO1t5Ab7_nxdVGd_OaMgc3YbKzYuqajEPg,376 +onnx/backend/test/data/node/test_gather_2d_indices/model.onnx,sha256=DPra5GUI_sv0fTGRUntpMSCozKIDCyJJgGnsrORMvcM,166 +onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_0.pb,sha256=SOaFrsa79PCS2ugXp1X-Zq0oKZzsDF1ZhhCp-IilMbI,50 +onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_1.pb,sha256=bXdhgzbcEgKzjvDLVobDKoZnWAbC9zGJZFC0lj7Y_o8,33 +onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/output_0.pb,sha256=w7ycEGtr1LhcasCY6CV0lbteDV95mdJMiOSF6kAeL68,37 +onnx/backend/test/data/node/test_gather_elements_0/model.onnx,sha256=-UKGxaVDmtpIiOxLp3hdBW50jufIf6WzYL2x9CXsna0,170 +onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_0.pb,sha256=wRC2L4HlxZ6ZgrkzAQSaPSyf6PJwdYTMGNVxHYmTBOE,30 +onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_1.pb,sha256=wSm3mqUOOxYumS8IIOegQAGpVj-DJa5dmRvLafVm1go,49 +onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/output_0.pb,sha256=F1BDlx55q8vtfYsgvENwpn1xht12Z7Dsw5tL1fkhntI,27 +onnx/backend/test/data/node/test_gather_elements_1/model.onnx,sha256=qhtzp0PVLrQhxI8DObE-nI7P7zDA8JgKTo8pliOpxW8,170 +onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_0.pb,sha256=Wm59aOyyoZOZv5YocFWSzXPg25a-rdTtaDgEYaWC5kc,50 +onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_1.pb,sha256=5pgWxgEKVysUsnq2IsW-NVvjJquNbcZKBWa1yFTP0VQ,65 +onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/output_0.pb,sha256=h_nydv1J1lfEmGnseH4P5IDLSjCcUDxV0wK-aQfoPKY,35 +onnx/backend/test/data/node/test_gather_elements_negative_indices/model.onnx,sha256=eFwUhoyzlAwCXYUqo2uMg9At6nY630sSPZYiO6xYER0,185 +onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_0.pb,sha256=Wm59aOyyoZOZv5YocFWSzXPg25a-rdTtaDgEYaWC5kc,50 +onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_1.pb,sha256=0VU9o2--B-qtP4gN3jZZoUPLGH2P_3RcU3JEkOZ9xEo,65 +onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/output_0.pb,sha256=fibWdZ4Mvy73m47uPMZAAKLshVsu3yP3zerYkK7Tqbw,35 +onnx/backend/test/data/node/test_gather_negative_indices/model.onnx,sha256=LsHLhrGMuLkwmRgyZ2IQDIFSPV3498o2_GBtp54cnQk,156 +onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_0.pb,sha256=GXKNcQ-uaECnpF8lviHCWJqTZop-OiUYjf15GjWXEdM,52 +onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_1.pb,sha256=5A7wfS6LnXClLPQu_ACgve0ttcPbYZSfwUcXrHRn7f8,39 +onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/output_0.pb,sha256=A5dULKLVuSszRV-Lr4tSbcCXE8SmBGXGEt2PBEUnrC0,21 +onnx/backend/test/data/node/test_gathernd_example_float32/model.onnx,sha256=qXeqzRaQl1k20yQxj66_8OMPrjB8hhbVLTAIP6Mhwrw,180 +onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_0.pb,sha256=5cz0WLnzXzK7tNORYLLJt7M4cEl5voO6weP87g10uzY,48 +onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_1.pb,sha256=jbBMayVnL94pY1Yt8CqgATmUpNvs4tIWsExStJnd_mU,51 +onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/output_0.pb,sha256=mji8xWMFyFYSHhjyJ7DCrYk0VKFyB-A-UXkQ4i_FRsY,34 +onnx/backend/test/data/node/test_gathernd_example_int32/model.onnx,sha256=BNQJZvLmpsNQWy9awDjRUyKJUFvbW6KFlHgtnp31l4c,162 +onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_0.pb,sha256=9zPZQrD5dWr-AFtjXJKRMv3rliBFCWE67e5HYlFgI8Q,30 +onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_1.pb,sha256=IgYXoL1hPZ5AWWRDlAg52hQcugR9rQ315g3gS5h2SKU,49 +onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/output_0.pb,sha256=wBiSs17OlKdFQgS0dKfm8s3KikSCYY3DCqHVJLqTax0,22 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/model.onnx,sha256=6VH-THSJwzI7Z3ZzLqkZIu8raqAyYJ5cYsBtZOTrDSM,200 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_0.pb,sha256=_Ufgo65torZP3BJXMuNV_I5bjGxlFeNnmYbzBQDtGgk,48 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_1.pb,sha256=PYURLeB1BEiLLcnnTviJ8DKU5TaUbxAMmuEs-y9aEPc,33 +onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/output_0.pb,sha256=SevtZOQwcp9sevBCWvvSXtPStmtLO1deGNkftiCcUK4,32 +onnx/backend/test/data/node/test_gemm_all_attributes/model.onnx,sha256=HTR5DpeE8XQRryF_KzHEKihBvN_IRKm7yHy0WKvGjBI,218 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_0.pb,sha256=RXR_ByfkxKZMoWCAHpiivbcuBwFAKhfBUVkyCln3T0o,59 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_1.pb,sha256=aVoY8BMzhNSlp1xP2b-jQ6REpi2Dtc1qnEAPQSMYGKY,91 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_2.pb,sha256=8gbLQicg2cZTYZpzj5BI-b4-9XtcCgaLXiQM1a6sZo0,31 +onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/output_0.pb,sha256=M8ow4VnzrBXwrvTAwznwIas4zwLusLNUS7u7MWkQsYY,71 +onnx/backend/test/data/node/test_gemm_alpha/model.onnx,sha256=SzQN_zHM5FNWh8GdU0P7nGh5JurL_z5yCQ1xbB8EfmM,163 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_0.pb,sha256=MILDtCDczrrmVCYbqkuMR6oYZmKaoVlWgARdLbzo9B4,71 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_1.pb,sha256=1xWZAGPREKiwEVDAShgn4ytsgBqHdZiahRzc34kWXIo,91 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/output_0.pb,sha256=0QrvhY8NjgaHuyrMkfNjHiN8EGUrrI2ik9s8pmKXLVM,59 +onnx/backend/test/data/node/test_gemm_beta/model.onnx,sha256=lbbrtTgcdg49mL9b9JhVQLbSNXp7HnHHN4P0XoFkuto,161 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_0.pb,sha256=r5WMCnSToJqMbEYSeANqSG5Nbsp3PtGfofCSBKWZxEw,67 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_1.pb,sha256=JeOCNEjJirYi_V4m0bfCyIwat86xDBD3ZA9OL6u1lPM,123 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_2.pb,sha256=IB3Jspke-7-5qQWMVzj62hbsVQ_lbvNUYjXvtFGl5IM,27 +onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/output_0.pb,sha256=JVxD5TKmPSVG8a_4F5GxWsxGnVh_R0L9rDe2k3xCqYg,43 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/model.onnx,sha256=EncOjVzLufDY4k7CdiKPnwWV3QqoASAgUDlw9q_f0z0,160 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_0.pb,sha256=XvAUu3zVMoHoUthPBoozrxWJMZk4TyEmquNiplVhb5g,83 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_1.pb,sha256=L69sZ8XUqDcre4xBAI4kPV0TarQpqwHvAdTg5f7WW9Y,107 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_2.pb,sha256=muCFB3W2JEK0ta9OShyFBcQwmhqbNzDHbY3sUDkVkew,59 +onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/output_0.pb,sha256=iQ3LpdiK7rS38o00o7UMFfXGstIaDyxsk2fileNMB1Q,59 +onnx/backend/test/data/node/test_gemm_default_no_bias/model.onnx,sha256=kLKHvgantAA1L4aWXYOBFpK_y_6ZYUd8sDM0HuauoYk,131 +onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_0.pb,sha256=cTbU9_Eif-2LEv4q5aKaThA_zQhShNPDIiZjXSRhMxs,91 +onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_1.pb,sha256=9trDrSVCbecGUg-TpqlqdscizRriba9XmLEIAPekmDU,131 +onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/output_0.pb,sha256=KC0JMcrMnA0iDy2_QfcyfQQs8KWTbYA9kLb9aSbETMw,35 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/model.onnx,sha256=kyvYbbUiBOl43sEzFkP1NX2h-4EHAR5BuTkNyiPUIKs,151 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_0.pb,sha256=VtTpPce13D-fdCP-802VIbl4EIVLgrtF7mtl517CpIE,35 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_1.pb,sha256=SZG6iS5JbxzyssmlpNhOPGFP_iOd8yfd9sbSGvm4LIA,59 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_2.pb,sha256=zRb1hwJ_IqbwUHQg5cFKeoV_wK7hFWJCLGv5_3lfDoU,11 +onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/output_0.pb,sha256=EINJmRzyMakSMOcv5FRxJpwJuzuYxYFp_vFX3lPPz1M,43 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/model.onnx,sha256=mUQWPy0JVeYPaVvAvb0jdSDFOKLpwda0OxRe6GBE3Ic,168 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_0.pb,sha256=KtFIVi8IliPuo9E23jP3YKzU-jsTyv306GzQu64WNRM,95 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_1.pb,sha256=QZrZwYak1ep3E164r-vGwhW0neLicmkAgQwUYgKQpG0,95 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_2.pb,sha256=qqc1BKD0WlwHFwNCosttdZqyvg0EznvDfX4sN4oLiGY,13 +onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/output_0.pb,sha256=uhIwMJjEzSp8y0mRbvsD9SClUujmS9ze-3vbtZmpAK8,47 +onnx/backend/test/data/node/test_gemm_default_vector_bias/model.onnx,sha256=d3yUgH0ldHi5SmINnvKCBg81rqZf64z97wzDRixnEtU,160 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_0.pb,sha256=r5WMCnSToJqMbEYSeANqSG5Nbsp3PtGfofCSBKWZxEw,67 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_1.pb,sha256=JeOCNEjJirYi_V4m0bfCyIwat86xDBD3ZA9OL6u1lPM,123 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_2.pb,sha256=IB3Jspke-7-5qQWMVzj62hbsVQ_lbvNUYjXvtFGl5IM,27 +onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/output_0.pb,sha256=-bT3X5G1IREouSTeHUyj7eZeA6zlCC5U25jNljD222A,43 +onnx/backend/test/data/node/test_gemm_default_zero_bias/model.onnx,sha256=fKG8IMPCAtOZnskNM_HhHhGPX54KM7mbRafsJxcKmAY,158 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_0.pb,sha256=MILDtCDczrrmVCYbqkuMR6oYZmKaoVlWgARdLbzo9B4,71 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_1.pb,sha256=1xWZAGPREKiwEVDAShgn4ytsgBqHdZiahRzc34kWXIo,91 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/output_0.pb,sha256=-fJCSSDCHHgenicNtmUhcWgfyxt9tadr5CZPutY1ol4,59 +onnx/backend/test/data/node/test_gemm_transposeA/model.onnx,sha256=VRg_UfqynzEdxEmglw_sL9ebMTbIvMUjxH2OmGPCIYY,166 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_0.pb,sha256=8v_ybDUH0fDPp5sZoIMfWJvtnweReOYdHp7Iu7qGYCk,83 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_1.pb,sha256=L69sZ8XUqDcre4xBAI4kPV0TarQpqwHvAdTg5f7WW9Y,107 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/output_0.pb,sha256=k-IwJyiSI1g8vypylfNjds4-VnWY6uME1fx6BH2lYZU,59 +onnx/backend/test/data/node/test_gemm_transposeB/model.onnx,sha256=qF4Yla3z628tEgTZQuvk_LRwoGr5nh7FJGJZxu3S4hQ,166 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_0.pb,sha256=XvAUu3zVMoHoUthPBoozrxWJMZk4TyEmquNiplVhb5g,83 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_1.pb,sha256=VKG3Ykxfro1pdhKVtzUNYRYQjysnnn3_P7ZkAKfVQm8,107 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_2.pb,sha256=_0XG54N6Zz5zb0Nxb201xMsoJvRtQ47nblJ4VfMvvXA,27 +onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/output_0.pb,sha256=RPKyOLcHHw4m-bpJDc5OB_oLunmPJGdD9FYP-keAVHU,59 +onnx/backend/test/data/node/test_globalaveragepool/model.onnx,sha256=O8bUH8bIsDlQm_GcKCIZX15KygH3tB-BOAui31v3RqU,133 +onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/input_0.pb,sha256=qmHY5ZOgfUeKlGr6gKjS6R4nQl61rIb7E8ZrdQSs3HQ,316 +onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/output_0.pb,sha256=xNA3TgQwfvnKKtJLHlP8BGoYSyY42pXVndHvtMzKNSw,27 +onnx/backend/test/data/node/test_globalaveragepool_precomputed/model.onnx,sha256=fYYxYRB9qBy5cVtNA5H_od0ZzETP2-629m4F94mACDE,145 +onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/input_0.pb,sha256=VEPr9C-MPAPrWNFhCqj3re8AshFCwfNIPN9i9k2EvMo,51 +onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/output_0.pb,sha256=otE0U2fczeenDUSTqh59jqDAfCNOJMoQjqE0pLtL-KQ,19 +onnx/backend/test/data/node/test_globalmaxpool/model.onnx,sha256=Z4zJa5gYvDzHTdML1nc82x9KOR97Ir3LF5TOdvAhRhE,125 +onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/input_0.pb,sha256=qmHY5ZOgfUeKlGr6gKjS6R4nQl61rIb7E8ZrdQSs3HQ,316 +onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/output_0.pb,sha256=56GJcF-qYJQhHJoqwvMOiOlFGpGfi3tVUUGyrRdycLs,27 +onnx/backend/test/data/node/test_globalmaxpool_precomputed/model.onnx,sha256=w92_r0TUpATDaoaqn7YgupNN2MJKWEtXy-t2ff3mEH8,137 +onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/input_0.pb,sha256=VEPr9C-MPAPrWNFhCqj3re8AshFCwfNIPN9i9k2EvMo,51 +onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/output_0.pb,sha256=BIUCmZ29Gugpj6pl82Cf1tuj26kP34Mbp33VqWuFmnI,19 +onnx/backend/test/data/node/test_greater/model.onnx,sha256=ewXoLOj7YNobggSofGk__hmXs7RamQ2IosA_fQ3Eaos,145 +onnx/backend/test/data/node/test_greater/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_greater/test_data_set_0/output_0.pb,sha256=uDTgBvvrdZBv60SwtKEuuMrGFn3ip783yOujJbu2_wc,79 +onnx/backend/test/data/node/test_greater_bcast/model.onnx,sha256=JL5xVnCCPgeF5ILL-bLmKpmrfSU-CfJXL1FBhe4GW7E,143 +onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/output_0.pb,sha256=ZferDXWUCmTQTquCgvAxWYEnjQ_b1B-dOjznTOngcdQ,79 +onnx/backend/test/data/node/test_greater_equal/model.onnx,sha256=pWC2qrXxm0Vbjj2m8omzBcdrjBVlVCxRRpqg3rY8Lx0,171 +onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_greater_equal/test_data_set_0/output_0.pb,sha256=mzT9JswDPorPoAK92dgoB5a05d4MI3Tx5985GQu3Ntw,85 +onnx/backend/test/data/node/test_greater_equal_bcast/model.onnx,sha256=E1Hy02R8SQc_F_PlX-ArhzZQJwPyTmPnw2z_mxDP-kE,169 +onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/output_0.pb,sha256=oDBk3zKJWIs6Tb8nJcKwh-Fuv0CHlJ8PtGAuV9byRuw,85 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/model.onnx,sha256=fATWTpPG4PUHGDL0tDnliPidXPuXmVd2GPSryeXnkmQ,447 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/output_0.pb,sha256=oDBk3zKJWIs6Tb8nJcKwh-Fuv0CHlJ8PtGAuV9byRuw,85 +onnx/backend/test/data/node/test_greater_equal_expanded/model.onnx,sha256=5stox5Y1fFCl4dX3MuRH40TfIeiJHg4_zUwRAt0FyBQ,425 +onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/output_0.pb,sha256=mzT9JswDPorPoAK92dgoB5a05d4MI3Tx5985GQu3Ntw,85 +onnx/backend/test/data/node/test_gridsample/model.onnx,sha256=sE6vIZLZeCDKKWMML92vqJT3WEaFqAs1HFAhgwyaqsI,227 +onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_0.pb,sha256=Er_KMA_bpGQqp91W7npSqfc4KcISgiYpOOth1aVtUoI,79 +onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_1.pb,sha256=VIc-rbiGUK4N9CBPdEUTgumay_Uf6CQo8S8rSodbCdo,307 +onnx/backend/test/data/node/test_gridsample/test_data_set_0/output_0.pb,sha256=35yxRZMYSQ1swNbyzFBFwVsmmeUdZR7iduxEuQ3I0NM,160 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/model.onnx,sha256=pFqw07lgWfBFdXIVDNqkz1fiCMLSmRwrem7VHNuf2-Q,219 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/output_0.pb,sha256=LKkY9CQbQvs4La-iuW0PzhH7gUCo-vr7friq3vXiyRw,47 +onnx/backend/test/data/node/test_gridsample_bicubic/model.onnx,sha256=NX7w77xYxRBcamNe2mmvkoT6KkTa2KpYGiG8RYKX7Vo,186 +onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/output_0.pb,sha256=iWyxqWQU2N7P8sBWOhtYGlbaZOizT5bWdJyERH9Vmd4,47 +onnx/backend/test/data/node/test_gridsample_bilinear/model.onnx,sha256=XV3KrvU2jgRF6HjxHI9mJgA4lmGRp2tCmNq9KJgqZOY,188 +onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/output_0.pb,sha256=JT3KtQjkMJaSS4Apt00mMjXzrXSol3CsMvGX-0_2-w8,47 +onnx/backend/test/data/node/test_gridsample_border_padding/model.onnx,sha256=SZwghsEP5AmthCJ6BBKwV32TWhGbqJcmV4Wb3ueswgw,200 +onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_1.pb,sha256=uIKQ9S1EJfGQDnIqDNFDZbPRcI4P9J11zZOQAFxwJGA,82 +onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/output_0.pb,sha256=9rfdAbkyFmuRjDoU9VsoDOaem0ChoKqoz4aBl_pcsGk,47 +onnx/backend/test/data/node/test_gridsample_nearest/model.onnx,sha256=FUK01gEOr1LSvZVQdPq6wiXaLd0IxQKFn8avazAf-_E,186 +onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_1.pb,sha256=-sgoYS71T1zyadZBJamze1_tDkLWp1RdqtziONB_zus,82 +onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/output_0.pb,sha256=RM6pagyCCllTI5PrwIPKwCNW9RocxzB7ktzcax9cNiM,47 +onnx/backend/test/data/node/test_gridsample_reflection_padding/model.onnx,sha256=GfkP1zXISefFz787m3n-Ng4pMq8CPN1cOKmgXnWhAkw,208 +onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_1.pb,sha256=uIKQ9S1EJfGQDnIqDNFDZbPRcI4P9J11zZOQAFxwJGA,82 +onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/output_0.pb,sha256=8Ovh-MCNiNQzDI6mWj3wv0noANRS_mwlPRnZPtEz7Pk,47 +onnx/backend/test/data/node/test_gridsample_zeros_padding/model.onnx,sha256=uP5UNQgr2WNxv1XyMSYz1k4fdwS-7Z5CspxnaX1oyvc,198 +onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_0.pb,sha256=eusk3-63HiQIJBbA_iwre2x4nSbdmUrKrC1hscOgPoQ,39 +onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_1.pb,sha256=uIKQ9S1EJfGQDnIqDNFDZbPRcI4P9J11zZOQAFxwJGA,82 +onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/output_0.pb,sha256=jRhFqa9skdV2ePTbDrQAFklZOaUhfsUJp4FA8TgrUq8,47 +onnx/backend/test/data/node/test_group_normalization_epsilon/model.onnx,sha256=rB8_YASPL1OxJvAU_WKzFz5DrSNYWWauQvK2QZUdu3E,237 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_0.pb,sha256=vb4yV3qM3ZDB7ZDyehV1hPcMyyZ8L63KEzuTUTeOkm8,208 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_1.pb,sha256=4f7j81sYSvK5wYqS9-X89XDxX-yIRaluWodE627Hjs4,21 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_2.pb,sha256=haAspcbW9pgWZjQD1THg0c-QvDlKE6jtFhf_DhW3Bc8,20 +onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/output_0.pb,sha256=YTLZ_29__4x48FnTWP5p9sTapNDROK63zlqdmdszMIQ,208 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/model.onnx,sha256=2DpqaRmSCg8lsWFcppaiOcQQ-910HqdmMgMsWuyixOA,6044 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_0.pb,sha256=vb4yV3qM3ZDB7ZDyehV1hPcMyyZ8L63KEzuTUTeOkm8,208 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_1.pb,sha256=4f7j81sYSvK5wYqS9-X89XDxX-yIRaluWodE627Hjs4,21 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_2.pb,sha256=haAspcbW9pgWZjQD1THg0c-QvDlKE6jtFhf_DhW3Bc8,20 +onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/output_0.pb,sha256=YTLZ_29__4x48FnTWP5p9sTapNDROK63zlqdmdszMIQ,208 +onnx/backend/test/data/node/test_group_normalization_example/model.onnx,sha256=ImHTJHtGVOBHe_GukTn4w0K9DkGvw5RlCl-RylJz44A,218 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_0.pb,sha256=692CieKQgoIgcJDXYv6vb3tpyZcEpU2pA8gk_cgjurc,208 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_1.pb,sha256=JZpoCnVIojzpKltibQXrfHcmVZ_8x3v-zSsly_yjWIQ,21 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_2.pb,sha256=7jDYrnyTyqDlzqmumjdy90Ho17kJFHA_NRTMVxdXAlE,20 +onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/output_0.pb,sha256=IWglEkZxiBmgIV2VMKKOdduhOZh5vofT6czepgQNPyc,208 +onnx/backend/test/data/node/test_group_normalization_example_expanded/model.onnx,sha256=tjujnfEJNSChZbn26rglQNzx6AI65avvNVurDoAg1ic,6044 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_0.pb,sha256=692CieKQgoIgcJDXYv6vb3tpyZcEpU2pA8gk_cgjurc,208 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_1.pb,sha256=JZpoCnVIojzpKltibQXrfHcmVZ_8x3v-zSsly_yjWIQ,21 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_2.pb,sha256=7jDYrnyTyqDlzqmumjdy90Ho17kJFHA_NRTMVxdXAlE,20 +onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/output_0.pb,sha256=IWglEkZxiBmgIV2VMKKOdduhOZh5vofT6czepgQNPyc,208 +onnx/backend/test/data/node/test_gru_batchwise/model.onnx,sha256=EJ7A4Lcnv9u2MxIAe6aUd7SRfGWA8rsG2_KbvUJ7sWQ,235 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_0.pb,sha256=X4Jx731skujCbqYlfE79v4ovLqbqAar9VfhQTegviw8,37 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_1.pb,sha256=1XWIhQUoTeNdQ7bZCX8yrBOX7Q92l7BeORAPrRY1avU,158 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_2.pb,sha256=oTE_0fIu0UOnnYZ7CNygBadHRlesmV1ETn3TvYDEya4,446 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_0.pb,sha256=9JVi2_8o_taU1q2mC9RFUb8_KHoyJ-J4xI0rXrK5LYs,87 +onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_1.pb,sha256=CnxT40oj7emJcthZanYarqegr_Zsvg3qkro1M3x3dUU,87 +onnx/backend/test/data/node/test_gru_defaults/model.onnx,sha256=pDyjizKvec0NBmGlQm_mVeKKbVfEZqsb007hZq5Bo8A,189 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_0.pb,sha256=CfdyEi1TF1qNXdr7S9ZjPY0_c7pWtxM7ou3bNl3fNIo,37 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_1.pb,sha256=Z_bpWjBL52Ni7_VmBBnx9GHq8oGZzSILXNiGdNDDxiQ,133 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_2.pb,sha256=blVg0U6-PdjmVF5azf2rAQafYFnzJtcTojgoF5OKCak,314 +onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/output_0.pb,sha256=xhW9IjUNOKkLWOQu1imw5N_rLbHxi-vqJStJf-FksVM,75 +onnx/backend/test/data/node/test_gru_seq_length/model.onnx,sha256=-5slDVVQLeKrsx2oXppph0Ecn5-FyJsyKNJFl6NCcjM,215 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_0.pb,sha256=fFR4OIXWBj5wmFEuZbfl7GOhhRaSJv9tEZM8VbjQ72Q,85 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_1.pb,sha256=tdQyLDrgooqElZX1X_yvVWQ3l77QTVxNMuJ9Mc3my5A,194 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_2.pb,sha256=bGMNqQFklQXONtCc1NZ73_jH8eb-uYXHaNyqNefJOzg,314 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_3.pb,sha256=pj0sMaV4OPwfxoqssa4Ub4IA_xoFv1hFo--pPjxftQ4,131 +onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/output_0.pb,sha256=ANqsfpHbnQLw0XMH1goz9oheZN79GTowkv3yVIr6l8A,75 +onnx/backend/test/data/node/test_gru_with_initial_bias/model.onnx,sha256=7ujI1hPo9JwV7jRibMTJudZbvNfm8b6HDmbtRLzRFQk,222 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_0.pb,sha256=eujm2YGHVRU93EAGK-aPA-aFEublku2wP288wJjVc4M,49 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_1.pb,sha256=EfCDZYPnRWB7IsE8QGLIxMMz1xsQspu2INrBzW0mBtw,121 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_2.pb,sha256=NuX-1ShTCBOI4m3H5fPAevf2oD_13zSsGNnhuLqlfwg,121 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_3.pb,sha256=SVjGa5u2ro0p1fUr5PEg1iOb7l12XHqFk9ZhQdMB2uQ,83 +onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/output_0.pb,sha256=HqlZXwUiQd76iSbd2zcKuJXxDM4Xe2av5ojJ5ndZ4Vk,51 +onnx/backend/test/data/node/test_hammingwindow/model.onnx,sha256=XmWXPruOkAjvFooZAUhkRImHklBQyIc-oNDAnk6Kp_s,97 +onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/output_0.pb,sha256=erJQv5I-MoVyb3kBbLSXrKK2RZRRXcIbqpDz4NR3LH8,49 +onnx/backend/test/data/node/test_hammingwindow_expanded/model.onnx,sha256=q-Ts9UxK0oBEFLslo8fT_xaD5tAIfY0LUc9DqeVTYk8,4131 +onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/output_0.pb,sha256=erJQv5I-MoVyb3kBbLSXrKK2RZRRXcIbqpDz4NR3LH8,49 +onnx/backend/test/data/node/test_hammingwindow_symmetric/model.onnx,sha256=8JOAx7sAb5z3xfSuOwq8AD30ghEjTR1iH06VS9uqAsM,124 +onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/output_0.pb,sha256=nKPj_SRkHLyYVbIjwKbiJUmNpK_k7_yVYgwGxRYlwvY,49 +onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/model.onnx,sha256=n6fC4unzUlQFNiC0fiAPQRhIuTRkdwb-xIbr2ucCxks,4701 +onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/output_0.pb,sha256=nKPj_SRkHLyYVbIjwKbiJUmNpK_k7_yVYgwGxRYlwvY,49 +onnx/backend/test/data/node/test_hannwindow/model.onnx,sha256=fpu3WfmAnvLPZokShbCTr9zhweBMiIs4BSWCJ6kM14E,91 +onnx/backend/test/data/node/test_hannwindow/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow/test_data_set_0/output_0.pb,sha256=Cgf8fH2I_mUbuBNRNTFRg7Fm0oNAkencL5GvslOAWLg,49 +onnx/backend/test/data/node/test_hannwindow_expanded/model.onnx,sha256=ghAYZSC8XHRMj1HAkopEVhR1VEM8XJ_JCD0RcUFmJ_o,3792 +onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/output_0.pb,sha256=Cgf8fH2I_mUbuBNRNTFRg7Fm0oNAkencL5GvslOAWLg,49 +onnx/backend/test/data/node/test_hannwindow_symmetric/model.onnx,sha256=ieBsEc3yA82fJuZLOPWaGQXzY1oC639oG1dzpxVjR8g,118 +onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/output_0.pb,sha256=0Tlu9lhuUS2lowoWHEPsOaua9vxLdnQZhyCoYk_QKrw,49 +onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/model.onnx,sha256=Xpsrjinpeu2i0nz2_8Jm6nIHzLhVwNLxc1w5QM8kr3Q,4362 +onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/input_0.pb,sha256=xTJpebPqFxfV2WSsCwKnXNthXGyvwqNu-H_FWa5J6cA,11 +onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/output_0.pb,sha256=0Tlu9lhuUS2lowoWHEPsOaua9vxLdnQZhyCoYk_QKrw,49 +onnx/backend/test/data/node/test_hardmax_axis_0/model.onnx,sha256=moiCGKB0Oc3qJtx6dMYz2IfuBDJShvTEZHTGzMR7tBM,125 +onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/output_0.pb,sha256=-jupCDBJs-WrmX2w6Gbwg76FW-XG0RzAhHYZeclMMHM,254 +onnx/backend/test/data/node/test_hardmax_axis_1/model.onnx,sha256=lLcJFwZG9SxP1SR1ip1xRH_GWjwwUgZSGcDmK_DiOKg,125 +onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/output_0.pb,sha256=ShJTro9DVDSj1gN_QIhaNfi3aDsXbW0xlw5He2wbAF0,254 +onnx/backend/test/data/node/test_hardmax_axis_2/model.onnx,sha256=Aq5v4HywyLNApU7lL1ge1Izhbwamc7jnq2GVxB27hkA,125 +onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/output_0.pb,sha256=p6ts1e5G3uPByR7frd8okvp0wsK8j91dRLPkDbq5Yf4,254 +onnx/backend/test/data/node/test_hardmax_default_axis/model.onnx,sha256=K3iL4jVTDBNWZxWOSU7B9U-AP6EStZbEW4EfvDR8YKI,118 +onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/output_0.pb,sha256=p6ts1e5G3uPByR7frd8okvp0wsK8j91dRLPkDbq5Yf4,254 +onnx/backend/test/data/node/test_hardmax_example/model.onnx,sha256=tAlOkY2DZGE9MiBisTVqXU-wggSqTxs7DOiy6piZ-wQ,105 +onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/input_0.pb,sha256=OzGq9WBWdosYSRvhnaiLhc7KylgWFWhYq8uaEybAeNs,75 +onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/output_0.pb,sha256=M4Nd1Dixr1GZVG8M8nttCzW57XEJpxlL3pT_jKit-as,75 +onnx/backend/test/data/node/test_hardmax_negative_axis/model.onnx,sha256=GEMroWxNGa7Kdjf5rFkOztNV5167ywdGdc2gIlLGXmI,141 +onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/output_0.pb,sha256=p6ts1e5G3uPByR7frd8okvp0wsK8j91dRLPkDbq5Yf4,254 +onnx/backend/test/data/node/test_hardmax_one_hot/model.onnx,sha256=_QtPLoPEGl0HTFjIH6AWIiqzLwUzHdOc2SjWXHiK2bI,105 +onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/input_0.pb,sha256=DLuz3VAkGId5FXX8jyoCfePLABiQklqpVIJJXzXOvsc,27 +onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/output_0.pb,sha256=P6WwvTGfwLDhJb72onY1iPvk3b0s1_tn5fMLATQ1JtU,27 +onnx/backend/test/data/node/test_hardsigmoid/model.onnx,sha256=x1jxdfM48F0WGkijtGaaTVbTtdPHxnjTRlCk6DB0FSs,146 +onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/output_0.pb,sha256=TqEPthNFWy5d78pFlUAqA8L0OV5_7USxH89x_hDCGSY,254 +onnx/backend/test/data/node/test_hardsigmoid_default/model.onnx,sha256=Y7ODdiBbpLK5fxFTSMMTIMqPfBaA7lwgo47S8xmOt1Y,121 +onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/output_0.pb,sha256=9uWdF9Of6-C1Xl4uBs_ViDKh_BS2f-kxq05kKF6CL8E,254 +onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/model.onnx,sha256=abINq0Rs2GihOQ0A0ZGP-wrzpbfi1vQw8-zXbMtUCKs,1832 +onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=9uWdF9Of6-C1Xl4uBs_ViDKh_BS2f-kxq05kKF6CL8E,254 +onnx/backend/test/data/node/test_hardsigmoid_example/model.onnx,sha256=zXIxR7vCrEiVbhZT-8cy11aWjdJVvGMst4HEfjk3mo4,138 +onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/output_0.pb,sha256=PHqA-MDOmKyDONKLmnSan5kJG8kPdXMzAzKuVLYvEGI,21 +onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/model.onnx,sha256=C5ZbLmEUIJ2Cx3uX_V9D5hOk28lCRZCoNp_pstKJr4A,1816 +onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=PHqA-MDOmKyDONKLmnSan5kJG8kPdXMzAzKuVLYvEGI,21 +onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/model.onnx,sha256=S9Qspqr4OliFKvUDw3SzZdX-rsMZhcEzOoYvaq8XiLU,1643 +onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/output_0.pb,sha256=TqEPthNFWy5d78pFlUAqA8L0OV5_7USxH89x_hDCGSY,254 +onnx/backend/test/data/node/test_hardswish/model.onnx,sha256=L-oSF3JZQ1u0bOfve5WvbO1oKug4e0XpoY5FXCEKc1A,109 +onnx/backend/test/data/node/test_hardswish/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardswish/test_data_set_0/output_0.pb,sha256=GmF26kbYvCTZt0rhtvIs_790x5A_8j5LG4zpVHM8BaI,254 +onnx/backend/test/data/node/test_hardswish_expanded/model.onnx,sha256=94S0Yt1sfvNl1oFwM_9VttQwAQsshx2--_2U5brMOw8,266 +onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/output_0.pb,sha256=GmF26kbYvCTZt0rhtvIs_790x5A_8j5LG4zpVHM8BaI,254 +onnx/backend/test/data/node/test_identity/model.onnx,sha256=vbhYRCBnhtNPMtJTFCChF46N_PeaDL8PQaKyL_rzH6M,115 +onnx/backend/test/data/node/test_identity/test_data_set_0/input_0.pb,sha256=jVVsnPYTtqJkezoas6FKgAvUJVH-Z4OI0Eocd13lMSg,31 +onnx/backend/test/data/node/test_identity/test_data_set_0/output_0.pb,sha256=gGR3wxRX145Jj-O43a8Qh6gPsPhFfPlEHErpPYQTP4Q,31 +onnx/backend/test/data/node/test_identity_opt/model.onnx,sha256=O_lLBDX5CpDSi7O2MOl6WIg4QEQHw36dxVPbu3ejBoA,133 +onnx/backend/test/data/node/test_identity_opt/test_data_set_0/input_0.pb,sha256=YddZEUyYhxMxNF8EBJChB6-dIseFq_7iAqB4GMdZr5s,42 +onnx/backend/test/data/node/test_identity_opt/test_data_set_0/output_0.pb,sha256=eh6A9N--g1PUhUrMyCSJUT3XmOiwx8LdKFOQ96LXotM,43 +onnx/backend/test/data/node/test_identity_sequence/model.onnx,sha256=tJGrScD70_ZOZyW0ea7Y6jW43LLBXFfZyT4Jwh0cJeM,96 +onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/input_0.pb,sha256=OtWKEZPsdistnxRCHxBveuTAodHN1mzb88-jDLRqGWM,65 +onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/output_0.pb,sha256=Nzoz0AbflpzSX5mlHltvaOoEuIt3h7yohG3-3hUdgXs,65 +onnx/backend/test/data/node/test_if/model.onnx,sha256=Kpbswl4zKb87TSAXvwkKrXZ-pz5_FiaP8_q9CBT4q_g,321 +onnx/backend/test/data/node/test_if/test_data_set_0/input_0.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_if/test_data_set_0/output_0.pb,sha256=6Z-sAab-Ll2mHzCTuxkbUjBy_RmQb_4im7xdYzJzlbA,31 +onnx/backend/test/data/node/test_if_opt/model.onnx,sha256=bHltYx2DCg9ppabsHWPOdZ6ovPN8-fRYxKS9kcHBsOU,419 +onnx/backend/test/data/node/test_if_opt/test_data_set_0/input_0.pb,sha256=9kbmn5T_KJnQNPG1ixMvyTnx_50JkgYRl4SGlqjdY00,11 +onnx/backend/test/data/node/test_if_opt/test_data_set_0/output_0.pb,sha256=CD_cSpf7zENvc3TWqcIg_NGBAiNDKNKlQTYwwfMpe04,44 +onnx/backend/test/data/node/test_if_seq/model.onnx,sha256=OzaqxTiIf5D_51--3X-8qhjyGSpDus2SnZ5ez_ImuRc,389 +onnx/backend/test/data/node/test_if_seq/test_data_set_0/input_0.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_if_seq/test_data_set_0/output_0.pb,sha256=nrKwZGW_LIu6T51XGN9q76qgQlPcdYwJp1dZ-icyV8w,35 +onnx/backend/test/data/node/test_instancenorm_epsilon/model.onnx,sha256=Jy0FweIbj7aH1vnDHW5FACBUrua21w-GX7WrKmaJtKA,206 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_0.pb,sha256=SYKd5PF5vM-bKNrV8oTKPGHvYE0twyvHWdFt3T67zDY,496 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_1.pb,sha256=AI-3RnrtRdqYWsuL7R4_zbZ0Vb7zfnaDEBYsm0i2kvY,21 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_2.pb,sha256=2oNlXxvO0WnQ0oLXr0SuQwOm4ErOca8R9dkNLwewDK4,24 +onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/output_0.pb,sha256=kViHfy66VxtlADF2mSyn7ORx1duw-RQk1rfI2xGzAf0,496 +onnx/backend/test/data/node/test_instancenorm_example/model.onnx,sha256=LLUFeAIjH4RnEcejNWi-T2Sb5jrD6MImRG__380WiMo,187 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_0.pb,sha256=VUIPX62VbmFbVNHPK2_fBC1r_H9D8f-WYOR64GExRxg,39 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_1.pb,sha256=LAyTcjTe_XhxYy49mFzDu7kzZbw1weK3MkBpQcDLY7Y,17 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_2.pb,sha256=Qr3ZK8mEuzcmIiC7CqVjLO10zP1ZUJSVhf57xgIViJc,20 +onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/output_0.pb,sha256=UXtFI_9wnq2LC-OKKrnRlR7OkEDwtzSz6huAdy3yogI,39 +onnx/backend/test/data/node/test_isinf/model.onnx,sha256=gxZuedrS5Slkl8KGovBih4cg-hStaGoLKrUmfwqjAfM,85 +onnx/backend/test/data/node/test_isinf/test_data_set_0/input_0.pb,sha256=DUSqI3C3X65jGkuhMXunUVTh3fc8Y2RfKVcIgqF2PSI,33 +onnx/backend/test/data/node/test_isinf/test_data_set_0/output_0.pb,sha256=IU0OrIPsDhiQy6zcHECAVjDvfVr6qR_yXQEvoNCEOAQ,15 +onnx/backend/test/data/node/test_isinf_negative/model.onnx,sha256=apLBD-QKNgNNxpoWhmyJus354wRoXdNzxw8BW79LgzY,118 +onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/input_0.pb,sha256=TZCOthXvSS1htnpkqRg4pC6K8OoGrAnxG_8lBZ2_jKk,33 +onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/output_0.pb,sha256=EkxCQSMrh0vkL8zRXyX5wQasiMwKXB41vEbwM-mJ9Sk,15 +onnx/backend/test/data/node/test_isinf_positive/model.onnx,sha256=Q6WUhMoGThgwtNju9JifC_Ecc3H8R2eUuPCP4lOUjtQ,118 +onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/input_0.pb,sha256=EszjPltq6ca9PXAPoXK2UayVbMS6fQ4AMMUExeYrUZc,33 +onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/output_0.pb,sha256=k8MIxh7aAeuvyLaQHb3xCbJ1zjetTSbQ9jrGyvmdMAA,15 +onnx/backend/test/data/node/test_isnan/model.onnx,sha256=23LQ_g9RTTK6vEbx-QVEcKsPYxZm0JuUqgeuZxTvvsI,85 +onnx/backend/test/data/node/test_isnan/test_data_set_0/input_0.pb,sha256=H5gFBAl03FCNLS-oGVx0MY6lEtHHnf-UEWGtwpx1UnI,25 +onnx/backend/test/data/node/test_isnan/test_data_set_0/output_0.pb,sha256=LqF0WXw1O6g2JY9RJ3rdO4E3w-y_AL4mVD6PQaE7btw,13 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/model.onnx,sha256=Qu0CT3bG2vP6ou0oyq0FeISUX1PBaBGR3O6yFpUv_P4,261 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_2.pb,sha256=LXv8aWQikWfT9D0FYEGMsl-g-FZoYCh4YhCuC_3uprM,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_0.pb,sha256=iVt1SwGe_eyWjGblJNeTU6rlSc-4YC-xkTWTBTmHODI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/model.onnx,sha256=DUxhEduHYmkto1q2Uv_ED0HtSnJ0Hl7aU-3PIS9Veqw,6048 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_2.pb,sha256=LXv8aWQikWfT9D0FYEGMsl-g-FZoYCh4YhCuC_3uprM,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb,sha256=iVt1SwGe_eyWjGblJNeTU6rlSc-4YC-xkTWTBTmHODI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/model.onnx,sha256=tMjoGfaPiZVV21CHq_LjcOc68zQW8yZ35H-1gxQYvkI,6300 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_1.pb,sha256=c5v62j2q513u7QaD0Kck1K-O-g3Q6LiJWVgNaVZ3umg,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_2.pb,sha256=LXv8aWQikWfT9D0FYEGMsl-g-FZoYCh4YhCuC_3uprM,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_0.pb,sha256=iVt1SwGe_eyWjGblJNeTU6rlSc-4YC-xkTWTBTmHODI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/model.onnx,sha256=sfa3c68-O_GcmBe4JJTF-vU1Y7ITngIUR1G5uPwynfk,253 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_1.pb,sha256=EZKA7ForrN2YairSPGNOCkCyOm1H2fD6otmjaVO4YdQ,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_2.pb,sha256=RbUzETROopB8rHchzsZs6Msdde_nz6eGAAvGd5telR4,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_0.pb,sha256=_7YDN6UEtee83kkh5wsnjvgdzJLyTGqAqlcF1Mig-8s,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/model.onnx,sha256=yiizqo2aVKXpdnyNQtQN9Aaox20FkEpMwkgewv1Qnfk,6040 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb,sha256=EZKA7ForrN2YairSPGNOCkCyOm1H2fD6otmjaVO4YdQ,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_2.pb,sha256=RbUzETROopB8rHchzsZs6Msdde_nz6eGAAvGd5telR4,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb,sha256=_7YDN6UEtee83kkh5wsnjvgdzJLyTGqAqlcF1Mig-8s,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/model.onnx,sha256=-ZUiNrDjVRz4py1EbR--rS26VWfdv9y6fKtQvlYWNHA,6292 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_1.pb,sha256=EZKA7ForrN2YairSPGNOCkCyOm1H2fD6otmjaVO4YdQ,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_2.pb,sha256=RbUzETROopB8rHchzsZs6Msdde_nz6eGAAvGd5telR4,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_0.pb,sha256=_7YDN6UEtee83kkh5wsnjvgdzJLyTGqAqlcF1Mig-8s,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/model.onnx,sha256=pZlPnXiGuXY7ZUkh8lgWBpkktPV_OzY6efzG3KfQpoo,272 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb,sha256=Z9KJWMim8_HHQqx310sN-MwR8HbbppmvpY0Gd7oGIIY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_2.pb,sha256=E-0WQ1hbMoH0mpC3NBjz-AzskpOkxKDYBugpDFckqXY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb,sha256=VnTGQAZfGqzqbsQv6BCWCuKG17-1be_ARnOAG2KQni8,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/model.onnx,sha256=D-htrwW-dU676NZDIItiLrkYjhMTUNmHSFcMiJEs7IQ,6633 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb,sha256=Z9KJWMim8_HHQqx310sN-MwR8HbbppmvpY0Gd7oGIIY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_2.pb,sha256=E-0WQ1hbMoH0mpC3NBjz-AzskpOkxKDYBugpDFckqXY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb,sha256=VnTGQAZfGqzqbsQv6BCWCuKG17-1be_ARnOAG2KQni8,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/model.onnx,sha256=POGSoiJko5Xu7inl9n9LtBqkhkIMpdjOgKZ5Drwrano,6915 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb,sha256=Z9KJWMim8_HHQqx310sN-MwR8HbbppmvpY0Gd7oGIIY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb,sha256=E-0WQ1hbMoH0mpC3NBjz-AzskpOkxKDYBugpDFckqXY,25 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=VnTGQAZfGqzqbsQv6BCWCuKG17-1be_ARnOAG2KQni8,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb,sha256=5ECA6Cn2IbIzbiRuOg38eKBimy42xy4LEHe1g1EYte0,26 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb,sha256=tHQXIVTQIuP89WdedOAN8Ba1rw4PrttrBKH3B23-9RE,31 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/model.onnx,sha256=lFCifpXsH80wLKo1i6kqVLL9bL6nZVC6d4EoRp6FCyw,280 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb,sha256=xCO5Odqhx6GmjsUlwlrHLnjfm63TjRJb3rzZndZCYyQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_2.pb,sha256=Pd-TMGMv2FcDr-jRpePp8LPEJICDh8AD1HX04T6MrLI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb,sha256=1QvjVDP3oBuUy26wURfUK_9v8pj-Jr8iXjjvMpm0Lp4,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/model.onnx,sha256=MrIobPhwcsTjlPntx0-XmOZSh2jahDomXYmftvYNOeI,6641 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb,sha256=xCO5Odqhx6GmjsUlwlrHLnjfm63TjRJb3rzZndZCYyQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_2.pb,sha256=Pd-TMGMv2FcDr-jRpePp8LPEJICDh8AD1HX04T6MrLI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb,sha256=1QvjVDP3oBuUy26wURfUK_9v8pj-Jr8iXjjvMpm0Lp4,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/model.onnx,sha256=FT55lf5rew2LfzX4yYFsYutgHfAPJMl2TmTz3kcIg4A,6923 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=z0sxUFTPXC7xORC3TXH-lrSh-0Dvo0Izr6rqpN7XmMQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb,sha256=xCO5Odqhx6GmjsUlwlrHLnjfm63TjRJb3rzZndZCYyQ,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb,sha256=Pd-TMGMv2FcDr-jRpePp8LPEJICDh8AD1HX04T6MrLI,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=1QvjVDP3oBuUy26wURfUK_9v8pj-Jr8iXjjvMpm0Lp4,59 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb,sha256=0ejfMOUdKfdOLL6TPubooul674_H7ZZecRkExYlE40Y,18 +onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb,sha256=_lB0ZM2LsSWG1KALOG-iiMDIp75mHdZ3BlGa0KiPZL8,23 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/model.onnx,sha256=nWu0d8mPuo_q-6EbxNldBgOwAHLI6r82ofpwMOeY3VE,312 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_2.pb,sha256=5PyU6fVFO0EEZAhy7iw-cH3feNNieB9cflROAd5uNrE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb,sha256=v4LJo9woQRls5a_jNs6Rjayjn62ji3ZGj_FOZjvOR6w,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/model.onnx,sha256=0ngaHnVQCQtDLmTPUnsltXdMbsef1Zao-_xztRUrJqg,6600 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_2.pb,sha256=5PyU6fVFO0EEZAhy7iw-cH3feNNieB9cflROAd5uNrE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb,sha256=v4LJo9woQRls5a_jNs6Rjayjn62ji3ZGj_FOZjvOR6w,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/model.onnx,sha256=dlYp8YolSE9qPr-UD8df4ajih6-FKKW4S7wvGSpwwGE,6876 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=7opcXxjA9jj8tE0kwn6o2zODfFoW-_nJ5TGxMKGx3Fs,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=5PyU6fVFO0EEZAhy7iw-cH3feNNieB9cflROAd5uNrE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=v4LJo9woQRls5a_jNs6Rjayjn62ji3ZGj_FOZjvOR6w,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/model.onnx,sha256=L1n3cJ5FYR20w-NL_S3NqlfSja8XnlEEZGDUXF5_Lp4,304 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb,sha256=ZPe50IuXkbPIN0CuON0wV-i4zLn3HPRsxO5bwFT9bkw,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_2.pb,sha256=ZKaykW9NECftmK4UFhp4YwKdZ066BMxKP2xmGzUHx28,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb,sha256=d2aHuLpzy26hKZfRcdjI52hGJm4-Rnvt4OA7yaHmC70,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/model.onnx,sha256=aPdwPxyqI8o_B1EVa074QMWy1LFSRTbDx0hGkB_VWNI,6592 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb,sha256=ZPe50IuXkbPIN0CuON0wV-i4zLn3HPRsxO5bwFT9bkw,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_2.pb,sha256=ZKaykW9NECftmK4UFhp4YwKdZ066BMxKP2xmGzUHx28,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb,sha256=d2aHuLpzy26hKZfRcdjI52hGJm4-Rnvt4OA7yaHmC70,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/model.onnx,sha256=Tf3OQ_KUgR3XL4Q8Uno1nuzP5lghFAUzrUSCNbvqLyk,6868 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=ZPe50IuXkbPIN0CuON0wV-i4zLn3HPRsxO5bwFT9bkw,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=ZKaykW9NECftmK4UFhp4YwKdZ066BMxKP2xmGzUHx28,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=d2aHuLpzy26hKZfRcdjI52hGJm4-Rnvt4OA7yaHmC70,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/model.onnx,sha256=CpeyhCB4UgjtGlVuw-BMJErTR4D3zFHDIZGjjcDBlzE,296 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb,sha256=va8YRICxaQUTR-F6lUfwmRzaiwoaXpFUgZQvNMMtd2Y,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_2.pb,sha256=k3SelyY2T9UlihBpgMkCl7r0uQ1BnbqvAaqnmxhD3BU,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb,sha256=9UZHfb3EbKd1lt9AAGTPK2rFA9w_3PYU1FfL5IMX3aM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/model.onnx,sha256=TcFs6aY6Oar3gTdtyKmzSxynu1bE4j3XLQ746ZeeLQU,6584 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb,sha256=va8YRICxaQUTR-F6lUfwmRzaiwoaXpFUgZQvNMMtd2Y,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_2.pb,sha256=k3SelyY2T9UlihBpgMkCl7r0uQ1BnbqvAaqnmxhD3BU,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb,sha256=9UZHfb3EbKd1lt9AAGTPK2rFA9w_3PYU1FfL5IMX3aM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/model.onnx,sha256=ZwEvYPFp-eSF4B-jfEdEX3aDSTNZdjjo9L4BlwwVVyw,6860 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=va8YRICxaQUTR-F6lUfwmRzaiwoaXpFUgZQvNMMtd2Y,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=k3SelyY2T9UlihBpgMkCl7r0uQ1BnbqvAaqnmxhD3BU,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=9UZHfb3EbKd1lt9AAGTPK2rFA9w_3PYU1FfL5IMX3aM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/model.onnx,sha256=Mgyj5v0-FOddHlPK2b49zSnTzPhLyEM5FiHI5R637uQ,315 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb,sha256=4PBrvKy3rxl13drhLIE5bL7rYJLK7SoYRzFAKTTxLy0,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_2.pb,sha256=QoSWvX-d04Zqaupf99gDg5LEvvIx4A1qA6BgR8pJKMg,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb,sha256=lXpnAlkFz26dL_kmQMXJJBuuk88Vtr6FMhlY7fLtBEY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx,sha256=XURUaN2LvupLmJtwiMxdDYqC93dBWn4aiBVkkFlsYW0,7171 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb,sha256=4PBrvKy3rxl13drhLIE5bL7rYJLK7SoYRzFAKTTxLy0,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_2.pb,sha256=QoSWvX-d04Zqaupf99gDg5LEvvIx4A1qA6BgR8pJKMg,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb,sha256=lXpnAlkFz26dL_kmQMXJJBuuk88Vtr6FMhlY7fLtBEY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/model.onnx,sha256=Czi1LTqxIkTQ2PXFHqbp6R5Z1Y4XXM70c6r_hgc8k7o,7478 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=4PBrvKy3rxl13drhLIE5bL7rYJLK7SoYRzFAKTTxLy0,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=QoSWvX-d04Zqaupf99gDg5LEvvIx4A1qA6BgR8pJKMg,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=lXpnAlkFz26dL_kmQMXJJBuuk88Vtr6FMhlY7fLtBEY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=AaAYL201wLhEwUVhQKgq49OBfx_80pQdi_Wo33isQNY,40 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=KkksKiORHOMDplW6506hU0pgFYBUTSjkAndy3JMiaic,45 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/model.onnx,sha256=tfYuT0x48pO3zOdPvb2af-sgrWXGAtDgigBlY_f2A8E,323 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb,sha256=RsFIHUaVXXkVUuqNiwwNCyD0G-fnbmxu-VtjpWDCr-g,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_2.pb,sha256=sHcZJ9BtHritZi7auxmp2MQdRfb6VioBIMj37gdsuUQ,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb,sha256=OvSGu63DhH8Q6FOw4vCzNGh3CbvdnCI3IWrxEogZ7OM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx,sha256=1aszJdGvZzf6nhA_2iFchJivNtGVEIY3hLsuqQQ-U0U,7179 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb,sha256=RsFIHUaVXXkVUuqNiwwNCyD0G-fnbmxu-VtjpWDCr-g,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_2.pb,sha256=sHcZJ9BtHritZi7auxmp2MQdRfb6VioBIMj37gdsuUQ,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb,sha256=OvSGu63DhH8Q6FOw4vCzNGh3CbvdnCI3IWrxEogZ7OM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/model.onnx,sha256=mXqVqfsfyDeK9O9mvz6w8dBQsW4pScdPJF_aXhD0-EY,7486 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=RsFIHUaVXXkVUuqNiwwNCyD0G-fnbmxu-VtjpWDCr-g,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=sHcZJ9BtHritZi7auxmp2MQdRfb6VioBIMj37gdsuUQ,71 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=OvSGu63DhH8Q6FOw4vCzNGh3CbvdnCI3IWrxEogZ7OM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=PHTleirt5gAWtXMHawJcVrMcujCETXqf1i89SdGF-ho,24 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=AcKwzHM9Di6J1dyJw8oVyabffaBkKvZ2XqmMiJormnc,29 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/model.onnx,sha256=EsaeIyu7HXxvvWKBbE4MtVCAVtZSc8dLn-xEL_r1WEQ,331 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb,sha256=-_y6ugkVRAuX6VtIyUN56Ja8hsdgc-uYpjQhH9o3wgM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_2.pb,sha256=pL40Oaw2IK9LzoPOZDaP75bc2lI0nDGGPsLMtsEA7CE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb,sha256=_jNYy4sNYdyeP5vTYQs63WW9_PpdR1ObiJalbo7T1rc,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx,sha256=D6LP8qum68kfFVrPWqQpubdeeIJbDzrBY-kkaNgzfRQ,7187 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb,sha256=-_y6ugkVRAuX6VtIyUN56Ja8hsdgc-uYpjQhH9o3wgM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_2.pb,sha256=pL40Oaw2IK9LzoPOZDaP75bc2lI0nDGGPsLMtsEA7CE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb,sha256=_jNYy4sNYdyeP5vTYQs63WW9_PpdR1ObiJalbo7T1rc,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/model.onnx,sha256=-UB36cfKrf0whCnJPy35TDp_2DBfxSt_8Bt_dWcwDGM,7494 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_0.pb,sha256=x8hqB6r-sU_tXut9YmsSmWXCDcdeW-IZc_2vzMnZegY,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_1.pb,sha256=-_y6ugkVRAuX6VtIyUN56Ja8hsdgc-uYpjQhH9o3wgM,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_2.pb,sha256=pL40Oaw2IK9LzoPOZDaP75bc2lI0nDGGPsLMtsEA7CE,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_0.pb,sha256=_jNYy4sNYdyeP5vTYQs63WW9_PpdR1ObiJalbo7T1rc,133 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_1.pb,sha256=H81tuC3okK3RUjvS60hBfM9-STj5kuLiQ45PaSjvw04,20 +onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_2.pb,sha256=TssEW9-a_1tOb8XcyDe8IiJJqERhn0g-u0tEX7bp9Ak,25 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/model.onnx,sha256=6FTymSB7VUYcPZKAp3b5kYQ87SaZnfg-FQZohEflz3c,309 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_2.pb,sha256=__QE7EAq717I04_JG7I_51Z5sC2scQ1_WLMFDvKlhl4,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_0.pb,sha256=oMQtjXP8GiZgJtDBJ1pNz2JI7FdH7M-rQiiT4b63_rY,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/model.onnx,sha256=yzgNEYHW9v9br3Uvujgff1JNa3T_oqsWiRP1T09zcP0,6096 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_2.pb,sha256=__QE7EAq717I04_JG7I_51Z5sC2scQ1_WLMFDvKlhl4,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb,sha256=oMQtjXP8GiZgJtDBJ1pNz2JI7FdH7M-rQiiT4b63_rY,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/model.onnx,sha256=gCIb_iUdusfUvRyCuxAqngine6lFStpfNZ69Ob9IM5E,6348 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_1.pb,sha256=SQ1M8CaJ0qLmcLTvIkOMlgNO0L8HwaXc_m0K26vIbnI,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_2.pb,sha256=__QE7EAq717I04_JG7I_51Z5sC2scQ1_WLMFDvKlhl4,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_0.pb,sha256=oMQtjXP8GiZgJtDBJ1pNz2JI7FdH7M-rQiiT4b63_rY,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/model.onnx,sha256=hnQKrdk74MuMs4Tg3gWL2wnn6FImP1OfquiXvAdW62g,301 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_1.pb,sha256=7zaL3tDlpElVdcFGJowAUcp6j2Nq_xL1ZjeEUWn73QQ,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_2.pb,sha256=lLuiBlurFP19GIwIpD-S93B2EPY2gV630HErOlKNK-Q,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_0.pb,sha256=SEut2uddWoC5hL8h16RBz-7H9XquUwDwmbYco_WFWEw,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/model.onnx,sha256=jNy7YkdY02dnpplGtFAzO06i_D9fVavlHJo5YFx_hlc,6088 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb,sha256=7zaL3tDlpElVdcFGJowAUcp6j2Nq_xL1ZjeEUWn73QQ,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_2.pb,sha256=lLuiBlurFP19GIwIpD-S93B2EPY2gV630HErOlKNK-Q,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb,sha256=SEut2uddWoC5hL8h16RBz-7H9XquUwDwmbYco_WFWEw,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/model.onnx,sha256=P9ZmRA9zsujJH7q1P2GU2ZhZy7XO_vyTJZ2YBLP6SnI,6340 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_1.pb,sha256=7zaL3tDlpElVdcFGJowAUcp6j2Nq_xL1ZjeEUWn73QQ,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_2.pb,sha256=lLuiBlurFP19GIwIpD-S93B2EPY2gV630HErOlKNK-Q,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_0.pb,sha256=SEut2uddWoC5hL8h16RBz-7H9XquUwDwmbYco_WFWEw,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/model.onnx,sha256=sFRKeanTQ5lDP1B82P-m3otZ3wZLy3bFjx2UASnY-yY,293 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_1.pb,sha256=qe-XVfBNefBCFc7BqwFVPauls8p6xc7Kg_zN9Z7Z37E,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_2.pb,sha256=FJdFCcsdB1KsWHVHfzL8qSH4MOsZeA-MpqXybaSUyj4,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_0.pb,sha256=bZ21DorsMQaEkatMnhbenFA8rDNstpgIdOKwN8CvD30,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/model.onnx,sha256=mVKO0Uefb9JPe411LiAS2tT1MD0uA-b595TyKUVxLEE,6080 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb,sha256=qe-XVfBNefBCFc7BqwFVPauls8p6xc7Kg_zN9Z7Z37E,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_2.pb,sha256=FJdFCcsdB1KsWHVHfzL8qSH4MOsZeA-MpqXybaSUyj4,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb,sha256=bZ21DorsMQaEkatMnhbenFA8rDNstpgIdOKwN8CvD30,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/model.onnx,sha256=K6H8uEh5a0FOxFCaQJPHsxnyj8Js9OL3g7Wcu9onojc,6332 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_1.pb,sha256=qe-XVfBNefBCFc7BqwFVPauls8p6xc7Kg_zN9Z7Z37E,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_2.pb,sha256=FJdFCcsdB1KsWHVHfzL8qSH4MOsZeA-MpqXybaSUyj4,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_0.pb,sha256=bZ21DorsMQaEkatMnhbenFA8rDNstpgIdOKwN8CvD30,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/model.onnx,sha256=f3vB99GHKLnzZ6VMiUiLAYGhsUS_p9rv5q7xLL9arig,285 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_1.pb,sha256=dhPFEwCCeDrZzyZzzTc4B8YdEbZB8eOdvjTBRWTna0o,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_2.pb,sha256=I3r-GMpY-sWqu4lHyIlkD5s7nRziiDkrGNkhZxJ6PpQ,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_0.pb,sha256=ZZgPs-pyo4XnW-gGUahZhyyefO-v_IsCwu4fdYG-jGU,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/model.onnx,sha256=wHnllra7f3F0Yn7bx76ltd0uF4Jo38Bxh9cHiobLFR0,6072 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb,sha256=dhPFEwCCeDrZzyZzzTc4B8YdEbZB8eOdvjTBRWTna0o,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_2.pb,sha256=I3r-GMpY-sWqu4lHyIlkD5s7nRziiDkrGNkhZxJ6PpQ,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb,sha256=ZZgPs-pyo4XnW-gGUahZhyyefO-v_IsCwu4fdYG-jGU,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/model.onnx,sha256=tc5gpKsV8OptgZw0XhllKuJ_e5D23kH9Zba_-PA8hTc,6324 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_1.pb,sha256=dhPFEwCCeDrZzyZzzTc4B8YdEbZB8eOdvjTBRWTna0o,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_2.pb,sha256=I3r-GMpY-sWqu4lHyIlkD5s7nRziiDkrGNkhZxJ6PpQ,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_0.pb,sha256=ZZgPs-pyo4XnW-gGUahZhyyefO-v_IsCwu4fdYG-jGU,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/model.onnx,sha256=73UhfFj6hqI5f7kRWoruEDcfbuEaSx1xviw5cYFsRR4,304 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb,sha256=6GZ_k7Bg5S-sVwagkPPRjF351HRT5efq3L0RXbbFfPo,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_2.pb,sha256=XJX83EpHjA-svtp5ZUT-cGHo6rmxPJPuge7JtGCcIL4,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb,sha256=ZuFfotGGllfUiOngMYM4jmdmjdC-Jrrz9jj9tpFRkzQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/model.onnx,sha256=7PhXg1U9I2yFSYJKePbnKTjGHublQ2h8zflWqeuMuDU,6665 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb,sha256=6GZ_k7Bg5S-sVwagkPPRjF351HRT5efq3L0RXbbFfPo,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_2.pb,sha256=XJX83EpHjA-svtp5ZUT-cGHo6rmxPJPuge7JtGCcIL4,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb,sha256=ZuFfotGGllfUiOngMYM4jmdmjdC-Jrrz9jj9tpFRkzQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/model.onnx,sha256=fl0G-dS-cClTWvnynmx9TjXyx5KKrO4jhlL00yvyoxE,6947 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb,sha256=6GZ_k7Bg5S-sVwagkPPRjF351HRT5efq3L0RXbbFfPo,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb,sha256=XJX83EpHjA-svtp5ZUT-cGHo6rmxPJPuge7JtGCcIL4,29 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=ZuFfotGGllfUiOngMYM4jmdmjdC-Jrrz9jj9tpFRkzQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/model.onnx,sha256=A2htY41elXdKJX_T2mPfTFyS0GqQWit50Be8HTzM7a4,312 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb,sha256=lldUvoN8cEAHdj14iPu_W2NaWno-DAHLBIhPF_p4Pd8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_2.pb,sha256=IdlwA87uvKYeYSPClPtWIUU9EwPQigWZfgLGhsI5E-8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb,sha256=asFNXrgO-KAfHYrriGkiIwAWBnnnEv6efe4rmSzGxIQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/model.onnx,sha256=pF9o1Z9It45xK3tp6cYAld9W76DFjgGbAevaW6WotEY,6673 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb,sha256=lldUvoN8cEAHdj14iPu_W2NaWno-DAHLBIhPF_p4Pd8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_2.pb,sha256=IdlwA87uvKYeYSPClPtWIUU9EwPQigWZfgLGhsI5E-8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb,sha256=asFNXrgO-KAfHYrriGkiIwAWBnnnEv6efe4rmSzGxIQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/model.onnx,sha256=8Y-ybd42hcymPB_-xOT7GF0u6VtKzQypdE97bEGFX_Y,6955 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb,sha256=lldUvoN8cEAHdj14iPu_W2NaWno-DAHLBIhPF_p4Pd8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb,sha256=IdlwA87uvKYeYSPClPtWIUU9EwPQigWZfgLGhsI5E-8,91 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=asFNXrgO-KAfHYrriGkiIwAWBnnnEv6efe4rmSzGxIQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb,sha256=Jdb9L1HSJpPk-w9babAzkefVo1_1OtnrycFuzhsqWyc,42 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb,sha256=bTgUzSWmCvzUbVNgz5UitP82lYNZb6gp_d3N6yGwNMI,47 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/model.onnx,sha256=VNCqFZoNsJFTB0ngEmUrJH1xWBQz_NgmSPvTEir5W0w,320 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb,sha256=Gq90Mctuyji8qFBteJmVpb2Hrpyq8LdiSb3PnC7udRs,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_2.pb,sha256=HF2D2CKuGbjo2s8uM5wNXzz7x55YyplI1OBvIXzUr2g,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb,sha256=l5U23ab2-R8Md6IYMyC72oD0P2uU52TH0JhH_VPDIA0,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/model.onnx,sha256=Kby-ajsIb_vu3rEUCBYufMh2qVybDA7iRnakIPqUqhc,6681 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb,sha256=Gq90Mctuyji8qFBteJmVpb2Hrpyq8LdiSb3PnC7udRs,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_2.pb,sha256=HF2D2CKuGbjo2s8uM5wNXzz7x55YyplI1OBvIXzUr2g,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb,sha256=l5U23ab2-R8Md6IYMyC72oD0P2uU52TH0JhH_VPDIA0,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/model.onnx,sha256=nRuSFMXeVKgz0etyhiyLfadJW1Azl8Y7xaGnwBjg9No,6963 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_1.pb,sha256=Gq90Mctuyji8qFBteJmVpb2Hrpyq8LdiSb3PnC7udRs,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_2.pb,sha256=HF2D2CKuGbjo2s8uM5wNXzz7x55YyplI1OBvIXzUr2g,254 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_0.pb,sha256=l5U23ab2-R8Md6IYMyC72oD0P2uU52TH0JhH_VPDIA0,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_1.pb,sha256=div91pv-EhX8CtojPjzcl-OCV7-3ucF2WMaqIA4Owi0,26 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_2.pb,sha256=SFEhUFLf29xLZCuQskP1rqZTOtPHZurgQaHJ7iIloMg,31 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/model.onnx,sha256=70k7y1Dw1jZs9VJuQpe1maGoy9T8ZBGvVFF7ufVF5NU,328 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb,sha256=pjzWsxYof-fpDuo60I8TJ_IoOXGfsn9uGNzmD-dqse8,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_2.pb,sha256=F4lODpYxgJ7bw__BS9HzQiEIvcezx2NAUr-bdpeWLME,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb,sha256=CNZnGSYfMqynnB9RBPfSfz0Z107X_uZQ5YyxsQHrZPo,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/model.onnx,sha256=4kuJXvNy2sKGNjaWL-_137AAKHEwKq985u-YXKNKGKo,6689 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb,sha256=pjzWsxYof-fpDuo60I8TJ_IoOXGfsn9uGNzmD-dqse8,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_2.pb,sha256=F4lODpYxgJ7bw__BS9HzQiEIvcezx2NAUr-bdpeWLME,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb,sha256=CNZnGSYfMqynnB9RBPfSfz0Z107X_uZQ5YyxsQHrZPo,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/model.onnx,sha256=NW8yWja0CKsEwYw_M9mHJ0nj-Jc5dVEXcO5foPKFQcU,6971 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_1.pb,sha256=pjzWsxYof-fpDuo60I8TJ_IoOXGfsn9uGNzmD-dqse8,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_2.pb,sha256=F4lODpYxgJ7bw__BS9HzQiEIvcezx2NAUr-bdpeWLME,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_0.pb,sha256=CNZnGSYfMqynnB9RBPfSfz0Z107X_uZQ5YyxsQHrZPo,496 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_1.pb,sha256=h_PlYPPc_oA1NHtZrWv0D55Gb9RZgmTgYnO0VZ2TI34,22 +onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_2.pb,sha256=hVXqX9wgl-HPPlQrrhqClVhRvWG1HC21LrbjWPq5HcA,27 +onnx/backend/test/data/node/test_layer_normalization_default_axis/model.onnx,sha256=b_2kEk9Ayq6XBTG-oSOrfJFe_FKs_ZyYmWkU9OxDOSU,276 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_2.pb,sha256=XsRGoQhLOWNEyIeZqVVjYnHk4mZKF8lajaF9UI8GZts,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_0.pb,sha256=RfWw3_rb9bhFMIefbpqMRHBeSAkrDZx9kMlblgbFlT8,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/model.onnx,sha256=TDt2_Jc5tCXHj2l5O7QY9-ItZFhp2rUg2XN88nXzgBc,6273 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_2.pb,sha256=XsRGoQhLOWNEyIeZqVVjYnHk4mZKF8lajaF9UI8GZts,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_0.pb,sha256=RfWw3_rb9bhFMIefbpqMRHBeSAkrDZx9kMlblgbFlT8,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/model.onnx,sha256=HO6zcuo5N3mdS6EXK2OYuFoECMlKUYJhfOxhZw232DE,6537 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=x-FxhkwixA66m5bcrvZSS0AmXxQGtgXOW9RaiNdUFtQ,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_1.pb,sha256=lnzferwhTiJ1206NWKt09uMfuERk-l8gPAOC9Rz5TEI,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_2.pb,sha256=XsRGoQhLOWNEyIeZqVVjYnHk4mZKF8lajaF9UI8GZts,29 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=RfWw3_rb9bhFMIefbpqMRHBeSAkrDZx9kMlblgbFlT8,496 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_1.pb,sha256=PyQxLcwwC8Zmn6ihwCHpRkKnLdOtTKa19fmW23TrU9g,114 +onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_2.pb,sha256=OHN3HBAA9M0qcG3nWWb7JqxwLw8gfKJMlIsb3xK2S3E,119 +onnx/backend/test/data/node/test_leakyrelu/model.onnx,sha256=_22Ni5RQMG7uIlr6XEeVpMPtd6m-wghY5OPw7MX_Z0o,126 +onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/output_0.pb,sha256=HL5T46BD6dJDcU8eZMF5Lm5I4maShdEDBguWdgLux3c,254 +onnx/backend/test/data/node/test_leakyrelu_default/model.onnx,sha256=I1tKwPadbD9YaefW-ZBgElwp3GNleBeR8pzzGqi0PA0,117 +onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/output_0.pb,sha256=n198khm90YbTozNWp1IATonknkccZtYunsb6PRQA_hU,254 +onnx/backend/test/data/node/test_leakyrelu_default_expanded/model.onnx,sha256=pc1KytIHlwlrT6uSt0Aar9M3KrHiUadTpnjEmhAKaf4,996 +onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/output_0.pb,sha256=n198khm90YbTozNWp1IATonknkccZtYunsb6PRQA_hU,254 +onnx/backend/test/data/node/test_leakyrelu_example/model.onnx,sha256=4uswPgT5c4NX9AAy8k97e9wHTixFkyH3MI35Ea63G3o,118 +onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/output_0.pb,sha256=MY0cN1MP7gOByzkKkJceoWxHG-kwUcs4D8IgLgDgXdo,21 +onnx/backend/test/data/node/test_leakyrelu_example_expanded/model.onnx,sha256=HqNSxSkEqZ4H6f2T-afxoG18D1pwpNVVzgBZgQLHBlo,980 +onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/output_0.pb,sha256=MY0cN1MP7gOByzkKkJceoWxHG-kwUcs4D8IgLgDgXdo,21 +onnx/backend/test/data/node/test_leakyrelu_expanded/model.onnx,sha256=m3NuI8g_U_7Czdc9tX1bnLwAaSoohmMDg3cgl6gdock,887 +onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/output_0.pb,sha256=HL5T46BD6dJDcU8eZMF5Lm5I4maShdEDBguWdgLux3c,254 +onnx/backend/test/data/node/test_less/model.onnx,sha256=VarII_RAwHj31PsI-Pxtwxnn9uJ3impXIoeHdX8xupU,133 +onnx/backend/test/data/node/test_less/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_less/test_data_set_0/output_0.pb,sha256=oLRYA8-ghpFNYXX8_SU6S82c8LMGyLC3hcXpYcRAegA,76 +onnx/backend/test/data/node/test_less_bcast/model.onnx,sha256=iTJmFimcwmkhrembVS2cERHKyTfUr2y2cFiOo3AAbMI,131 +onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_less_bcast/test_data_set_0/output_0.pb,sha256=ISvgvc7TKhgnUzs1arbsFxBlMJnFlb3SSY3MxVCm2NU,76 +onnx/backend/test/data/node/test_less_equal/model.onnx,sha256=G7cUKwHYYg_vsrRmj_m_BQXHzgjG_OYxEGAdhDxDid4,159 +onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_less_equal/test_data_set_0/output_0.pb,sha256=6KQRJD-Zzbqgjq8LLBi1XYJ2HcB9SkzS4oPm8hDTT3U,82 +onnx/backend/test/data/node/test_less_equal_bcast/model.onnx,sha256=R73v6AOmEUmMTYS4DEzM6rgp89TErgdIpAzq3GcDdfU,157 +onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/output_0.pb,sha256=6OSOoce2x4z76WkKaCJFJbNncAEOkLSY8hY7Mp7kfNk,82 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/model.onnx,sha256=4ArSKpbhsIhQh51IyTmlp2jxRjtlRmWYhxJEZWDmhSs,411 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/output_0.pb,sha256=6OSOoce2x4z76WkKaCJFJbNncAEOkLSY8hY7Mp7kfNk,82 +onnx/backend/test/data/node/test_less_equal_expanded/model.onnx,sha256=jCJ-6W4caO1SFch4j0QbuPwSEd4GVRJHcwhwBGxeWKU,388 +onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/output_0.pb,sha256=6KQRJD-Zzbqgjq8LLBi1XYJ2HcB9SkzS4oPm8hDTT3U,82 +onnx/backend/test/data/node/test_log/model.onnx,sha256=cjzxxnA2vdNVbEX5HvAKpSmjYnWrEJoMDppGn_nVs6U,97 +onnx/backend/test/data/node/test_log/test_data_set_0/input_0.pb,sha256=h8CKUWP5FlTAgSDNi1yNwj568pm_N5ceqp_-U0ll_Vk,254 +onnx/backend/test/data/node/test_log/test_data_set_0/output_0.pb,sha256=pETp9F1Xftoyb5uzN-CDODSiMM1O3kKb6bqDTq8nloo,254 +onnx/backend/test/data/node/test_log_example/model.onnx,sha256=XVquiQ33XPpN2dX6vINv5rNtk-sTtg9bXICaZ2bPjwM,89 +onnx/backend/test/data/node/test_log_example/test_data_set_0/input_0.pb,sha256=0YatubYDmMpLjT3RWtFeMNO0bgyvikdU41tE6Or7TXw,17 +onnx/backend/test/data/node/test_log_example/test_data_set_0/output_0.pb,sha256=uhyyuENMdNx-nQ9styrIbgpA_f86OaR-2N7rPvmRBMk,17 +onnx/backend/test/data/node/test_logsoftmax_axis_0/model.onnx,sha256=VJwFm_Yn_uQ5JJ8u_eWlbgtiWZrtUi6NAPAsOJ8-AGE,131 +onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/output_0.pb,sha256=rxRI3f_tjrg9jlkJETIIY0Ezuf2mdi8sJVui7jN45os,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/model.onnx,sha256=YfCbAB070y4n4iY1Jd1GKDYl9dLoNDmQUPi6hfk3H6Q,1058 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/output_0.pb,sha256=rxRI3f_tjrg9jlkJETIIY0Ezuf2mdi8sJVui7jN45os,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/model.onnx,sha256=0xlpmgQ7u3QkgZrwjSAQKfoM_I0RCzyThOhRPHvS85A,1110 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb,sha256=rxRI3f_tjrg9jlkJETIIY0Ezuf2mdi8sJVui7jN45os,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1/model.onnx,sha256=ecVwQeM2qxClBhjEWUbOb2ag80E0M72V3PKfPoB107c,131 +onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/output_0.pb,sha256=y-ROhxTKXw_3lML2t7eeO6eumoUcDiK7HUCWDrM0zjQ,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/model.onnx,sha256=g5Dj4agZBHB5oYZpG5fDhDSzlP6r5eAnq7lclEn7XH4,1058 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/output_0.pb,sha256=y-ROhxTKXw_3lML2t7eeO6eumoUcDiK7HUCWDrM0zjQ,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/model.onnx,sha256=DFEInUgsiO7XfgcAXECqwsmPRs5vxeg1jMAy3drbkS8,1110 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=y-ROhxTKXw_3lML2t7eeO6eumoUcDiK7HUCWDrM0zjQ,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2/model.onnx,sha256=nshnXZ3VAXw3BDp8QNoyBWN8szqKSIfh2w6v5fuFMeY,131 +onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/model.onnx,sha256=MiHL1XMsKoyIm9MPa-EeZTOBmmIShCvteQR0igOGgug,1058 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/model.onnx,sha256=cWJhXBgARwv2HFpK0boBVxxbAB-uJqiRJEEYn6z9ZSs,1110 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis/model.onnx,sha256=W_xTO0KtwNOY1vT1hr9XmelZo54m6yXz4lPD4aNYnbQ,124 +onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/model.onnx,sha256=KlfdRLL8jlBhSlKlS-GX9L8nQ_gVqqH9Rm7zMQaDNZE,1161 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/model.onnx,sha256=wC2W2D5LPxEUCiGU9aAutzkUbr_SK4TJwRP35vfq6tQ,1210 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_example_1/model.onnx,sha256=0AlAWkvbmN5EuyqEmOQTqSwtUfKwopJz1z5RgxXbS9w,113 +onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/output_0.pb,sha256=0E88Sg_EHhUCNlKNOtJhRSD4YLju2X8tGUYcZ-68M98,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/model.onnx,sha256=BzlBt5Ku0H1N8HqQOwSqH8TgegEiWJ0uOTiXPpp5gmw,1111 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/output_0.pb,sha256=0E88Sg_EHhUCNlKNOtJhRSD4YLju2X8tGUYcZ-68M98,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/model.onnx,sha256=Fm1B-d4hmXuY6aIMje5xrjHpaj4QxJgz1_Vk0ZBG9to,1157 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=0E88Sg_EHhUCNlKNOtJhRSD4YLju2X8tGUYcZ-68M98,23 +onnx/backend/test/data/node/test_logsoftmax_large_number/model.onnx,sha256=gJWUGFTLCqc41krZNiUU9j2zySmHPqJK2ZJbgP5o0ng,116 +onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/output_0.pb,sha256=Sr55i9PgvLCs-n1Ew4mlUpnkhsgmu3BaizigOb_SFwk,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/model.onnx,sha256=byHDQ5CYCFgvkuFSiTxaETwHkpsasZMFBUfq1-AWUjE,1153 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/output_0.pb,sha256=Sr55i9PgvLCs-n1Ew4mlUpnkhsgmu3BaizigOb_SFwk,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/model.onnx,sha256=fXI6GvlhebnyoFrv0QPQ98kJQksjCFpjlYleYdUlnCU,1202 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/output_0.pb,sha256=Sr55i9PgvLCs-n1Ew4mlUpnkhsgmu3BaizigOb_SFwk,43 +onnx/backend/test/data/node/test_logsoftmax_negative_axis/model.onnx,sha256=eycSf6ZZu87Dr64zGxydYF7uwDJNon6U0YOxlJVZ5Ms,147 +onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/model.onnx,sha256=4URNtnb9AximMCbvDlR6JOkAot2n-0bqXA9aImyKIys,1175 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/model.onnx,sha256=ISmFRynfhw5CyXIuuuQKQRhZ7SIOGGuVD34vSDUCquM,1225 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=msG-YqFWPcBJzTIYQ7pC_R9R9WTqi6MP7WC-fm4Ysi8,254 +onnx/backend/test/data/node/test_loop11/model.onnx,sha256=NUlbusd6NPWkUocdEIyVtNhyLkrj8dNo-Jt4G1Cmv9c,726 +onnx/backend/test/data/node/test_loop11/test_data_set_0/input_0.pb,sha256=21JE-MBIhsvfmum8LEJZRp-Ye4W2jOC8yOKzQDWQeSg,24 +onnx/backend/test/data/node/test_loop11/test_data_set_0/input_1.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_loop11/test_data_set_0/input_2.pb,sha256=odGLrEmd0nK29vu1cr7vt82v8nFq43Ps-bhrbn3_7rc,13 +onnx/backend/test/data/node/test_loop11/test_data_set_0/output_0.pb,sha256=4ToJMgBIR2YxjkszwBk7SawzzOTz3WUAz8cgo_aEH0E,17 +onnx/backend/test/data/node/test_loop11/test_data_set_0/output_1.pb,sha256=4FgI1CLKyj4rzxQPcdL6YDctQ1tijp2ao1XFgbLEtX8,38 +onnx/backend/test/data/node/test_loop13_seq/model.onnx,sha256=X2_q1DMYFPlgKOXWtNil8nGpg77BOc5BTqwTOKNPeGY,735 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_0.pb,sha256=21JE-MBIhsvfmum8LEJZRp-Ye4W2jOC8yOKzQDWQeSg,24 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_1.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_2.pb,sha256=06j9wXmbVFTVecpbq-DEWVtWWQSzCcllrwnC--Jf54g,13 +onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/output_0.pb,sha256=zTPY0hjFSeAJ8JDXtLJ9RqaiGe3bkvi-kIZnICmmnrw,111 +onnx/backend/test/data/node/test_loop16_seq_none/model.onnx,sha256=qI0mQQyRbK_o6Xkf0p_SX-TsdIMCfm8SIktEfIJwNgE,1149 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_0.pb,sha256=21JE-MBIhsvfmum8LEJZRp-Ye4W2jOC8yOKzQDWQeSg,24 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_1.pb,sha256=OH775Ik9hGMBcOHijMYFq_DdWSSqgPdT-CZfhNjcOpw,11 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_2.pb,sha256=eJaYeF3jiE9xLuq2AoSHII-61tNtlFUkew3iRtmr60A,25 +onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/output_0.pb,sha256=9SLymmgUBDSk1J-jBePC9CBoLiabCczNkHDaJMMZzwM,121 +onnx/backend/test/data/node/test_lppool_1d_default/model.onnx,sha256=eZ94zxHGXJjX9W9M8A5R1BOzT3z-UmsGo57CSeAzkVw,162 +onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/input_0.pb,sha256=Za3StahBL7BbhQGm5tBIbmHL40mPVKMeoJms01DCbkU,398 +onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/output_0.pb,sha256=zs7RzbAqfv4nBOBDrk4T9ljczt1-lu_rzDcznI8szDI,386 +onnx/backend/test/data/node/test_lppool_2d_default/model.onnx,sha256=8POaI7nLcfBRgRb5Ehb93XIpNzeb2bEG5L81IJGORV0,156 +onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/output_0.pb,sha256=nhYIrtRs818qGeRFyl185QgEG7gCQfPdFmlYK7L_b3k,11548 +onnx/backend/test/data/node/test_lppool_2d_dilations/model.onnx,sha256=FahwMMQWbiZcLyAt-hf7mPfHOSjSeAAk_jrjvGzsjKs,196 +onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/output_0.pb,sha256=4a9-Q0pFJed5AhCQ2R01nG38O2j5TevoKwad9oslwnY,31 +onnx/backend/test/data/node/test_lppool_2d_pads/model.onnx,sha256=BONj-FtCLGFPUpqRfMLNKlVjKjP2utxDESkvfhfUeuE,172 +onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/output_0.pb,sha256=AsJ1Wg4_Ven9yPRn6Rj0e_-BIrAdDlGfPp01JgBfx8U,10816 +onnx/backend/test/data/node/test_lppool_2d_same_lower/model.onnx,sha256=P1FRJ1ql2Herm3URmFZC7HjlHhMXEPjIApV518vzj98,186 +onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/output_0.pb,sha256=37Fol-hh2swC4VufGVXZ7yw7E_W4rFTJhIcTENHf5Y0,12304 +onnx/backend/test/data/node/test_lppool_2d_same_upper/model.onnx,sha256=l3auNj5Udd_-copC8dLj3g7Ptiq2zuqKiHZcSLYO2Q8,186 +onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/output_0.pb,sha256=QIHS98H9r-Pvz4VM4cR7eYH6WUhsJdAomJkAnV3Dweo,12304 +onnx/backend/test/data/node/test_lppool_2d_strides/model.onnx,sha256=9qlwhLSX9ErP3L2AMUS5qJd0bi0oqrhb8iPHQ-O66WI,174 +onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/output_0.pb,sha256=BDPKhQX2BBLBEwyfV7s5KfL2ua_fmKJAKOaLe983ohQ,1216 +onnx/backend/test/data/node/test_lppool_3d_default/model.onnx,sha256=dXN3axvo21IAXIkTeiezdD7BUVOvH95iRYV7EHAMLTs,166 +onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/input_0.pb,sha256=L_c9P56CmA7WzPjy1TlkWrKgYm0YkeXEYxiPZ6VV1wY,393235 +onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/output_0.pb,sha256=6i0TyhC634cHG3TRMNQOmHsvHvFJzz5J6g1IrRxxojA,357511 +onnx/backend/test/data/node/test_lrn/model.onnx,sha256=2RmKdi_xdJKG2nQ6Sydr0RhKp9hx2sYugj0rrLJiwHg,168 +onnx/backend/test/data/node/test_lrn/test_data_set_0/input_0.pb,sha256=WTjaurAfJF9L9t73S5CfE2SmsNIVXuYgfYNgVEkypVQ,2516 +onnx/backend/test/data/node/test_lrn/test_data_set_0/output_0.pb,sha256=xdnB1rOmadLvzwf321Xc8uXA01Lyr_k6mac3gS-LQAg,2516 +onnx/backend/test/data/node/test_lrn_default/model.onnx,sha256=pLo59lyQp0avFhRmH_TiiS2qWXApwiREShuiL_3uuVE,126 +onnx/backend/test/data/node/test_lrn_default/test_data_set_0/input_0.pb,sha256=WTjaurAfJF9L9t73S5CfE2SmsNIVXuYgfYNgVEkypVQ,2516 +onnx/backend/test/data/node/test_lrn_default/test_data_set_0/output_0.pb,sha256=cxUk8-yvr-GWQUwRs5k296MxN76GuC3f9Ry4MYC-nhg,2516 +onnx/backend/test/data/node/test_lstm_batchwise/model.onnx,sha256=YlBIlwsPqPjo_z1dSVNgavYhwzivz_6IEq9lRh1xwKw,237 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_0.pb,sha256=X4Jx731skujCbqYlfE79v4ovLqbqAar9VfhQTegviw8,37 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_1.pb,sha256=OtNadmJqOUdzMif6TE-Lr_MvFZLW5uPxpNN307RTPqI,238 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_2.pb,sha256=4TgQIT8ZsnJmaBYxUhHn-MwfrldN0Nl5ubXhWUqr11A,798 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_0.pb,sha256=OTkQCUErjFkNHjBcm6xzsKYQ0Ihg5HMl5uSOi7oN-Rw,99 +onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_1.pb,sha256=5GQt1_4Z8Z1ArFiNEbzFUZxEAMVDr9AsjRXeAg1tiME,99 +onnx/backend/test/data/node/test_lstm_defaults/model.onnx,sha256=YYraEws0PGMvXwyc6jyGNu4GJxpY7sOvo5ARcygZ2dE,191 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_0.pb,sha256=CfdyEi1TF1qNXdr7S9ZjPY0_c7pWtxM7ou3bNl3fNIo,37 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_1.pb,sha256=TdJ94c4zwrACHQohXoMpgqyrwu4mcgsXbjFRuNlhp1k,109 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_2.pb,sha256=J0_sd5TU-GsTX-rbQovkFPVlVl7vgYypkPSUwo5ssZM,158 +onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/output_0.pb,sha256=lFvUjpPnQcNn5X_C-qFjM4CvBRwylGP0bgCPpFV9u20,51 +onnx/backend/test/data/node/test_lstm_with_initial_bias/model.onnx,sha256=7ckQkqxrwg1YaAcYM4rylKDnN8Md9MOr05cXOjbuC8E,224 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_0.pb,sha256=eujm2YGHVRU93EAGK-aPA-aFEublku2wP288wJjVc4M,49 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_1.pb,sha256=4nJnesA4ulDJrcu7HmldoPAKiHBRrrYEixxYzM93W8Y,206 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_2.pb,sha256=B_-IsKA8_GE6IY8PnBmwX9m6t6_3vdFJM9Z2dHMOHC4,270 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_3.pb,sha256=FWf6rrp6unNAWgeBMcpNQbQGnOLdeqkuEb3JpC0hKGI,140 +onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/output_0.pb,sha256=bnEbfd3S79ZtqIA_BeGIOrBw9dxm1KGb_czY6mtL6iU,63 +onnx/backend/test/data/node/test_lstm_with_peepholes/model.onnx,sha256=3EA-TGf7bLWpLmGO2FAtpvnhioklrKZEh2kzWniU_cI,377 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_0.pb,sha256=2OeoosrOatiTi0V9BOYjvhD88vWXbcfkKA6c20gxRr0,45 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_1.pb,sha256=YkSD-HUoRWHWy5VblSruzpovxbXfIx3hpt_ixzQtv1Q,206 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_2.pb,sha256=J0_sd5TU-GsTX-rbQovkFPVlVl7vgYypkPSUwo5ssZM,158 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_3.pb,sha256=UTQhV68H3RnHN8YKybJuSU0jokxWMdiPQJ8MvnNYS6U,107 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_4.pb,sha256=MkJoqFV7-u_t8_o6Y2rIguYZimj9D8eeb341jV847QI,29 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_5.pb,sha256=-V_w7_cGyZ0GDnxvC1kRRN6fgpl0cpKetpIig_LQwC0,45 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_6.pb,sha256=ZyP6k0P4yDzfvH4T-npTdIMB-DmtFmKrZbXjRhpq1MM,45 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_7.pb,sha256=o1t21DuNUncpuswkkA69WCsPzw0sPPeGbw4AO6heHEQ,47 +onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/output_0.pb,sha256=QcMlaZa8V3bViVMaUZ4VCqhpktnx3QHRL8mp2b1kUkw,39 +onnx/backend/test/data/node/test_matmul_2d/model.onnx,sha256=lG86Scz9r2JYa7roQ4Bl_kGn5qm4AGsUrzIZmZtJu3Y,122 +onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_0.pb,sha256=XJ-hOynTG0EF6hYsDK7MlRgESZsBa98mi49HC0BMH3k,59 +onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_1.pb,sha256=fZUNbWrynfo6yrjJ_N6nbVU8ERJAE7EG62YivA6_PdQ,59 +onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/output_0.pb,sha256=x5KLo-j-hQdpdMlVIAUywqJGlxGetUszj7x8Jjkijkg,47 +onnx/backend/test/data/node/test_matmul_3d/model.onnx,sha256=DSaZ3zVKvneKN1wcjZAH2WW5yjn7StDbbPU_zOA1lC0,134 +onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_0.pb,sha256=X2JZRe6Q-1UZLzTUnGefHdp5psiyGGbOZUoOU2PJJFY,109 +onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_1.pb,sha256=uNcHeZg62FvPXXLbAOIfP2JA-S0GbYLdWCPiOFju_B0,109 +onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/output_0.pb,sha256=Q2pR-WqVLQPaV8_iSRR_Yl4z_ddIBOA_7qJ72M9CFW4,85 +onnx/backend/test/data/node/test_matmul_4d/model.onnx,sha256=zvG_PFUSeYw4uirzowT8rtfUHmwcngKIpEpcxTaymq8,146 +onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_0.pb,sha256=BOQ_EXZfe_quR07HGszrPSBrS2-k42x1hH8FiMBFPAs,111 +onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_1.pb,sha256=6jox02jdTNxPHGwscLuIGr_GWZZhcG9iyOvRGH3Wlwg,111 +onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/output_0.pb,sha256=koxqNtVvc6ykaa0u9WWTchqTWy-WxdyQJYMV4-LdDUI,87 +onnx/backend/test/data/node/test_matmulinteger/model.onnx,sha256=80liWhDJ10RJr-RA7pL_LffuyFV9P-fu4u1J4QO6yCI,218 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_0.pb,sha256=CW_qu6MGZeHIi4xtdzFAE3EunQBARAnSpXpphiq4n3E,23 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_1.pb,sha256=Zi7ccul40b_4WbGzddk6zQxNcul5WpeybbqROgjR_fE,17 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_2.pb,sha256=n9w_0UFZSEO_KZ8ixK8FVb_f0hz4De5Q3qVfuoU90WE,21 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_3.pb,sha256=2QOpPgCU1uUvr5u3dTi6vhiiHB_Rp5lh2LZGrHlup38,21 +onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/output_0.pb,sha256=q285XbBU3WGQ67jFVoD_LqN-Zc_Fs5chpbtCmJh8mm4,43 +onnx/backend/test/data/node/test_max_example/model.onnx,sha256=uZcZ8DpvjVFEZwu03Aa3A7twKGWU6ZduHpPZOIYiN3g,170 +onnx/backend/test/data/node/test_max_example/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_example/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_max_example/test_data_set_0/input_2.pb,sha256=AIB1cbcFh3kj1j43N81kkDuwnI8-0qQyvmV-b-FJ_UI,26 +onnx/backend/test/data/node/test_max_example/test_data_set_0/output_0.pb,sha256=sJp2P7F8KKH4NdxwIWBG9p6S_EpBkKyZjvqeEH9hs1k,26 +onnx/backend/test/data/node/test_max_float16/model.onnx,sha256=PrWzBjjbzgVYz_zPCtTL1HpfXqW2njVwePab2C6gn8M,139 +onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_0.pb,sha256=XkpNeOliXBMqFxuPluFGL90YeFBKPQgFn1VCcdN0JTc,20 +onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_1.pb,sha256=PGuS9cFumaH9L8uba6S7fx1HAjkPixoPdhEnLzKsJR0,20 +onnx/backend/test/data/node/test_max_float16/test_data_set_0/output_0.pb,sha256=WubrX5BBksfMhnwR41XLC7FM_0k0Ilv6nLUrrDRyGFc,20 +onnx/backend/test/data/node/test_max_float32/model.onnx,sha256=tOJ-16c5LKcjYgoFmD7SSZ-3zsw5jR_1PcakIUGgEYk,139 +onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_max_float32/test_data_set_0/output_0.pb,sha256=E_wXnHEmLizJ3s9zseH5tQKuAokfDXYQ7so-RUpR2SI,26 +onnx/backend/test/data/node/test_max_float64/model.onnx,sha256=adsd71YIOGdvQR0grieRN8r5IWqah5goY0iXR9K9brs,139 +onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_0.pb,sha256=aYo1cyxhD5UJSoRB6MYQY5rIIODrGNSUJtchZ3acHIo,38 +onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_1.pb,sha256=ZVu4MYPV1wvct-Tk1Ju5kemkLyKfY1O7yyOxDXn3HBU,38 +onnx/backend/test/data/node/test_max_float64/test_data_set_0/output_0.pb,sha256=4oiQWJRtVlEw2oLoRfFsiwZOfTb3ABrE3kuqiC106sw,38 +onnx/backend/test/data/node/test_max_int16/model.onnx,sha256=aUD1AZjE3QcudcAaK6RHNWJW1Ge0YxEpkyJa8t1iTI0,137 +onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_0.pb,sha256=FJtiLllRWIS-a9GZyj5gx3m04341cxeH0urJ1Z68vfc,20 +onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_1.pb,sha256=PsSyF9rrkKuUygjrqNhdMCyZQCKu6RXs5lgH-MYow1Q,20 +onnx/backend/test/data/node/test_max_int16/test_data_set_0/output_0.pb,sha256=OGejQtNKbP-XeLonJgWAEuoOxN0YVuXhppnh8Wyd2Rc,20 +onnx/backend/test/data/node/test_max_int32/model.onnx,sha256=2fg800_ywUTwN8eNexg2EsRsLEHDaMCiJDxQWeV1_24,137 +onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_0.pb,sha256=oMt8bgYATqCj4PhzKh_oNtszKREjsNTuk5YwoMxWvHk,26 +onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_1.pb,sha256=dv4_C3z4H-aIoWXzNNmORQ6jQ1A2eaaR0CJVwTkSs38,26 +onnx/backend/test/data/node/test_max_int32/test_data_set_0/output_0.pb,sha256=kRy9ZYyhzDGeGwhqNnHQhpZ7-0MXIpwXqo8gSY_BF0Q,26 +onnx/backend/test/data/node/test_max_int64/model.onnx,sha256=9fkGP9GdQqsU3B7HM4sBXodpxVwO4x_MRv2pZ0jqmuo,137 +onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_0.pb,sha256=KjwVyx6CIaL3FdqxbpcjXEFaaGaO_Ru1yHutAcTm64Y,38 +onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_1.pb,sha256=fvapJViThkYxR2fL98GASrAg9vLpzpzDQsyrcHE0g8s,38 +onnx/backend/test/data/node/test_max_int64/test_data_set_0/output_0.pb,sha256=VycEHo6uFBG7JFssCyGxuXiyiRHCPeHzAukqVU3jMMk,38 +onnx/backend/test/data/node/test_max_int8/model.onnx,sha256=swSBQ_LLuz_5QhQTeYRZJaAPhoxSfnyQEnm56BGoY5Y,136 +onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_0.pb,sha256=wcyuFxX3kcHkurfMWEZ7SIbnKsYcn2OL5ybQBrJoGOI,17 +onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_1.pb,sha256=jMvP1oUjUx-YfHhzRx9y6TktJZrXCoGCA_1TqSRUVIA,17 +onnx/backend/test/data/node/test_max_int8/test_data_set_0/output_0.pb,sha256=MN1XN7VS9eX5ZE3BGlpy8uL0gGug-JVx67jOYzPoX8s,17 +onnx/backend/test/data/node/test_max_one_input/model.onnx,sha256=KE6w2WFpaTpjbAlELW2vIRYjuUSWK5usM_kZW10ORtk,111 +onnx/backend/test/data/node/test_max_one_input/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_one_input/test_data_set_0/output_0.pb,sha256=2zyDGx5VM6wREENPQvmSlNd-hsuWcMKvHDS30GC4txo,26 +onnx/backend/test/data/node/test_max_two_inputs/model.onnx,sha256=b0f8X9_6y9g7RdIRdWk7INpwxcEHb0jWe9njs5PNtk8,142 +onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/output_0.pb,sha256=E_wXnHEmLizJ3s9zseH5tQKuAokfDXYQ7so-RUpR2SI,26 +onnx/backend/test/data/node/test_max_uint16/model.onnx,sha256=gh5elrUdqR6TAE-9GLd73ezLANIdM5iVT6A49uy-cR4,138 +onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_0.pb,sha256=X-cnRcEYXi6OPoDAGivylhC6W0b97RiSbZYosOrTjyk,20 +onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_1.pb,sha256=LNaHLa0pYg31eVGgKD2j2_K0qV9p_04E7rwNwE58WIM,20 +onnx/backend/test/data/node/test_max_uint16/test_data_set_0/output_0.pb,sha256=MwEWUB-O9UEcFkKe1qFJ31bNOlYhbzMNYHkKuZeoKz4,20 +onnx/backend/test/data/node/test_max_uint32/model.onnx,sha256=5ss8IzMCUZIYRXZUvXDC2ytzjEYjYeWrChcyCtgAsY4,138 +onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_0.pb,sha256=GUldKT7G3azwH1ALqcSPzCRwnvYQaQYORo_nwdufOvA,26 +onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_1.pb,sha256=HxXkqFhIrH8fFY0dh2U29hfzGO_kE_47ahyZ9QH3oBU,26 +onnx/backend/test/data/node/test_max_uint32/test_data_set_0/output_0.pb,sha256=wJRLHAF8aMq0b6QMJ4nioLkGeZ7QN9h8U-YMkRo9AU4,26 +onnx/backend/test/data/node/test_max_uint64/model.onnx,sha256=twFkVgUAjihfUBCujVhIWcHk58B9SLDOTeIa963Y8fI,138 +onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_0.pb,sha256=URHhAcMIJ52W8ExjVsDmTYPLDu0cRKN9sXcoOPF6nds,38 +onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_1.pb,sha256=Kc229gfiuo2eKmyts9JJNXFrnA0U1sKhgM6uyban3W4,38 +onnx/backend/test/data/node/test_max_uint64/test_data_set_0/output_0.pb,sha256=6r1bXvn_3-S04qjHSshAQ-EGpXeZ01H-4Ii3WlAivm8,38 +onnx/backend/test/data/node/test_max_uint8/model.onnx,sha256=9xvgReV9iBBgU617ADLrYDh8X5aPZey_TcTGqPhtRXM,137 +onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_0.pb,sha256=d8-V_cmlfWKcdUnF5wYjohZ3PM7DtOeQaLO_BWcOZ44,17 +onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_1.pb,sha256=u_Ig9DtP5w3-ADv0CKHHwWzzexXoKKuQXHENbJNK8Jw,17 +onnx/backend/test/data/node/test_max_uint8/test_data_set_0/output_0.pb,sha256=4ijjUbkUJeRJUYuCQBu54lcJJsZEVH34jiQCzHBzZ0E,17 +onnx/backend/test/data/node/test_maxpool_1d_default/model.onnx,sha256=Ica_ck9iK0z2PAGUc2S94cyXFqBP-AQKLCcf9PWv7Pw,137 +onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/input_0.pb,sha256=Za3StahBL7BbhQGm5tBIbmHL40mPVKMeoJms01DCbkU,398 +onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/output_0.pb,sha256=ztthcPetAeoKY7HTdeVucMBBtGPI0tjx42jpBggsano,386 +onnx/backend/test/data/node/test_maxpool_2d_ceil/model.onnx,sha256=A3VRi6VRTkaI0wi_Xw-mmMc0twQQ-ImWSSKOS2L8njo,181 +onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/output_0.pb,sha256=BhWwtQ7jPUcvpLyfxmX6TehlXYva35_ohmw3Zjd4Hj8,31 +onnx/backend/test/data/node/test_maxpool_2d_default/model.onnx,sha256=kjsexTcdtUU-oREpJ9HsZI-8pHXriIB3dgTD398O7J8,147 +onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/output_0.pb,sha256=JsM1y5aj-I4KCDSIoohJxNtHERuuFh1BDJk7FagRyUg,11548 +onnx/backend/test/data/node/test_maxpool_2d_dilations/model.onnx,sha256=pG6syTutDItXnvxvElEVlvY3EAL7guLwyeAAdn_hoRQ,188 +onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/input_0.pb,sha256=wWnR5nCmHbKNWucpc2qwGWA_byviZxAN4EWpmBWxWjA,79 +onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/output_0.pb,sha256=BhWwtQ7jPUcvpLyfxmX6TehlXYva35_ohmw3Zjd4Hj8,31 +onnx/backend/test/data/node/test_maxpool_2d_pads/model.onnx,sha256=pQ8lgZCwgmiZY8lCKh9arfJJc5v_dCg4mtO5lBaehH0,164 +onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/input_0.pb,sha256=HFGpOb8k-_eSox3wcj8SOjH7WcbqDYrAaqiceZ_ZzdI,9424 +onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/output_0.pb,sha256=xqjyYXTRUlDv6gfMp9O3f_nmQTqOzwl31kYWzyocyA8,10816 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/model.onnx,sha256=-1tvv9xOnkTGpEB10W19BxAdJeKKEswMOeuZLRmC3aU,176 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/output_0.pb,sha256=BHyTkA2yfKPVso9bJ4yBq_7GlaexvNXyNEixQHDZfKk,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/model.onnx,sha256=AKun967BpHFPVrX9SxrEFpVlu1ziEgh-W1KEJiEO11Q,208 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/output_0.pb,sha256=NwkDSgVwZffOfc-RYMiB-T4Bi9cG3Hu6ckE1QL5KUOQ,51 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/model.onnx,sha256=aHJcqm9hHB6lDfmJRrpSswoUjBNl8ClJoOZVZOrYUBc,178 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/output_0.pb,sha256=uvNdXstYljuvnE014-jjf3-QdQ47ixmPovGW56jxeOM,31 +onnx/backend/test/data/node/test_maxpool_2d_same_lower/model.onnx,sha256=2lpm_yBrdHAOJDbbNUOM1ImQapnODjREJpKut7WV3gI,178 +onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/output_0.pb,sha256=uY9algpaX_ocBYHvZlcdg9ZIduWkiisEWHy-6ZF_cD8,12304 +onnx/backend/test/data/node/test_maxpool_2d_same_upper/model.onnx,sha256=YwQles_itOJm9q6XujHU7K7F9WQlnFKrnlCMQeboJTI,178 +onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/output_0.pb,sha256=3VZC2meFU8-OLnTuJM31Fm_TltaQS6RZEXBWSy-lo70,12304 +onnx/backend/test/data/node/test_maxpool_2d_strides/model.onnx,sha256=Dm7cd-yopY6-ubCzmXH7zvNww6Ppu9W0geE_whdcCQE,166 +onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/input_0.pb,sha256=Unze_of2KARaDBbo9Z3SVvlMUfaP1AUSekfdK0VNWoY,12304 +onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/output_0.pb,sha256=ydD0_CK6cx87T-WWLIm5fN5Y5FVnMjR3dqVLlDAkrkY,1216 +onnx/backend/test/data/node/test_maxpool_2d_uint8/model.onnx,sha256=5thf5Kmyvy4_0RdO-65xcdOAj4_4R7QDldBEOtHTngk,165 +onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/input_0.pb,sha256=3rECJgx1OCrUoFpmAiMYxDU35mjjrL9I1QJb0vTgL_U,40 +onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/output_0.pb,sha256=gEtwsq33uBnzsUvNyx84xTRk7AyduVLPFIMUBbzryas,40 +onnx/backend/test/data/node/test_maxpool_3d_default/model.onnx,sha256=a4GfZ3wd_kHRx-jZXlxF_-kHT7AbHOyaFNgFo_Qcva4,158 +onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/input_0.pb,sha256=L_c9P56CmA7WzPjy1TlkWrKgYm0YkeXEYxiPZ6VV1wY,393235 +onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/output_0.pb,sha256=_bML65YsBeYvjV6NIF53p3bWICy0g7hiTWhjfhv5K94,357511 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/model.onnx,sha256=2OHtcgNf_Mfv6eQ5NOSVXf9TydPHyLmLdV9qXOVz9VU,220 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_0.pb,sha256=BHyTkA2yfKPVso9bJ4yBq_7GlaexvNXyNEixQHDZfKk,115 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_1.pb,sha256=Dc74UT0aIeGqzqxQHRA5XIEuMc4LMA78gwdBT3gYEUc,216 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/model.onnx,sha256=LXWZxBBdo8Ho4BOQM0S-5k6PNVjTjSLIKkbaI6sk1tA,244 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/input_0.pb,sha256=OTlNmprtJOUuLYiDg3HHSwDSMZ9I07l2M5FcxdQLysw,115 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_0.pb,sha256=uvNdXstYljuvnE014-jjf3-QdQ47ixmPovGW56jxeOM,31 +onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_1.pb,sha256=ux7kfRW2OZDqGYUGfIbVRLuPOCkiwlShBxVO0syCvqA,47 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/model.onnx,sha256=hQLf8vbf8SQgSIshrsgdJ4zwjqfJostZ4oqV-HvI9_A,262 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_0.pb,sha256=v2Jafk_IShwMwa2Gew0QBJuJenG-XnnlkQktS0E-suM,32 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_1.pb,sha256=_Ho_y8dI0kAzxqDHfrdxQahOFIrlabEN2V3_9FrvihY,48 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_2.pb,sha256=DjgMaIl2oDbkGYsMWUYGn1-JTp6N9w_xP-ayKrmNEbk,52 +onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/output_0.pb,sha256=R33r1KeeZjicEOJg6Ib1Suhskf1qCU1s68adr1fqBhA,115 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/model.onnx,sha256=vWjlosFnheXRXuquF4d5Ua4QWOV8jZi2pSEgBUYB3S4,223 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_0.pb,sha256=6AsUaxumi7ZjpBxazO9ZJIE1HyGmav5abfKCoArXX_A,32 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_1.pb,sha256=_Ho_y8dI0kAzxqDHfrdxQahOFIrlabEN2V3_9FrvihY,48 +onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/output_0.pb,sha256=AsBxPx9tutDDcg5YVJB63RC9URcoMzdGfCiIj4aX-oE,79 +onnx/backend/test/data/node/test_mean_example/model.onnx,sha256=L0nI3wSlMT3WoBWPnGRvOCjwszB5AOmVQ9sfNALXXqs,172 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_2.pb,sha256=_PLxlJ7xl9XIGa6nbKkonHq25eO5mYsALw5JQS7zyx8,26 +onnx/backend/test/data/node/test_mean_example/test_data_set_0/output_0.pb,sha256=KG7ceFD_UsUNZYzkjIM8TFMO7G0-cmnzZLgXel7i9vk,26 +onnx/backend/test/data/node/test_mean_one_input/model.onnx,sha256=1XwAN1QuSDBuIxW8R6ln8m0SYjj6YA86i5X_5wuWO1k,113 +onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/output_0.pb,sha256=ZKhVafwrQna2mYQVSKmI2eivwdOVRllNuFJ0a3S4awM,26 +onnx/backend/test/data/node/test_mean_two_inputs/model.onnx,sha256=g00GzthG6o0H_aStXffMWED1rUw5J2kFr8pW9AqsoRk,144 +onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/output_0.pb,sha256=nqC_wFwz02oBVUimtu5pY2Nga3AVKriaEL7M6uMdyC4,26 +onnx/backend/test/data/node/test_melweightmatrix/model.onnx,sha256=b9l8xULlNZVrhxOduh7oVLNuVrdfPgNSyOL9Lh2rbGs,300 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_0.pb,sha256=NEPQIRs3FEL6UGqz8HzVTd0uBDI52jfUHtmsPDo6xh8,22 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_1.pb,sha256=I3E3ucT0v3A3C96bJeRt6VJerY7Vvo_1jYX-wFC1Xio,20 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_2.pb,sha256=riXIveX4Y4MT3-Xz3tvYXF5jNkOeUjLJDYNYzLhmQMA,21 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_3.pb,sha256=e8IILeTioZtXTnxsVBJEM_k9Uee58y2clJvgOuz_zmk,26 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_4.pb,sha256=RXrXHnMYPUVp0r__a6otNlGy9yyeq6P4B5YXO_47Ors,26 +onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/output_0.pb,sha256=sBNBK-d3RGC0wetdS2QB7w63nuLz04fTVQBV0AumZuo,305 +onnx/backend/test/data/node/test_min_example/model.onnx,sha256=Jl71j3_A-QdMP_yyVfKSP8ZONEAFXuO_sqCAGWkoKbk,170 +onnx/backend/test/data/node/test_min_example/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_example/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_min_example/test_data_set_0/input_2.pb,sha256=QpbKt69Jv0zAdktqC0_-h0v6bwKo1Uj7aPUx26Wv0zU,26 +onnx/backend/test/data/node/test_min_example/test_data_set_0/output_0.pb,sha256=NiybG918Px_YARZTv8xLcKeVMg4_DawQIjEP6N-3ax8,26 +onnx/backend/test/data/node/test_min_float16/model.onnx,sha256=7ZSX7Ps22Dx_ZYoC52rHlfMazBGQAIXt1odd1IyfKX4,139 +onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_0.pb,sha256=XkpNeOliXBMqFxuPluFGL90YeFBKPQgFn1VCcdN0JTc,20 +onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_1.pb,sha256=PGuS9cFumaH9L8uba6S7fx1HAjkPixoPdhEnLzKsJR0,20 +onnx/backend/test/data/node/test_min_float16/test_data_set_0/output_0.pb,sha256=RK5AMEDDe5TRXOuJSAaQBPF3jJPVwvGUmDrQl2mFR5E,20 +onnx/backend/test/data/node/test_min_float32/model.onnx,sha256=24f8iC-6SRbQWm-irEf-Pvve6NWJ45BCNk9OfzS-kxs,139 +onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_min_float32/test_data_set_0/output_0.pb,sha256=l4xYUpOgO-wd16dHDwhvlQnq3U_PRCoHyWTjTgDgWfk,26 +onnx/backend/test/data/node/test_min_float64/model.onnx,sha256=RY2IJ7_4rbMt2CTikHnyafV2QZeC3xeEPhMl7Hqn4Pk,139 +onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_0.pb,sha256=aYo1cyxhD5UJSoRB6MYQY5rIIODrGNSUJtchZ3acHIo,38 +onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_1.pb,sha256=ZVu4MYPV1wvct-Tk1Ju5kemkLyKfY1O7yyOxDXn3HBU,38 +onnx/backend/test/data/node/test_min_float64/test_data_set_0/output_0.pb,sha256=GEKafc3aNO_TQNdJae9RihD3K85Onv7GJAH9KyvLX1c,38 +onnx/backend/test/data/node/test_min_int16/model.onnx,sha256=NRHzzE2zXmhpkuMX8U8EqYxKCmV2X5lpKpr8-lbp8eo,137 +onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_0.pb,sha256=FJtiLllRWIS-a9GZyj5gx3m04341cxeH0urJ1Z68vfc,20 +onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_1.pb,sha256=PsSyF9rrkKuUygjrqNhdMCyZQCKu6RXs5lgH-MYow1Q,20 +onnx/backend/test/data/node/test_min_int16/test_data_set_0/output_0.pb,sha256=hASsoRQp3LTFS1EuynL9QOnLfVLX5MzZWo3ZyB7uMfw,20 +onnx/backend/test/data/node/test_min_int32/model.onnx,sha256=z-JDavbfz2-uoCSQQejk_o8NWsQDQblAjaL2QWVy5r0,137 +onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_0.pb,sha256=oMt8bgYATqCj4PhzKh_oNtszKREjsNTuk5YwoMxWvHk,26 +onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_1.pb,sha256=dv4_C3z4H-aIoWXzNNmORQ6jQ1A2eaaR0CJVwTkSs38,26 +onnx/backend/test/data/node/test_min_int32/test_data_set_0/output_0.pb,sha256=QOgWmBfpG2ZTFzEZ6O0QZQWkTyvU4ka4qkFLJUqBOCg,26 +onnx/backend/test/data/node/test_min_int64/model.onnx,sha256=XhaI6ewm7TosjMjsg3RNo_g79YobPtaFhbAVuc8Nll0,137 +onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_0.pb,sha256=KjwVyx6CIaL3FdqxbpcjXEFaaGaO_Ru1yHutAcTm64Y,38 +onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_1.pb,sha256=fvapJViThkYxR2fL98GASrAg9vLpzpzDQsyrcHE0g8s,38 +onnx/backend/test/data/node/test_min_int64/test_data_set_0/output_0.pb,sha256=qf27EVakskgj0Bv0aNtW4WJQrgME131LP74nHqx6MgM,38 +onnx/backend/test/data/node/test_min_int8/model.onnx,sha256=y3gjGQ2UzLg9LEU1Nr1Hkcee-zv6Q-JRgg5VcSKr-F4,136 +onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_0.pb,sha256=wcyuFxX3kcHkurfMWEZ7SIbnKsYcn2OL5ybQBrJoGOI,17 +onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_1.pb,sha256=jMvP1oUjUx-YfHhzRx9y6TktJZrXCoGCA_1TqSRUVIA,17 +onnx/backend/test/data/node/test_min_int8/test_data_set_0/output_0.pb,sha256=mVByJIahRHozMhvyDghT17o7iB2vYsDonWzby7nB04A,17 +onnx/backend/test/data/node/test_min_one_input/model.onnx,sha256=s8sXPKEgzYrTnfd6dJWh0rYujFVjIad7AalqDtrLqhc,111 +onnx/backend/test/data/node/test_min_one_input/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_one_input/test_data_set_0/output_0.pb,sha256=2zyDGx5VM6wREENPQvmSlNd-hsuWcMKvHDS30GC4txo,26 +onnx/backend/test/data/node/test_min_two_inputs/model.onnx,sha256=LX78oggqjZfNUGhN1iipvJTOINLQp7LIp6YWjRAbC60,142 +onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_0.pb,sha256=HJclva4-TFD98X2o011t-i_w7K5ow9hG8aJER5V_xN8,26 +onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_1.pb,sha256=2V5ZDb_t112Xa7JZY7c78huQL9pnJ4-jQGxtlvuagks,26 +onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/output_0.pb,sha256=l4xYUpOgO-wd16dHDwhvlQnq3U_PRCoHyWTjTgDgWfk,26 +onnx/backend/test/data/node/test_min_uint16/model.onnx,sha256=hDS6KkmbuOOKDdODax1bcXI9CCZD8cqfctQ4ok719bw,138 +onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_0.pb,sha256=X-cnRcEYXi6OPoDAGivylhC6W0b97RiSbZYosOrTjyk,20 +onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_1.pb,sha256=LNaHLa0pYg31eVGgKD2j2_K0qV9p_04E7rwNwE58WIM,20 +onnx/backend/test/data/node/test_min_uint16/test_data_set_0/output_0.pb,sha256=AASj0clqDfoUl5BuA9hzYSB90G5ESdetIgx2CjmGQcE,20 +onnx/backend/test/data/node/test_min_uint32/model.onnx,sha256=-Tpxeb4-r6EAeAhoKZdxYBXO_errt6m1nTLPm8VQtmk,138 +onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_0.pb,sha256=GUldKT7G3azwH1ALqcSPzCRwnvYQaQYORo_nwdufOvA,26 +onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_1.pb,sha256=HxXkqFhIrH8fFY0dh2U29hfzGO_kE_47ahyZ9QH3oBU,26 +onnx/backend/test/data/node/test_min_uint32/test_data_set_0/output_0.pb,sha256=7xTVNXY6HjeciLcJV6zdkMW0unSZrIrZn7nibEMoZV4,26 +onnx/backend/test/data/node/test_min_uint64/model.onnx,sha256=spJUPN6TOkif8NhqEN4XnSWOqEhSJ6fyUYdXNsMqnlY,138 +onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_0.pb,sha256=URHhAcMIJ52W8ExjVsDmTYPLDu0cRKN9sXcoOPF6nds,38 +onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_1.pb,sha256=Kc229gfiuo2eKmyts9JJNXFrnA0U1sKhgM6uyban3W4,38 +onnx/backend/test/data/node/test_min_uint64/test_data_set_0/output_0.pb,sha256=FE2KqNIEFUjpIl7oaUVxtvE_4BB019djTS7PGK4Im8Q,38 +onnx/backend/test/data/node/test_min_uint8/model.onnx,sha256=g8P4RJbhTlZYfM-uXsCrCLTzUHsvejgu4LYRx7AZaEg,137 +onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_0.pb,sha256=d8-V_cmlfWKcdUnF5wYjohZ3PM7DtOeQaLO_BWcOZ44,17 +onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_1.pb,sha256=u_Ig9DtP5w3-ADv0CKHHwWzzexXoKKuQXHENbJNK8Jw,17 +onnx/backend/test/data/node/test_min_uint8/test_data_set_0/output_0.pb,sha256=A08AZUxIdlvdVsUZwY2HJY7t-weOBX3f6n7noU2Uoh4,17 +onnx/backend/test/data/node/test_mish/model.onnx,sha256=tlcpsOd7XTlJMlypvI59-lgGWXBbILeDpOYOmv3-F6w,85 +onnx/backend/test/data/node/test_mish/test_data_set_0/input_0.pb,sha256=RV1aKvQqmlX789Wd5GM1iOelHOcq7mpK2AOc67HTnds,40012 +onnx/backend/test/data/node/test_mish/test_data_set_0/output_0.pb,sha256=R0fUL48TlUkZEKUOxuIziaLHj8Hu9_joVAA82El9Zh8,40012 +onnx/backend/test/data/node/test_mish_expanded/model.onnx,sha256=8t9m016_0LoMctl5Opjg7Ne38xazAVZxkI65R4Y_95E,309 +onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/input_0.pb,sha256=RV1aKvQqmlX789Wd5GM1iOelHOcq7mpK2AOc67HTnds,40012 +onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/output_0.pb,sha256=R0fUL48TlUkZEKUOxuIziaLHj8Hu9_joVAA82El9Zh8,40012 +onnx/backend/test/data/node/test_mod_broadcast/model.onnx,sha256=UZosTR7ILJwdb-R8mjUh0dV6Yto8ml7Hs9Y9Qsc_VoY,127 +onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_0.pb,sha256=3qcX3Wo1hXBUsLziRjzEWPSLBxAIkA6VkDFfdA1ODMU,133 +onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_1.pb,sha256=lhpCdi7Z7eKMpbL-r8ctfPGvcP5tqKpCYNwyvTL_R30,13 +onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/output_0.pb,sha256=XH7PNJTdEM2rYc6l2D7GV682V_c2XKf8T5IMzZ1_esw,133 +onnx/backend/test/data/node/test_mod_int64_fmod/model.onnx,sha256=Sh2X6OdVI6ekT4fRR4TRVhNxnSh_qOfb2D1XfiEzjLM,125 +onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_0.pb,sha256=nOKhA4S_k4oLRRJtc_sBIsbaabKM4Kp44EPsTtGDZhc,57 +onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_1.pb,sha256=flHpVhHA6WGEfMmq0TjdhZcLKpScvTBl45zZ8KCgQHU,57 +onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/output_0.pb,sha256=wyOpSZFx-PejmYFgPDzyIxKN4uk7JQ9whEwb-YUuZts,57 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/model.onnx,sha256=gto1zqyjHBJAoruIoES9llZMP-VflH0elbJ6k0Sgcg0,133 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_0.pb,sha256=MVkaogxKWSWLKCwAWIYIK6ka31cTnE5k7AGtluEGF98,21 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_1.pb,sha256=v0Ok1u195wYs7KWZpMK_-kRpCU-kJEdKLi2dkVWPFWo,21 +onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/output_0.pb,sha256=XoZwwT9Mq8IIe68Fvh9txJxngP333hN7nptDt1NxAS8,21 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/model.onnx,sha256=fyl1SXwq0Ep0mmmnPCGwg585zjCQ9bT6D-6OHz4Fglc,133 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_0.pb,sha256=QIyPABIKtekKty_eC1fS4BQXb9SAfOc95d3C-hWuOaI,33 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_1.pb,sha256=TlfuxHXSKKO59_3ot-9_8TkSOEghBMa1JttpvwE_9HY,33 +onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/output_0.pb,sha256=fThMIPzW6l8EFZIP-cjpRxJ_5SA5LPFmB2iBDgr3aqs,33 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/model.onnx,sha256=ukr-kauED-l7VCdewRDZxkC7WrkJPUbtnobG1U6jrHs,133 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_0.pb,sha256=jsA_RIDwWdbwaf1pa-Eg2TOKQVSW-InXqUAGRGoIgtI,57 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_1.pb,sha256=ZkwMjo9QFC5z4WWHXnidDvETp_Vg7HxYH8IW4QH56-M,57 +onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/output_0.pb,sha256=LAlPMxtTz5ncBIakv4KmstJhSW3IVxQuauGbzWqk2GM,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/model.onnx,sha256=MGsxSYQNbI0OQCZFNRF3E0pv_T0KeHIVaEMF6U4bOUQ,118 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_0.pb,sha256=UEIoI4Qd-kq43WszIVwerQdDc-kCz1SdUQlJdigMHec,21 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_1.pb,sha256=AjsGow0MFJSwTd9jddqniDZA4pk1CiWh-vgZt-Egfn4,21 +onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/output_0.pb,sha256=jv4-0meAPqn4mynSfgFV1NNOq3UKKsgeM1to4cDxn_4,21 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/model.onnx,sha256=PgK31M04H60Q5fcHtpoaQKj-5wiRoDBkb3eVLRr04xM,118 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_0.pb,sha256=giEjjHtUYRpU_BEU217_pCgE_OEA3y9ZleuAgN-typU,33 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_1.pb,sha256=22wYw0JM7tNQ401SFLtgGcQ-ne90tvpWWTReoytj7Bo,33 +onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/output_0.pb,sha256=_a4Yjx7uvnZPG-TkIb341yGjdeliR--d3Fu5Trgxpho,33 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/model.onnx,sha256=nTw6OR_BMSC0Y_JjnrTnr5BXwUOMJ9tA9B9R1VljY2Y,118 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_0.pb,sha256=nOKhA4S_k4oLRRJtc_sBIsbaabKM4Kp44EPsTtGDZhc,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_1.pb,sha256=flHpVhHA6WGEfMmq0TjdhZcLKpScvTBl45zZ8KCgQHU,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/output_0.pb,sha256=jnR4bDtZ93G6nMkj2CAaTaWk0UxaTaA5AonWF1KjDKY,57 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/model.onnx,sha256=CC0VBcKcNW2g4-82riqZy2byWRYIeaE4Xs_SIfdtBSQ,117 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_0.pb,sha256=e4SdPaUz7v7WV4GqACVkvDDWv3VVRGyh6zY736g7Avg,15 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_1.pb,sha256=QWRmvzgxJcXKMTv1vhMCT_n4SZgHtga6NLK0sm17tH4,15 +onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/output_0.pb,sha256=3dXZkOSPNjX9Qe0FFIjUZ9sYNqJBrpeBuDRK9z1gwYo,15 +onnx/backend/test/data/node/test_mod_uint16/model.onnx,sha256=alKlDqYYFEBTlxoP_KUnA0ujiOdmDAPCUpPlN4hBM2E,108 +onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_0.pb,sha256=tCsmCRMblNFjQrp58dHq-WdUlovdrwQtDw18AEeCa6M,15 +onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_1.pb,sha256=2LAcmWXmGxfnOGwxfznTysJ_tjFk5VK8q_Rr7uAaWL4,15 +onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/output_0.pb,sha256=MKxPEomEIEe4a3G8KHviE6UTv5yi-EfSi_IFkqHypkI,15 +onnx/backend/test/data/node/test_mod_uint32/model.onnx,sha256=MukL3eMwWSctzgKqJFqFkmQdbAVYtzx94H5sVfPcs9M,108 +onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_0.pb,sha256=RMNhUhYgBTdqxllQCSq5-7jdbrhadyk-Y67u6inphCc,21 +onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_1.pb,sha256=CTViFOfkAPQBZePJI7qcH3xxx-o60oHKZ_Ke-zJVidc,21 +onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/output_0.pb,sha256=6ZpnoFc5CJba_bTAYvYaZLlfHn2oYWn5z16ykLEjYCQ,21 +onnx/backend/test/data/node/test_mod_uint64/model.onnx,sha256=RkACaHHi03wcrloxfUcHz1XxirhsdUkmpyGYR0D09Qw,108 +onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_0.pb,sha256=ntDx28CL_G8v9dPpttRHXJ8h6FsFGA0GNQipBt-ouwk,33 +onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_1.pb,sha256=4NWx2-tUm-ZC_B5WjZqZzVwE9MdhMRRt38ohiDV6WjI,33 +onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/output_0.pb,sha256=1V8VuyVx0lcS2Df0tt-JrILo_d95XKV4ksyO2OV7ZM8,33 +onnx/backend/test/data/node/test_mod_uint8/model.onnx,sha256=5qmvMgMmlxRslaSdJSYy4VqUhnPZAHEC4h6l6vB8Pjk,107 +onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_0.pb,sha256=hDHI1DHkbLpXzkvBdwdVqa0ReVZMhcpGiIlhep4W9YU,12 +onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_1.pb,sha256=slzwobrbN-njwaehacvZjMt6LUfm49Bl_dHEOCuB5ZI,12 +onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/output_0.pb,sha256=QiipYfVIuwPVRtPVyMv5lZN-q2JuQys4ocuT4c3dCZ0,12 +onnx/backend/test/data/node/test_momentum/model.onnx,sha256=-5oApOVFhBs0bz9FDBG8ldvVBgrAhU-avnjryfajF6I,333 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_2.pb,sha256=q6Wsydvsci5ZJNiqDej1Kq17QzS3xOPWEruuLIgoorQ,17 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_3.pb,sha256=NQkKr3rClZp31gGf1Oyh_ECrr2_5AMVYn_fNdDazT8U,17 +onnx/backend/test/data/node/test_momentum/test_data_set_0/input_4.pb,sha256=6upGRVU5-O-5zKXoDu6cRsc2F036k6N02w_CNPHBGqA,17 +onnx/backend/test/data/node/test_momentum/test_data_set_0/output_0.pb,sha256=1cxy6HxWJTlaTZSXXWCoR56T9BWkUpKG7saLuYwgXyc,21 +onnx/backend/test/data/node/test_momentum/test_data_set_0/output_1.pb,sha256=Ci12duo6EDJXkQplTj0GZH3T5xTG-BDRHfUN7eIaR0M,21 +onnx/backend/test/data/node/test_momentum_multiple/model.onnx,sha256=5h0MIOkr-byri8c8cozhvIeSHzz5mfmTnFt7uOclUvk,478 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_2.pb,sha256=zSCQaDJuSfjV89lOKl_e8FAvaYdDg6UrH2n4eykC9bI,14 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_3.pb,sha256=A-40FgJNucPNFb_WksbMy0Z-E_EIV7RF0DP90kqbbC4,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_4.pb,sha256=CxeZGajewrwPha-MBoCdOi3nXJYzF9DgbGhOIwIqx3A,14 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_5.pb,sha256=stCGvEbBW8itgJbkRX1pnKZir080kytSIuTmZAkh41Y,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_6.pb,sha256=1-flVrzPmKolD0GSh-ld1wYZxSEIUx0TUpi_0ywedqA,14 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_7.pb,sha256=elUimbVps7sroUEVgzsr7m7OElV1YF29zVkzYA0YS-s,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_0.pb,sha256=4sSVWd8Z9X1CPKfShQixSU6j1XAuHKwTbI1HDWDK05c,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_1.pb,sha256=VIx5aXfPMBO-XRc7JlxZvj1LRnOeikNDOmR-uqHntzs,22 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_2.pb,sha256=QpvgrRN5sklswqZAtEjKXsjjnjKNTvmEd8eJz4v8VQc,18 +onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_3.pb,sha256=y6bsm396HxD86Z8Gx4SrXpBeBLu1t4YviYpxT9Zp3Bg,22 +onnx/backend/test/data/node/test_mul/model.onnx,sha256=ZuS6sRZvUEzjJgVPrTahZSjon8MxxwR7LmtefNnB24M,125 +onnx/backend/test/data/node/test_mul/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_mul/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_mul/test_data_set_0/output_0.pb,sha256=GvmV3GKzE3tMQaUbtsliIf7YaUyHtSitkjeF-u4Qptw,254 +onnx/backend/test/data/node/test_mul_bcast/model.onnx,sha256=FmrNZbakJHVt0sk6JDgHNkK08Xla6MrTE3U_qv0LntY,123 +onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/output_0.pb,sha256=xVi0Xf_iQ-yNWQKzRUGY86LcvRmnwTV2W9U7iPvAXyc,254 +onnx/backend/test/data/node/test_mul_example/model.onnx,sha256=BbkaFyBUf7-QS7ZH0F3kuoLpjnMhMWXxMFYZ8nTaUU4,109 +onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_mul_example/test_data_set_0/output_0.pb,sha256=tVxYlgVT1AqY2a1VMrqOyiLZAn9wRBDCh7Fdffib0uA,21 +onnx/backend/test/data/node/test_mul_uint8/model.onnx,sha256=D6fmj7leZM-7NYYKX7rKyNcmRryGvdyndMqlNnBrIhM,131 +onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_0.pb,sha256=lDVrTjZITNWkVtasiKIF2ak3tbuhepNRhxrgudf0KTs,73 +onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_1.pb,sha256=jx9eQGpCxoKBWgfPS0KfbG40pw6mS3ewQqDH5ksDHls,73 +onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/output_0.pb,sha256=y8L5yIKZz6xnyDczj7pFRWo1-I21Bvn-HMVwXU_h2QM,73 +onnx/backend/test/data/node/test_mvn/model.onnx,sha256=epvYrtzDMGUCQaTNZrsSaaJv6sj4Z93jWBiIdkZuTtI,127 +onnx/backend/test/data/node/test_mvn/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_mvn/test_data_set_0/output_0.pb,sha256=E83O-chiuVDaVh2K4dg2eJ0Xg40h2shNgDjy6prT-mQ,123 +onnx/backend/test/data/node/test_mvn_expanded/model.onnx,sha256=EZuZmf6XgC8sidl6q5Uf8Gvse-2rTXU8dX8ZeGGRpiQ,1714 +onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/output_0.pb,sha256=E83O-chiuVDaVh2K4dg2eJ0Xg40h2shNgDjy6prT-mQ,123 +onnx/backend/test/data/node/test_mvn_expanded_ver18/model.onnx,sha256=GUDLfw0FyhbNGi6k2wyaZMfyk1GuZYJD5fwIZjhUDrY,1901 +onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/input_0.pb,sha256=JgQmvqlXl4zwhOoqE3bqOj-0uikQHKd2j0Gt1aMhG3Y,123 +onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/output_0.pb,sha256=E83O-chiuVDaVh2K4dg2eJ0Xg40h2shNgDjy6prT-mQ,123 +onnx/backend/test/data/node/test_neg/model.onnx,sha256=RG6cCaIqfUQ34xlba_AMQOwsIBnpTHgEE4_2K3bWURs,97 +onnx/backend/test/data/node/test_neg/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_neg/test_data_set_0/output_0.pb,sha256=Ts5Na8UG6-tCk6szO_WjtcUAMMIPYVYm3I09yt3IuAs,254 +onnx/backend/test/data/node/test_neg_example/model.onnx,sha256=1xGuNAOWCh8G6u2QwbF8-n6qtNrao0AvKJ70iKtMX0s,89 +onnx/backend/test/data/node/test_neg_example/test_data_set_0/input_0.pb,sha256=hIDv23oySvd30UHcdMkH6btwYls47z-2HWS1hMB2wdg,17 +onnx/backend/test/data/node/test_neg_example/test_data_set_0/output_0.pb,sha256=4EW4AVpPlfhx4g9wwktECbBn42vmT0mhx-eztsZhymE,17 +onnx/backend/test/data/node/test_nesterov_momentum/model.onnx,sha256=0PJxU7A_pXiJUQYJqlEwQhgUz-7Y4D-K11Y6wItheKI,342 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_0.pb,sha256=CxMIfRjPZEo5uxAaZt0Go3_5W6wA6Dv71f9iG1FoqiI,11 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_1.pb,sha256=xEpBjafU-CYCl1V5uhzdqP2rUfBgaj7glskxTqDGi-k,15 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_2.pb,sha256=q6Wsydvsci5ZJNiqDej1Kq17QzS3xOPWEruuLIgoorQ,17 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_3.pb,sha256=NQkKr3rClZp31gGf1Oyh_ECrr2_5AMVYn_fNdDazT8U,17 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_4.pb,sha256=6upGRVU5-O-5zKXoDu6cRsc2F036k6N02w_CNPHBGqA,17 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_0.pb,sha256=78D4vxBLlg3_1l7fVOJsUgiud1GhCpYye_F23yOxGfQ,21 +onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_1.pb,sha256=u3TIKVQhJ12mswy7LJAMitidrIrQwfmHZc95LItmh38,21 +onnx/backend/test/data/node/test_nllloss_NC/model.onnx,sha256=k9wuaUyG4vqUGdOasux7BAiNAWXsS-HRQ8Rw5SXZ7TI,181 +onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_1.pb,sha256=4CX0ut_YErV-LAF0q3XBesrAedTFBSOEEoLncdkhSCo,38 +onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/output_0.pb,sha256=FzPp1aOpi6ruhclBnofi7t6rPu1JBh__2nUlEKB8jRg,24 +onnx/backend/test/data/node/test_nllloss_NC_expanded/model.onnx,sha256=oVgjxEzxZOPMU9_sFPezyzxZFhp6u1bsSCH92XGha2k,1487 +onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_1.pb,sha256=4CX0ut_YErV-LAF0q3XBesrAedTFBSOEEoLncdkhSCo,38 +onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/output_0.pb,sha256=FzPp1aOpi6ruhclBnofi7t6rPu1JBh__2nUlEKB8jRg,24 +onnx/backend/test/data/node/test_nllloss_NCd1/model.onnx,sha256=BBF-XfZL4KxoptstuVpwnLrKg9aS3GejJTE7ygSD7oQ,187 +onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/output_0.pb,sha256=Wy80hsUPrWr21jyHz00NtQPKFLFbm9jkiMOVGrkzYOM,14 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/model.onnx,sha256=pT81kC4Y2cO4C4ymweviL6GJVxKLoPzcVzDIqQX6IBw,1702 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/output_0.pb,sha256=Wy80hsUPrWr21jyHz00NtQPKFLFbm9jkiMOVGrkzYOM,14 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/model.onnx,sha256=JtRnrOytz9VvC0WEpD9C42I4WZXvdvSau99Jx4SShq8,211 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/output_0.pb,sha256=mvZzSWz0AU3Qvv7pm7RZtTx91YugRDgGdDqN4IjfhRE,14 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/model.onnx,sha256=azLZlbzUqCzx2WGHZ2NhdpBVKzlToR8eZcttjg1s-F0,4799 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/output_0.pb,sha256=mvZzSWz0AU3Qvv7pm7RZtTx91YugRDgGdDqN4IjfhRE,14 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/model.onnx,sha256=_SKEOgXURs-d05J0uofV5nVrvyK28SlJP1AI4R99iFg,271 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb,sha256=EV-DL1xuw3Ssoc13Ru3vNTP97mPKvc4FanaWAaurb30,378 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb,sha256=jCgGbI3X6Kh1LiIy-D1u1T83sddtcdLsgSGGSfnxv34,161 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb,sha256=2pdGNpbiJ_sObKTCzmn5NvpYSnz7nmZf6k9pSWyaiyk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb,sha256=xVxmU46seyPHXo5LO5_H1OTgdz4paTCSI5_vP1GO3rY,14 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/model.onnx,sha256=eFqDQXZs2jCOK35-_sZbmxoUaCCCf4VH5tzFjpDUNQY,6057 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=EV-DL1xuw3Ssoc13Ru3vNTP97mPKvc4FanaWAaurb30,378 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=jCgGbI3X6Kh1LiIy-D1u1T83sddtcdLsgSGGSfnxv34,161 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb,sha256=2pdGNpbiJ_sObKTCzmn5NvpYSnz7nmZf6k9pSWyaiyk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=xVxmU46seyPHXo5LO5_H1OTgdz4paTCSI5_vP1GO3rY,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/model.onnx,sha256=chgwfvx1L7zLJdzVZGzzFStfkrodMNRwUpVqEcGnODc,224 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/output_0.pb,sha256=VMqJ-Ig4hx6FdES7_UNH17eu-1_iOnoQZdk5N9VOgKk,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/model.onnx,sha256=tSLBSPP-84mbZROlNAFPRntvG541XvV4ocn-j5a15uM,2696 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_1.pb,sha256=TxDsHYS2QuW7G4Ta0rbBDixXELufO1KTJTJKsj5PDh8,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/output_0.pb,sha256=VMqJ-Ig4hx6FdES7_UNH17eu-1_iOnoQZdk5N9VOgKk,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/model.onnx,sha256=0i2ax35T04SSaY_zKFcEXWutZuP9fw2-C8_xmMVZ83A,248 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/output_0.pb,sha256=8_UkUhjk3o7HpAwm_8qujCN_005PKGId3cvF1VYaCTQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/model.onnx,sha256=1bYMav1I-YQjA-mvde3-GlufskTDZ0kRSQ03YBk3eJk,5288 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_0.pb,sha256=Y7fKVXkDFZWQMad8JysQ8iP5c3_MKMk6RACAU-4HTfI,137 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_1.pb,sha256=Ur_oz-w-7AwpWPcD7rOje_KVu5kEOh8mhVS8xvWexXA,64 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_2.pb,sha256=7DDbvKGGDdq188bMvD_LwMlrhgJmPpCuh6-TbVZJglk,34 +onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/output_0.pb,sha256=8_UkUhjk3o7HpAwm_8qujCN_005PKGId3cvF1VYaCTQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2/model.onnx,sha256=1sYM_xrJw6DuaaweSKCZyKivC3advgOBU1nxoXAANsI,209 +onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/output_0.pb,sha256=i2iYMamczG-7HCsEJauZO4tMxXxOii0ei0TGmGaTimM,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/model.onnx,sha256=NfgOlvNOYP_ooJgeBEZwp_vNS2vg43WI6uxYNxRrrqo,1579 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/output_0.pb,sha256=i2iYMamczG-7HCsEJauZO4tMxXxOii0ei0TGmGaTimM,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/model.onnx,sha256=ued4Hm19VkYsOFUK_EZwYy-EdhgraMSRnvUN1XtsD6o,246 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/output_0.pb,sha256=hSGnu1TNFV4r9LcNJTndtBoNX_1GblNESfOk-W2HrLQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/model.onnx,sha256=2sUj1G2s_CorrTH1oQB9wsQ9aeJNZi7uxVyAt5YfneE,6244 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/output_0.pb,sha256=hSGnu1TNFV4r9LcNJTndtBoNX_1GblNESfOk-W2HrLQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/model.onnx,sha256=WhjQvu4HNTpdmXKYeCF665Njs0wi3zI2-fbJxL-2KZQ,212 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/output_0.pb,sha256=qSq6WlgazeDCIm1mTyLxUKhzYL5DcoLCqbHb-BXtdAM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/model.onnx,sha256=X3zd_AXuTxG5E9V3pPosriKKcqq7XaB6ieoUql_3Vcg,2033 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/output_0.pb,sha256=qSq6WlgazeDCIm1mTyLxUKhzYL5DcoLCqbHb-BXtdAM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/model.onnx,sha256=Q0glDHkUuBJv3FfCzBtylxEHBoafQ1jx1F7I-VVeIxA,210 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/output_0.pb,sha256=x1AM6O_evyx9hb1eICxW4zTGdItDWz9rf-65meUkzCM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/model.onnx,sha256=fGcWHO2ULrCKPBiCitaaniXeXHapQK_57w5gF6IkkoE,2013 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/output_0.pb,sha256=x1AM6O_evyx9hb1eICxW4zTGdItDWz9rf-65meUkzCM,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/model.onnx,sha256=NJpYNKc_dKkK2LxipaT2IdVTz2WKKWZhQ1DhcWnTLUY,251 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/output_0.pb,sha256=JSqPDGiOsobP6xup-vxOXxOSOJTnn6J3C0Z4VCboW54,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/model.onnx,sha256=GEgEGirkeM__zc31nmNNNY1y-6AsaYmLwDMBy0m0rfk,2211 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/output_0.pb,sha256=JSqPDGiOsobP6xup-vxOXxOSOJTnn6J3C0Z4VCboW54,449 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/model.onnx,sha256=r5ln075G2yIhyJQlk3PFmAN-YO3z708FbKu35HbHXOY,254 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/output_0.pb,sha256=Y2jLiaibOR3bdOa9HsLCodhKnjvPmkYX4oUXLJlpg7Q,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/model.onnx,sha256=zFnBrMN4Un0uquM2wpsyJNYG98h3aWW4DAmGy9KhDzY,3324 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/output_0.pb,sha256=Y2jLiaibOR3bdOa9HsLCodhKnjvPmkYX4oUXLJlpg7Q,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/model.onnx,sha256=9Hj1soS3_ZubUoKxZv8nr4V11M-cPuoPefooNsQ_DTU,252 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/output_0.pb,sha256=ttk6qgLV4PrBOJwBA0MNagYSn2xbblmFgdT5G4Y6DSo,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/model.onnx,sha256=VxEpAEiKzOrH7ZaTnJI1KehBctZIaBt4k6A8uj0yuuA,2730 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_1.pb,sha256=Ze7CWNk2I2nyDVtw4aEqkvKfchvRITCMQlg1iMQTqPI,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/output_0.pb,sha256=ttk6qgLV4PrBOJwBA0MNagYSn2xbblmFgdT5G4Y6DSo,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/model.onnx,sha256=7eEbvlOB8Q16vcAlutJ66OeTSkpOYPNMUfDMRn-QoNY,276 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_1.pb,sha256=t37hGGOZpY76Z076TWnyUXHJ9RhjExXsTMzsFDongOE,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/output_0.pb,sha256=G1tuk8Dm8zZmN2j-1zlY1fE7Dhiqg62AePzHDxzw9Vk,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/model.onnx,sha256=uxWTspWFWjnXaTYEYFdTNQ3hHg8U4dpUhabJuDjT3rc,5854 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_0.pb,sha256=-hNsEYq4QMPiZ8vIgKKttbbEJpcJ58FgVS-Bzh0VRY0,2180 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_1.pb,sha256=t37hGGOZpY76Z076TWnyUXHJ9RhjExXsTMzsFDongOE,883 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_2.pb,sha256=LXGbi9KzO_VgKlKgxnnFfqBGcYMX6pKqnQCsK7rip2w,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/output_0.pb,sha256=G1tuk8Dm8zZmN2j-1zlY1fE7Dhiqg62AePzHDxzw9Vk,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/model.onnx,sha256=aGnx-ACxAObbXX1-FTiwAEV-PlY0J0IB4pAL0FdZlCs,280 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb,sha256=z23LiYXVLuyr6YhOh59dhvGqVqx8aoJP7eOh4qE51QM,10822 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb,sha256=cKLm3K_3JxpfYsG4am6zDDJskYvJQbVzjuENYNBUkpw,4341 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb,sha256=S_h5iqr0rOuKrKp6BbeSJ3fJ-2kKAljKD94lVeL46Wc,2179 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx,sha256=jYR1ngpcN28t90XDR4WuP1Sl7BSAMrUv4YNoJ8_dWek,5510 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=z23LiYXVLuyr6YhOh59dhvGqVqx8aoJP7eOh4qE51QM,10822 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=cKLm3K_3JxpfYsG4am6zDDJskYvJQbVzjuENYNBUkpw,4341 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=S_h5iqr0rOuKrKp6BbeSJ3fJ-2kKAljKD94lVeL46Wc,2179 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/model.onnx,sha256=Pakdemg0frIEpUOxbNd0yTFCShGCoUPTzt3i_7y9HHk,252 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb,sha256=RXI-xC4uNH5h_9bRIqFZxVMyWsu6CV5b0pbQecU4Bgs,38 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb,sha256=Jm5nsejoZUXJLQiQBzP-LlZ0LpN6o5WgziqWVVxouXg,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb,sha256=nZ7GyTo8pI1otqZg8N04qEXGK8KMRoAVsVCuNp6KZKs,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx,sha256=VKl8WWNMlOMsMw2OraymtpuZkDulF6radt80AhXTw-M,5445 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb,sha256=old7l3-e0xBCJ0lTuYT6UfvHSpi0zYXGQc1FsncLpIg,75 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb,sha256=RXI-xC4uNH5h_9bRIqFZxVMyWsu6CV5b0pbQecU4Bgs,38 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb,sha256=Jm5nsejoZUXJLQiQBzP-LlZ0LpN6o5WgziqWVVxouXg,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb,sha256=nZ7GyTo8pI1otqZg8N04qEXGK8KMRoAVsVCuNp6KZKs,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/model.onnx,sha256=B4i75xU-VtMflOT8rnkwNW1-ovGUD8O6aYX2uLM2b7A,269 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb,sha256=ELwcD97zClJjm-0q0aWGNMO2lFpemh7tQC1XoEkDCCo,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb,sha256=PSbLzivPmtfKKKqqHg4CfuFqAdZRxWJCEJN4QLYvFbQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/model.onnx,sha256=F1Q3B2R3NCpGRozhHe5BBtOLdP4KdxzQepZ_oPYKjC0,3092 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb,sha256=ELwcD97zClJjm-0q0aWGNMO2lFpemh7tQC1XoEkDCCo,34 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb,sha256=PSbLzivPmtfKKKqqHg4CfuFqAdZRxWJCEJN4QLYvFbQ,14 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/model.onnx,sha256=gB0J5vDo6X0PqjjVfUAGFTX51lzgAmCoII_lfIi7qSA,266 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb,sha256=y3Zghr4cDyuqm8pbBCrybjPAkSLe_eJ7sR0zCMdCpyM,25944 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx,sha256=KLP6Qfeaq9OXA3sRbOAVPKN0yUIqF67Akz5NAbuZWsQ,1974 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb,sha256=P-KwI3TkPu9I4UH_2t-0e1iCCIJe7S3kGZNXzc_N2GU,129627 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb,sha256=2oaVEIGngV21FQn4FgoG7qbtTYELaSA8w1z1HdyQSIc,51866 +onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb,sha256=y3Zghr4cDyuqm8pbBCrybjPAkSLe_eJ7sR0zCMdCpyM,25944 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/model.onnx,sha256=b5A4lcIFtquT_uLGjS0-Yh_HxEPuxsj-sfdxboSMfhE,410 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_0.pb,sha256=aQPSV_4Z6zQcZDVGmekHfnVc5BHUPfOMSfgoCOUCiX8,113 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/output_0.pb,sha256=VkYmKplg2aAE_7p6EVba0_QxYiTcUtLIAud4BVNFCVc,98 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/model.onnx,sha256=ChIjMwo0mYkmvrx5mruIWwH6vffhTspoARXoUnTObqM,380 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_0.pb,sha256=vYpz_7-JGMz48Rd76XAJEU5ZJP9EbbVdbojxgbVQG3Q,113 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/output_0.pb,sha256=VkYmKplg2aAE_7p6EVba0_QxYiTcUtLIAud4BVNFCVc,98 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/model.onnx,sha256=pRqjxjc6bOsMwBV7BFZH11P88ZSmYkxEvjfviO3c0ss,376 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_0.pb,sha256=CmhJacibwTo53qN1x9N-gVK36bwbgCdCDi8wFskbaAk,178 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_1.pb,sha256=HvcpOmM7nTwjD3KeqZ-FkgFW0xAT9ltbwiA0Db3UmjI,58 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/output_0.pb,sha256=9YHRVPgbYrY2cQnDRar4KnLaeonSVWSdU89tbBN7vso,50 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/model.onnx,sha256=ruPA6FNX-f2C8YKjU9f-fGPtWs8E14vAbin4aStZ7do,378 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_2.pb,sha256=2P30Cd3fFGFSGa7DF8F9KCKvZGxbK5uNUhmU-k69NzE,42 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/output_0.pb,sha256=6I0l4kmldzPrF5onX4EWG6aE2qEYmjhx2g0NhS6sr0A,74 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/model.onnx,sha256=G9qIpCAAKZfUE4vQaN5VqiYlR75wqD2z8cu3k21RkFo,371 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_0.pb,sha256=b1Nue7dL-O5ckB2PtWiRUbFhbD4I6NhHOAK0KaFIvko,33 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_1.pb,sha256=taq4F_r3_H_0TP2WdMSsl7q-8GBinBXy0GgNfbcJT6Q,22 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/output_0.pb,sha256=9YHRVPgbYrY2cQnDRar4KnLaeonSVWSdU89tbBN7vso,50 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/model.onnx,sha256=c4__cnmz8GcfTRmVUcaeSWMKiEgWmYkmN_SOYqSMzAE,376 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/output_0.pb,sha256=VkYmKplg2aAE_7p6EVba0_QxYiTcUtLIAud4BVNFCVc,98 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/model.onnx,sha256=I4ZPZIQDwB_6DWvtoH7Jw7StjGTDmldjhkloHZnt_0Y,387 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_1.pb,sha256=F8Eh7WUjXtKojmIpSeXsbYD2qPsRcLXA3WtXC4vwkNw,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_2.pb,sha256=wHAZTQlX9ckNeo0B8bi7mO9CufjQz6hVH5xSg04PXwY,42 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_4.pb,sha256=S_ZLHHF52hnQCGoYFUDGzoXON6ejUj1_45vFLB8oRzE,27 +onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/output_0.pb,sha256=6I0l4kmldzPrF5onX4EWG6aE2qEYmjhx2g0NhS6sr0A,74 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/model.onnx,sha256=lFJHZUPBRCbUKh6iUMzOzuRTuujALHctWk8hNDzPz_o,372 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_0.pb,sha256=3HF94qHNxjTM8WjQWgm2G3v0yWzH-uZMwkjNvixauog,210 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_1.pb,sha256=H91iA7UY1O-Q6Bk7qNRv1g6Udhd4PQetKtp4KemkCCg,66 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_2.pb,sha256=2P30Cd3fFGFSGa7DF8F9KCKvZGxbK5uNUhmU-k69NzE,42 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/output_0.pb,sha256=8rjpUP7x4wsIEYYTzCWpUhTfdii3TzZu3wVcBJFwdKY,122 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/model.onnx,sha256=7EWVtK6PCCwzWUvXtGlJY6RbqU-BQNJnaxGppt3y9AA,372 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_0.pb,sha256=QcocbmgMfN9gR0hQmlBCkMN1MOqyzDtOyL0wDo3HH-s,113 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_1.pb,sha256=txKTRX67rNUdqyDQKt-fzGR7NdzmdWON2-47x_otWBM,66 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_2.pb,sha256=2P30Cd3fFGFSGa7DF8F9KCKvZGxbK5uNUhmU-k69NzE,42 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_3.pb,sha256=B6qRKb1_O_DZYhoAr4ofYWN_KOBsRzWR3G4qNUeFsi4,25 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_4.pb,sha256=udYwTTSV1VPje8RjiHGMu34WDMTRVKTSlblxW4Q8w6Q,27 +onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/output_0.pb,sha256=0Xd_ql2omtRQrJWmryeLNA9btZZH6gbiR8HXP0EDDRA,122 +onnx/backend/test/data/node/test_nonzero_example/model.onnx,sha256=NX71cOVVAavMtXWDgcW3432l9-4BxiHnarj-LJq5fkA,131 +onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/input_0.pb,sha256=ghkps-yp5CRRR8fRbC7fiqWG19bL00TcORlce2Dr8og,23 +onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/output_0.pb,sha256=qoM-JaFSLmJRjNoDvsqY2dR0f6q64MPDvlJtjVR6grg,64 +onnx/backend/test/data/node/test_not_2d/model.onnx,sha256=ZmCCGeOUtVvFmdxC1oaRu2PkbBvnhHQ3Gai3PyrsoKo,96 +onnx/backend/test/data/node/test_not_2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_not_2d/test_data_set_0/output_0.pb,sha256=JEuquI41JHa3vt29a199NzMyPBW9WvAOkSSADkpkpiU,25 +onnx/backend/test/data/node/test_not_3d/model.onnx,sha256=--Dj2nqyBlRaVxLrtH5BZ-anek--8I4MBmVx6xD6QAo,104 +onnx/backend/test/data/node/test_not_3d/test_data_set_0/input_0.pb,sha256=TWHpMMyqdtQO1GlrLNWX631jO6986ZyG-R4tcfX_k9M,73 +onnx/backend/test/data/node/test_not_3d/test_data_set_0/output_0.pb,sha256=-oL9DNgUrH4pCs7vwUYL5uq1Las7wPU-F4ZJSVNExrY,75 +onnx/backend/test/data/node/test_not_4d/model.onnx,sha256=_GXaFJpy_nuIiMqj2PyWLjPP7FfBx6eaxaujJNpnGmM,112 +onnx/backend/test/data/node/test_not_4d/test_data_set_0/input_0.pb,sha256=iZjPxHloGhOKJNSczLBvGtYZN5Sen7TAs77gLl8-eJA,376 +onnx/backend/test/data/node/test_not_4d/test_data_set_0/output_0.pb,sha256=8PTjOyrS2vPHwwmPn8DXr1_MbVZjMzStaPuHfzenUTI,378 +onnx/backend/test/data/node/test_onehot_negative_indices/model.onnx,sha256=fjlyNhjpN3EFThxhnvvRr7R_IrOBnSZ1v47WdW2X3c0,188 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_0.pb,sha256=F1-tByU4VnMyQFdReEjjeChbk03-iM4AH8zk9QNM1QQ,39 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_1.pb,sha256=SniLudwpo_9h-MMMuoLXqe1Ulz9W9uSM28WqXjYKBB4,15 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_2.pb,sha256=N_K-xBM0o6Y0qLA8Ml_8Q69xVU7fEZBZDFDFtXN5gYo,22 +onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/output_0.pb,sha256=5HdC9_F-HsrRLzGONydCDeMC2U1U7qJAOglTi8kUsWE,131 +onnx/backend/test/data/node/test_onehot_with_axis/model.onnx,sha256=7Tn4gjOHr5C80bna6RBkHEvFdSKx5ucs4Mw29ScjCKI,189 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_0.pb,sha256=qPjxHytD_tom84Yx4twm4SstHXXF6aMSkw1A0I1NzHs,33 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_1.pb,sha256=SniLudwpo_9h-MMMuoLXqe1Ulz9W9uSM28WqXjYKBB4,15 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_2.pb,sha256=N_K-xBM0o6Y0qLA8Ml_8Q69xVU7fEZBZDFDFtXN5gYo,22 +onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/output_0.pb,sha256=bu2Cxu0sCAAENGCwmOdA4QRBlbkqJBMAxunzVkOUbIs,174 +onnx/backend/test/data/node/test_onehot_with_negative_axis/model.onnx,sha256=f8RCLQLUojpYObQA3yVz6ZEGA350Ak1TdU48FyZSrd0,207 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_0.pb,sha256=qPjxHytD_tom84Yx4twm4SstHXXF6aMSkw1A0I1NzHs,33 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_1.pb,sha256=SniLudwpo_9h-MMMuoLXqe1Ulz9W9uSM28WqXjYKBB4,15 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_2.pb,sha256=N_K-xBM0o6Y0qLA8Ml_8Q69xVU7fEZBZDFDFtXN5gYo,22 +onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/output_0.pb,sha256=bu2Cxu0sCAAENGCwmOdA4QRBlbkqJBMAxunzVkOUbIs,174 +onnx/backend/test/data/node/test_onehot_without_axis/model.onnx,sha256=U0MILFaATSHjw9zDIMB4sRTqS_roPxfMWY6J84vV80o,171 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_0.pb,sha256=ta7hFCjVAb1WUU9sgiAov4CmflwgDNr3ak4YwDYUcxs,39 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_1.pb,sha256=4Ww8eBVFbMYzzKNzz3vLhRTT7_zLFojaP213mTFSVvU,15 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_2.pb,sha256=N73BjNA73IsU2QnQRSOqdYwn0AZlbwJonbgfKwmjLnU,22 +onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/output_0.pb,sha256=O8e-sVvv0ez-QO3vJ6e5qiVmVID9fwqfA1bgs3uHKyA,156 +onnx/backend/test/data/node/test_optional_get_element_optional_sequence/model.onnx,sha256=cKBCcL2XcDo1Y-HE02G7OEjeuqc_7V9tbNCP_4s00T8,174 +onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/input_0.pb,sha256=vpd8FwYbVh9wyMZ9xsWKs5AxADA98-eucJKMK8T-tU0,46 +onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/output_0.pb,sha256=PTgucfFItJi7etGLkHgc63wqJeAs5Fm_jZEdQGFHH_k,34 +onnx/backend/test/data/node/test_optional_get_element_optional_tensor/model.onnx,sha256=Kc4P3uTKFr35Ezt5zmkEDu8KFHxj3ipovRpfB7E8OR4,170 +onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/input_0.pb,sha256=A-AbnXPvbH-QEhigtVShIBP4Fxgyw6jbvckX2cSUAlM,42 +onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_optional_get_element_sequence/model.onnx,sha256=r2cz0m_Z6oUSQ3MpWM2huW1MfIB9tNN3qfUunUpkYm8,161 +onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/input_0.pb,sha256=mw1O20tvt7b6NaD0nRT-YqH7HmJARdY9dK4rnHwQ8_E,42 +onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/output_0.pb,sha256=PTgucfFItJi7etGLkHgc63wqJeAs5Fm_jZEdQGFHH_k,34 +onnx/backend/test/data/node/test_optional_get_element_tensor/model.onnx,sha256=smEO352xSf3_ms-9u2kyG5NKsJV_SBji5n1wP666qAk,157 +onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/input_0.pb,sha256=uUsn8ZJZNXJMkBUOaeS4pl1SPQtNedl6dZNV_MGJE90,38 +onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/output_0.pb,sha256=vSCHzMFSvur8t7ADW1BDQbERwPltOiCd-JuPcQ6-XcQ,30 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/model.onnx,sha256=gCOrPv1m7gcQjjBim0-S8q0RFs1erBi31VkyHuT3Yl8,136 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/model.onnx,sha256=wUjCLI9sTzqKZV8slgHm50AdjHBPULNsO-UywuHZZl0,134 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/model.onnx,sha256=fcThUtkxSofwsh9bpW_1o_zI2QwbYX7e1RN4mx2GzqM,129 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/model.onnx,sha256=B8L4KqEAU6oYpjOcXpByxFtlNK7AznjTdImTR7vAbQo,127 +onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/model.onnx,sha256=lhf09ImdqqoFt2WX5kuR9OH1ihyT85AOhSjgZX_dQzo,167 +onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/input_0.pb,sha256=wv94C5xbz5m4GuMdyxohS6Lqilkq4fNCzFygsTgGIPs,18 +onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/output_0.pb,sha256=KPmYRG7Wt1DNktECBF5SN8KtQ0EKfo1s1gXtOI-Tw50,13 +onnx/backend/test/data/node/test_optional_has_element_optional_input/model.onnx,sha256=oZsbFysfy2fzzLDLaRl5pp6yAKt_JBLQwYKKbCb_O5M,165 +onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/input_0.pb,sha256=A-AbnXPvbH-QEhigtVShIBP4Fxgyw6jbvckX2cSUAlM,42 +onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/output_0.pb,sha256=hpn8eiTjKgyiZryvhHYl3b_SKNz3D9ZMneyziZ0AkvA,13 +onnx/backend/test/data/node/test_optional_has_element_tensor_input/model.onnx,sha256=uU1Svb-zZhq-bhKKY5XCI1gDnmfKllnJOvDEK7JrfmA,163 +onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/input_0.pb,sha256=A-AbnXPvbH-QEhigtVShIBP4Fxgyw6jbvckX2cSUAlM,42 +onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/output_0.pb,sha256=hpn8eiTjKgyiZryvhHYl3b_SKNz3D9ZMneyziZ0AkvA,13 +onnx/backend/test/data/node/test_or2d/model.onnx,sha256=YxZyfgzueJXXO82yAk2d0oFy_YCthbGNgd1ZHuDZ7WU,115 +onnx/backend/test/data/node/test_or2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_or2d/test_data_set_0/input_1.pb,sha256=goZmxegiEZPjRTXScUiQU9fpxPndF4EqAZy8oeToa8k,23 +onnx/backend/test/data/node/test_or2d/test_data_set_0/output_0.pb,sha256=5Xl0XiY-aaQiF0RTwPftqw-gxf2WK-W0mXlMNdMDSyc,24 +onnx/backend/test/data/node/test_or3d/model.onnx,sha256=14UsGEpmYYb9juxWEBxdx89196ZQU8cWRIawcP-mbWs,127 +onnx/backend/test/data/node/test_or3d/test_data_set_0/input_0.pb,sha256=Dr4k5dppNqEaWmFsMUXw_Pbp7QoEpqkXv4Bodqt7zMQ,73 +onnx/backend/test/data/node/test_or3d/test_data_set_0/input_1.pb,sha256=v5SpTzEGQijgxpt3GQdqFdpD-LCqlDgrPace75EL5pQ,73 +onnx/backend/test/data/node/test_or3d/test_data_set_0/output_0.pb,sha256=mw8NzywgY2NAFHAr4f4QQLIffghFyfSifzaeN457XRI,74 +onnx/backend/test/data/node/test_or4d/model.onnx,sha256=bKfqW6lqdxp4zZ8X7G6MD1eyfUCI2TS9qECPjystd3s,139 +onnx/backend/test/data/node/test_or4d/test_data_set_0/input_0.pb,sha256=sMKxU5gNQx6mv89ZOkmV0QCdEu9f8EhE-MZuoWNbcek,376 +onnx/backend/test/data/node/test_or4d/test_data_set_0/input_1.pb,sha256=9JaUvXVRf_NYTRwYWtPYsbSoKJDwOXPZuRBgFY7pYPc,376 +onnx/backend/test/data/node/test_or4d/test_data_set_0/output_0.pb,sha256=NWaSdDXxpWJ2G5_V1j1D4xBCLVAfA5AibswMzTatBs4,377 +onnx/backend/test/data/node/test_or_bcast3v1d/model.onnx,sha256=cXjsmeVsR0T2G5yMsihChNeQN_zpdqJ6i6IbPlJi5RA,127 +onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_0.pb,sha256=wF52hvLEXCfryTN0FvgWPKXSx3PPlpiaC_aAZ5IXCMc,73 +onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_1.pb,sha256=0cP0kHJ95VbmGsyJW3rlozPO38YQocSctc5buLas0ZI,14 +onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/output_0.pb,sha256=j0nTh8QRsYHOGVMoWh_46oB-6On3aBJH4SI24vIohRI,74 +onnx/backend/test/data/node/test_or_bcast3v2d/model.onnx,sha256=G9GQtIbSTfAFO3EFW38ioWu9y_2NkgU1Iav8Ci5HCrs,131 +onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_0.pb,sha256=2Hi5gZzCyk3SWtB8dhtS5tIMipISnPJGI1SIjx08Fe0,73 +onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_1.pb,sha256=J1neLsOqZHTvGdagBF8_3O6sQk1byuUIMABR0wJxASA,31 +onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/output_0.pb,sha256=Glafui2pjURlqmm1rfvld49F1orTOyvv3DaBtU3j1gI,74 +onnx/backend/test/data/node/test_or_bcast4v2d/model.onnx,sha256=TZJalmR1gazv8940_76Fk0UXbxLJLqVAKlZnbMATqKI,139 +onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_0.pb,sha256=TG9PpNJBW-rhSdwYDpmwCMotWc8SOe2e2cLAoXaNQ8o,376 +onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_1.pb,sha256=D4JIlfVUzijC8rk152pkPsDWa33YJRlmutjMvkT-1FI,41 +onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/output_0.pb,sha256=3VcBGGnUIc16zDtVFdh1ecfxPo5Amdeloer8Gs6iGWc,377 +onnx/backend/test/data/node/test_or_bcast4v3d/model.onnx,sha256=fgL1jyS62RVe7hVUtiNc0VXR-Qi_Hd-D6QAhvFN54ns,143 +onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_0.pb,sha256=1gaunFCw_HO0ZAf_sAp9bfcwVRJW_aTJIwkv-2WYWMw,376 +onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_1.pb,sha256=26gLYNI9eQESqKzWzx1zrE8YDDCNIvfAE_0m_FoeT3E,133 +onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/output_0.pb,sha256=L4Mruier4Yg6xS5HZXDfBii0EK9xF13r_INAS00D8fU,377 +onnx/backend/test/data/node/test_or_bcast4v4d/model.onnx,sha256=0jt8W5Qyv_1nUR5K7fMmga8rLmjsjePDZvS7ZKtdnkc,147 +onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_0.pb,sha256=f63fGhPch5eTkAvMXCrJTC0FOIdhKnaSfJ8Ox9hnol0,39 +onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_1.pb,sha256=iCGDAU6H1-WHvqKKRCD44UWeluKsnFCWMpevbsJ5ASU,105 +onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/output_0.pb,sha256=FDGBOwzj2VIUJgfnXU22QetJ_GOkZCqrZ27em-O04Lk,377 +onnx/backend/test/data/node/test_pow/model.onnx,sha256=oSi3o33WPiiwEEtIqeL8xWz5h2VGhoieq2vfZxsTdkM,125 +onnx/backend/test/data/node/test_pow/test_data_set_0/input_0.pb,sha256=AY_VMGnKJBQrw98tz_qYFRZu6obuXC-dGQyJjKrKjKo,254 +onnx/backend/test/data/node/test_pow/test_data_set_0/input_1.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_pow/test_data_set_0/output_0.pb,sha256=y-34eZm7CPL6irwI7C6amp564eVmFsIb9OvVtgp0cjg,254 +onnx/backend/test/data/node/test_pow_bcast_array/model.onnx,sha256=aWkVJssCZgZJkRcz1r9097G5eEy7N-yy2FhQszIXYeQ,121 +onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_0.pb,sha256=4pQ6jBxU8_tBNnaRVRgYgck68GhQp-YW_tL388GcCvE,35 +onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_1.pb,sha256=KW9J7uTWmyfHYqYwYwZyv64IeAl6_iDrPha7DI-bhcU,21 +onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/output_0.pb,sha256=oINJYm3arnswSBGkl8GBHl_T8_2yIhrVB53JwpiKAvE,35 +onnx/backend/test/data/node/test_pow_bcast_scalar/model.onnx,sha256=UuP9qM1PUFNvkdMvtnuBcHQ2-HIMkO6eRJ6v5JzOkBc,110 +onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_1.pb,sha256=ydsAlIsWhTc_J1CFdrtsGmByX5clFiagrVStpbLbEm4,11 +onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/output_0.pb,sha256=KJlLjivIdBlVq1m1jgyIwPU5tSpNIjw-blrFrPmtr3Q,21 +onnx/backend/test/data/node/test_pow_example/model.onnx,sha256=W--GGh80r5ebmjKz0wJSx74FtnlQW26I5-rqJ3Pe_sk,109 +onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_pow_example/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_int32/model.onnx,sha256=dxLTq6DJ-ekrMCQY4IxPqzB5oIDKNcEJDFKWNTk4iO8,121 +onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_1.pb,sha256=r8BFGDyB4p4Qqn72TCCqllX4VYjNBD2WqlCAVxUuF10,21 +onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_int64/model.onnx,sha256=bva03rFSbrJ18uJMKS5oBQTMI8XdxebRhodAICC0M7c,121 +onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_1.pb,sha256=-Mz9howslt6OFLvLPy_8aC6Z7H6lpX4ULsCU9rbuITQ,33 +onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_uint32/model.onnx,sha256=8Pbwtz_fJDSXpX-bstlXsg6MCAanm_cXB4VcH2dYDVQ,122 +onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_1.pb,sha256=58O5vvDhR1HzOWUoqyt2e86myJ4FYDger-v8DT6IeR0,21 +onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_float32_uint64/model.onnx,sha256=oX2b_ITd8r-Hl9OeBki0iVT5oNggIYhN_0AAHIUTiRA,122 +onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_1.pb,sha256=yY4W3jqfz1Qc7B9EKL41WxTKzhmiwQlgkd_3eJoJtQA,33 +onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/output_0.pb,sha256=57LTWuvzfgrVUv-dX28zQm97yYNf09UNTo0WGGLE4Vo,21 +onnx/backend/test/data/node/test_pow_types_int32_float32/model.onnx,sha256=lEyY8p-kFy2-Um7rIKeF2W6wSppZvfBrYuUdWS-KNEI,121 +onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_0.pb,sha256=nXGXrHzTelDfYXqyN-ePUSAnKkGHHf4Em7tfQoCy8gI,21 +onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/output_0.pb,sha256=5HGZJaBp_kTdE1qP63n0RHw17mLW6osJWWIKcdTAPRE,21 +onnx/backend/test/data/node/test_pow_types_int32_int32/model.onnx,sha256=b94RDUFctnJPBTWKCC3gXLaM152e7zkloWeyZpqGsnU,119 +onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_0.pb,sha256=nXGXrHzTelDfYXqyN-ePUSAnKkGHHf4Em7tfQoCy8gI,21 +onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_1.pb,sha256=r8BFGDyB4p4Qqn72TCCqllX4VYjNBD2WqlCAVxUuF10,21 +onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/output_0.pb,sha256=5HGZJaBp_kTdE1qP63n0RHw17mLW6osJWWIKcdTAPRE,21 +onnx/backend/test/data/node/test_pow_types_int64_float32/model.onnx,sha256=h4Bky73HUDVZ3HfCJr8Bd-mmkMeQq-Lmktqp5NxZL-s,121 +onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_0.pb,sha256=_cGeaGhZxcfOOmaCCsiTo_hNZRp2Zxo91TaoYiWtOAM,33 +onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_1.pb,sha256=CRO596M4hKvMtegi6TFu8eNUs-prhD7vkphHojkzBj4,21 +onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/output_0.pb,sha256=zDXqkOFSIfyWuTMnQxcIRhTC-wGpB5rhBrjWeAOZdLw,33 +onnx/backend/test/data/node/test_pow_types_int64_int64/model.onnx,sha256=aobGdTeCPRQjcsm-0MQ55aszgjd3WW1DU5Po3uzsoKw,119 +onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_0.pb,sha256=_cGeaGhZxcfOOmaCCsiTo_hNZRp2Zxo91TaoYiWtOAM,33 +onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_1.pb,sha256=-Mz9howslt6OFLvLPy_8aC6Z7H6lpX4ULsCU9rbuITQ,33 +onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/output_0.pb,sha256=zDXqkOFSIfyWuTMnQxcIRhTC-wGpB5rhBrjWeAOZdLw,33 +onnx/backend/test/data/node/test_prelu_broadcast/model.onnx,sha256=VOu6i8tiLpeQK6YWXdF7oJCXK-4WT3E0bDszBxRc4l4,139 +onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_1.pb,sha256=zCWXggDw6QArEHtYuiVS23cWS2G7lNjtq_XeeHy65sc,33 +onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/output_0.pb,sha256=KmwLJ-2oKWwwgugpBrNYG2ynhsgvc_0m_vdW_NCbEFI,254 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/model.onnx,sha256=3VpORuXsca8Ufl65oJO1bkyRLQZ-KJS3La0KlcSTQbU,676 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_1.pb,sha256=zCWXggDw6QArEHtYuiVS23cWS2G7lNjtq_XeeHy65sc,33 +onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/output_0.pb,sha256=KmwLJ-2oKWwwgugpBrNYG2ynhsgvc_0m_vdW_NCbEFI,254 +onnx/backend/test/data/node/test_prelu_example/model.onnx,sha256=fTqBhgsJarObGlLYNycwzJD2NIggfMg4_pjC0LrZ_c8,145 +onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_1.pb,sha256=t8-Rs14nU1gM46Bqcj7DCLL8KQt3PwZNrP-n6Yxs050,258 +onnx/backend/test/data/node/test_prelu_example/test_data_set_0/output_0.pb,sha256=hkpum_lGz_jBnbvAIljQ9y5IzwU1AbXJRLXvIuVCK5I,254 +onnx/backend/test/data/node/test_prelu_example_expanded/model.onnx,sha256=Pu-_pG45_wdvyBPfSRxzgpHH-Ou7-y5XY7K7ls2Fh_4,665 +onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_1.pb,sha256=t8-Rs14nU1gM46Bqcj7DCLL8KQt3PwZNrP-n6Yxs050,258 +onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/output_0.pb,sha256=hkpum_lGz_jBnbvAIljQ9y5IzwU1AbXJRLXvIuVCK5I,254 +onnx/backend/test/data/node/test_qlinearconv/model.onnx,sha256=bqDrNQcDv3Qw4DbA2a6-uTWtkLlPxWm1Sk9EJa0uOKk,360 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_0.pb,sha256=nixNRkyGN_KgVkWV5xeFSwW2P9g5MGBOe-fgB5gW744,64 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_1.pb,sha256=a9DMFXaeuYAOi_FHwlb4SDFEqpxh_gwHrH06td0hjQ0,17 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_2.pb,sha256=afKUomTgzPpltKVwfiOFEPSOezG6ntRvqW9enoddjJA,19 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_3.pb,sha256=YDlA6BZ9CIGFwKl9IfXE7vxH2gKpIftKThESMEtEHgI,16 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_4.pb,sha256=kdHz8BDgovMXRdFV-OaK5z36bbaWGT3-ZI0h6qw2uh0,19 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_5.pb,sha256=CQhc7l4YdSLie9L3sGF-eLE3KZIxewlTFTmvOmZRym0,21 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_6.pb,sha256=T4bbtORqnLDgoXiJlaOQ2C-Rbwqp2nQ_t4VN6Rbc84Y,17 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_7.pb,sha256=qrW9JA42dIlWU4LSxNQEZVx6ktF-KAhGf4gYgy-4bX4,19 +onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/output_0.pb,sha256=fXjZHJuLHRtyTJIj46iMB6A-32OAXHixEdz5OWZ7t0E,64 +onnx/backend/test/data/node/test_qlinearmatmul_2D/model.onnx,sha256=y4k72R2ZXefU9UjIvL0RhQF5D3gbY3LrVjeCNwMrCTk,359 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_0.pb,sha256=ko9ZfhAcGp41Zcl0RgwHA7UB-6Iqkc0hqXnViR7c-2M,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_1.pb,sha256=aVsxHksGQU9JCf5giP1I5HpY1f659W0A0y09s5oXTVQ,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_2.pb,sha256=pPLPbQiq1ONgy164_MHBnJM4nH5E_tZbcoFV5sPOYUY,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_3.pb,sha256=oIvG3PVjz2QeQCzNzI9o9errRsMMNpLyCqVPNflcHAY,23 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_4.pb,sha256=-XzmSr1oi7OP_jzKt5I8dd4ZiHXLfgttDVHG9h02Asc,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_5.pb,sha256=CbDV3Ys31D0hYZkLMhnYjqA2TCsFoiAB6Osr8BXOleg,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_6.pb,sha256=f9fGFxkJMhbFB3Jha4dcX2nTB0pIclfxri5tXYpZZwc,19 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/input_7.pb,sha256=ATdkTkCLK9NqW-0ctLP0ByOjC9HDFf6P3w_fAVQhiQc,21 +onnx/backend/test/data/node/test_qlinearmatmul_2D/test_data_set_0/output_0.pb,sha256=Fbb3q876qubUQlK88YFKv7lCDKrp0pAA5yddHKodoqc,17 +onnx/backend/test/data/node/test_qlinearmatmul_3D/model.onnx,sha256=CtjSdvVaLpTcfutXz7BOox4AQ_Sp62Brgl1ZGdtDeFE,371 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_0.pb,sha256=g5g_gcA0GltOE1_lFzaVSua7MBYe98NlUfplZayMJtM,29 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_1.pb,sha256=aVsxHksGQU9JCf5giP1I5HpY1f659W0A0y09s5oXTVQ,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_2.pb,sha256=pPLPbQiq1ONgy164_MHBnJM4nH5E_tZbcoFV5sPOYUY,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_3.pb,sha256=aRoCSENX6yjHjLkmm5vXFbBpo9EbeGo9RxE94GPJHXQ,37 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_4.pb,sha256=-XzmSr1oi7OP_jzKt5I8dd4ZiHXLfgttDVHG9h02Asc,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_5.pb,sha256=CbDV3Ys31D0hYZkLMhnYjqA2TCsFoiAB6Osr8BXOleg,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_6.pb,sha256=f9fGFxkJMhbFB3Jha4dcX2nTB0pIclfxri5tXYpZZwc,19 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/input_7.pb,sha256=ATdkTkCLK9NqW-0ctLP0ByOjC9HDFf6P3w_fAVQhiQc,21 +onnx/backend/test/data/node/test_qlinearmatmul_3D/test_data_set_0/output_0.pb,sha256=rvU4UCTaVhbhfnNv1gl2oCkUQblLDZkbA4uRlSy0Le0,25 +onnx/backend/test/data/node/test_quantizelinear/model.onnx,sha256=UVVe1h5H5eQJfG0ffhSw-qLxDPumzs4RzqS3g0hTSbY,170 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_0.pb,sha256=-WdUWtE3Gq6XQCRO6yOoTUcsaUMo-gEvqWT8B_Q2ax8,33 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_2.pb,sha256=wPEVchEft31jMR00LL9m2McOaC1WYliDhjLWm34U2yA,19 +onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/output_0.pb,sha256=tKPhseg-u9oNXCOVqz3GYbmoR7oSaEtKC0Y5KC4txus,15 +onnx/backend/test/data/node/test_quantizelinear_axis/model.onnx,sha256=5hdzFSQ5rmLK44VhtqGCrStuX0o_urhj_cs3XXCtC8o,207 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_0.pb,sha256=lOMq5eKWvXmYUXZijznYZGS8ZP7QGcLUOQgOwOc00zE,87 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_1.pb,sha256=32ZIocYXlTh3bTOfM1h_XZs3_EDpTAXIivA6ljFghzA,27 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_2.pb,sha256=Nm2IkguOQZ3UhRkLUIs3YMzqEG3ssgm0UKDB1bvBKKk,23 +onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/output_0.pb,sha256=qUJeQDCKjzRejnEfE6gC17CDuVDqA6q5MM1F555aFVA,33 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/model.onnx,sha256=nPaUCEf6xQmhceqqgDZR__Wd1hLD-wGeImonxO0Kqtk,181 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_0.pb,sha256=RpINE2Cg2dhwMgzJm3ZxSLDmJ1q0XwI6WmIHcL_j6Yc,29 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_2.pb,sha256=3qDZIcWHdcD6sR2bi0d9zxwFMbgB-8xVA8QC78gP0h4,19 +onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/output_0.pb,sha256=5ppu9OPJvzH6uInh4_-OBAZxTEfN2ZdY57yMBQUKpKw,23 +onnx/backend/test/data/node/test_quantizelinear_e5m2/model.onnx,sha256=GbBALkhoo3Bg5J30lbkTFg3sjByWM2wnsr4wpffLiKc,179 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_0.pb,sha256=RpINE2Cg2dhwMgzJm3ZxSLDmJ1q0XwI6WmIHcL_j6Yc,29 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_1.pb,sha256=Zv7CydImWalnvbaS5VHQ6zTXvOUCohUym_ClUIDiLJ4,17 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_2.pb,sha256=PW0rlxt1n-xDnnHatqfnNnTTn3NsbNGhcm1Gs7psnmY,19 +onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/output_0.pb,sha256=T7WiYpvxHWPSIGF-XAeTm3fqktHCM1_2rlC53-E2-w0,23 +onnx/backend/test/data/node/test_range_float_type_positive_delta/model.onnx,sha256=yDJm47JALZVJ9S2sTGlShf_fJRLQNqF-BYb_fTfohlo,174 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_0.pb,sha256=PnwKkhwnmd5quiS20ZgN5aEPgWHukh4Z1L_5tQBqFMg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_1.pb,sha256=OT2i3PvMIECBJbEVaUsUV8vy3vq8W619CaqivcgRoFg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_2.pb,sha256=_Azn8KSvchMQKs1IHINUFQPQxYbtW9YaipLS2VsJGOE,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/output_0.pb,sha256=CWcrRK3j1PGFEpIxuIl7JKnveAGbOMams_iDdcqFhJA,22 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/model.onnx,sha256=QCdczSdUJTvbo5-AyJr4JX4AG2mBuEnJrw9D63HYL3w,2647 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_0.pb,sha256=PnwKkhwnmd5quiS20ZgN5aEPgWHukh4Z1L_5tQBqFMg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_1.pb,sha256=OT2i3PvMIECBJbEVaUsUV8vy3vq8W619CaqivcgRoFg,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_2.pb,sha256=_Azn8KSvchMQKs1IHINUFQPQxYbtW9YaipLS2VsJGOE,15 +onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/output_0.pb,sha256=CWcrRK3j1PGFEpIxuIl7JKnveAGbOMams_iDdcqFhJA,22 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/model.onnx,sha256=OL5MqVgBtEzjYRwqakzjOZwztFjvpzyH94biMkHRm78,174 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_0.pb,sha256=IcldFo4nLQkGvXdxZT-tL5zhETapZc_ycbchk-cBlP8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_1.pb,sha256=uNYgLVHrZEoHuuPTegF9h62BtRk4kWwhnCcH08WlTO4,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_2.pb,sha256=85Fwi4unXUNic9TUurAeph_M0WclGePlXKxTJkarxr8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/output_0.pb,sha256=Km4G9yM-_Q369BPQXgij7_N3dWiC05nccMJvbVkCwOY,22 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/model.onnx,sha256=TwYliCls4W6m3UNvAXO9aWw9kCYfw0rY1lcSPrJLC0Y,2647 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_0.pb,sha256=IcldFo4nLQkGvXdxZT-tL5zhETapZc_ycbchk-cBlP8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_1.pb,sha256=uNYgLVHrZEoHuuPTegF9h62BtRk4kWwhnCcH08WlTO4,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_2.pb,sha256=85Fwi4unXUNic9TUurAeph_M0WclGePlXKxTJkarxr8,15 +onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/output_0.pb,sha256=Km4G9yM-_Q369BPQXgij7_N3dWiC05nccMJvbVkCwOY,22 +onnx/backend/test/data/node/test_reciprocal/model.onnx,sha256=9cYhyYrtsZnNsprI4Lv2Mo4iKGoD2D-2tKAXYkZ21fc,111 +onnx/backend/test/data/node/test_reciprocal/test_data_set_0/input_0.pb,sha256=GgRN6i1Z1pXIrsvfZWkp52hvnZToD0J1d6uAsH-ysOw,254 +onnx/backend/test/data/node/test_reciprocal/test_data_set_0/output_0.pb,sha256=Iw7Mqud4Obp2fRS-HaenQ1G7QoOphufczelvmamQGJY,254 +onnx/backend/test/data/node/test_reciprocal_example/model.onnx,sha256=zqyZFVq34gf2pggBHznhwsBXrlELzUaUou3suG758Ew,103 +onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/input_0.pb,sha256=hIDv23oySvd30UHcdMkH6btwYls47z-2HWS1hMB2wdg,17 +onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/output_0.pb,sha256=ep0bNR1nZSAgCmdKAEIQP7ZNm5_nVb12ngt6I-yLdzo,17 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/model.onnx,sha256=ohzqkukts8S1Ekf20SpX5OQEMvQWTUZ5Z3-2iSfLh90,200 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=-tM_bqHqK-65eWP1RbkvxizF8zO7aiimwgb1H-034CM,23 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/model.onnx,sha256=ttJdqNR1C12VkcacAyILL1AX-K5HEYcTINsN2aKF7Nw,385 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=-tM_bqHqK-65eWP1RbkvxizF8zO7aiimwgb1H-034CM,23 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/model.onnx,sha256=Z4DTNgCI8ewEd2WZCu1gIgzJ8TOGXYj40T8fpAB-E2E,199 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=3IYq1wIPmuGmuhhsnqmPmvnaA3qpKCI5e2wRanUn-EI,23 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/model.onnx,sha256=3RfBSyOsfEoWya4S8zdLwRBeKYrw3P9-pR52bMMbB5c,382 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=3IYq1wIPmuGmuhhsnqmPmvnaA3qpKCI5e2wRanUn-EI,23 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/model.onnx,sha256=RPmBjeHx3iQ_RPcKvTxKCE6bveoJrtMXs_32KKOUVTE,190 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=JC-ByfOkizIkgJ3nwdBl673paZR_4rtYThjJ7UCL2Bs,41 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/model.onnx,sha256=k4g1LJhbvidKtD_1QgBwEVd0EB-HfFOUM5MXwWk7PS4,363 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=JC-ByfOkizIkgJ3nwdBl673paZR_4rtYThjJ7UCL2Bs,41 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/model.onnx,sha256=2MJdQR4vCOCKHEKWhYRnZvxFfS_EoYcBmzZV9YTc--8,189 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=boLxo_tKTY-Elb4ILMYTWLBXdqS8I2dDPXrh7wlJYdE,41 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/model.onnx,sha256=64repJxPz_8w13hBcF4miv8kKtiQBa9KCOGelXcHemk,360 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=boLxo_tKTY-Elb4ILMYTWLBXdqS8I2dDPXrh7wlJYdE,41 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/model.onnx,sha256=8tPPR4vedPEERxpY1rTpUT76lMyxWjvum1LptsNgYKQ,188 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/model.onnx,sha256=UIzfR9nHpxRp8vQD4-FdQk1x9_EFbL_zMatXqYbgcT4,349 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/model.onnx,sha256=vMPnjNZPytsdjAWg_-FIT_LynV0Fz_mPTVr6w4OmFjQ,187 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/model.onnx,sha256=0vF2lI0lLQfv3f8ErJiKhVx8g2awf64E4KJtczFs6yw,346 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/model.onnx,sha256=v0bGIRG0HAaaWr8yKBWnfW36snQJuKgB-bgjx_Wz9no,202 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/model.onnx,sha256=yEu6LJV-6EvuGZiIqt2rVS0OpWTMAwE8a1BZhMt0Zyo,392 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=dJeaCpTSWSt6LwkQwBqvad3ot7QYb173M1rkBSqLXzY,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/model.onnx,sha256=c2tLsQtNx4nsU6LOI_6kkmG6HkA8gHBO8EGmBcvnXIY,201 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/model.onnx,sha256=gQtFJjAYWOPM9aHZzMWZrSksp_5-r4irB_7uj6SLmhU,389 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=GLZKMWiKlhBmVVM0kbK38-GloFGIoR7eFzqiQlIojqA,43 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/model.onnx,sha256=x3If-zJSSwsskknM8IMaAc-Q1HlsDhAVXNsVuGXxxmk,200 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=1nRvbw4k8gX2Lm2fHXH02jiiHY6FJ_bDDg0ZGJ14r08,23 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/model.onnx,sha256=y7da8FPFP4TiXaD3Mp2vlP_aOpGaU6PlqrVjOiULGoc,951 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=1nRvbw4k8gX2Lm2fHXH02jiiHY6FJ_bDDg0ZGJ14r08,23 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/model.onnx,sha256=4bAdBwk_5DWKjJezOCbPeyRYwzguBTYveoYAWqep2nA,199 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=PIATHW_5LGj0-_ZFZ4z8TpxbqFnMZNPE0ugw_WZjiuM,23 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/model.onnx,sha256=QqnCJAyaLKEUiZ7fqFmm3pCWZIoRVtjeHEMbly8vlgI,942 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=PIATHW_5LGj0-_ZFZ4z8TpxbqFnMZNPE0ugw_WZjiuM,23 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/model.onnx,sha256=VXrFAN0MVP4cc2Bo7NZ3334EsiiV3YTy_zJbWRCn0FM,190 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=c1D0KDheSLTWalNQZaabVbJ79Rr_RID0w21TeOewaBM,41 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/model.onnx,sha256=pCmGC5F9uaFhRXuOdyXdn3Ebxnk6osLn35P-rtOb2KM,893 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=c1D0KDheSLTWalNQZaabVbJ79Rr_RID0w21TeOewaBM,41 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/model.onnx,sha256=CvpFw-JYy4MzUPdpdx4RsFNsFQE8z2_ZswiBS_C1HaA,189 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=JOKjva3pUba9oCjoOdZ5D5cn8DmqUxB4ukD3fJeSbSk,41 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/model.onnx,sha256=vfO6qCnlDHc6SIkcNupjqryhQNvrDVntLwWQPGep3W0,884 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=JOKjva3pUba9oCjoOdZ5D5cn8DmqUxB4ukD3fJeSbSk,41 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/model.onnx,sha256=z66shsNj20DpEmucNL9xyFGHMMCNhxIFGt5H0gOBNYk,188 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/model.onnx,sha256=Cv4-IzsbBcliMyx6QsJckfp2CeUFTJSo77QmoHXPhrI,843 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/model.onnx,sha256=mUGEy6kiSHSdFR1SPWYA8uUyKQkNwYKS2lO6wy0WgqY,187 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/model.onnx,sha256=oKYJ6egnCfRCEP2A7UY7BY6YJdfCdIyU4FY07ZHtIjA,834 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/model.onnx,sha256=pjqo4Qrdy1yBnQntfi1AWBb0mKHhj08HFyvBAk8d4m4,202 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/model.onnx,sha256=TAgSxvizyBfPDSFzEZO2HR09ggQb3IBptXJDEiubn04,969 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb,sha256=jEsoUMRhG4OeYC5KTm_HKvd8ZN1iEJzVUEOlNq3zsow,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/model.onnx,sha256=_SnWGbphTilYxGrCD0L2vsViRqONP1Wc3UiXvYCvg4Y,201 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/model.onnx,sha256=SS_yV_VfVlGoNsYVTtNDm7I9nbNsnSwx8mmOTDRu9Bg,960 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb,sha256=TQcMG4GWMtXqeLfE_sX7GRTpBRPd7PNq1CmUW4rnTh8,20 +onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb,sha256=rPsbYUQn6_Cmp7zcRSMK4aDCf4R0jlttuYSLZj9JV6Y,43 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/model.onnx,sha256=08cgOZBs0l3W00v9s8wZpTPV3rOcIH-j5QRrsP05ZN4,180 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_0.pb,sha256=hiOZW6YmCAGEqJ0ELt4OVjMm3ncS3BqXQ9ngd-FPcN8,257 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_1.pb,sha256=3uvlJ_2xYPsfOzK-E0Fz2WR-a1Yvmf3r1G6DZPUQ8v0,28 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/output_0.pb,sha256=TtThcW8lQGZNcOpVgIggfFRZhLJ-dEq7i2HJ7P--ZQU,35 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/model.onnx,sha256=8awpV0QZ2b9diWVxOb3f6hIEeHsO4EX0Ef5LPseXuwI,343 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_0.pb,sha256=hiOZW6YmCAGEqJ0ELt4OVjMm3ncS3BqXQ9ngd-FPcN8,257 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_1.pb,sha256=3uvlJ_2xYPsfOzK-E0Fz2WR-a1Yvmf3r1G6DZPUQ8v0,28 +onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/output_0.pb,sha256=TtThcW8lQGZNcOpVgIggfFRZhLJ-dEq7i2HJ7P--ZQU,35 +onnx/backend/test/data/node/test_reduce_log_sum_default/model.onnx,sha256=qbcysYmQ32u_zU_D4iArr69SAiwEAtZcY2jQBLOF150,170 +onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/output_0.pb,sha256=VX5i5qOEuFQmlsL04_Mi021aVGoCe4VbAhD1x_xXErc,23 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/model.onnx,sha256=v8YwEvh9UQoFyTt5FyJWC2Si_ElcETHA1aRkg-vrFu4,348 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/output_0.pb,sha256=VX5i5qOEuFQmlsL04_Mi021aVGoCe4VbAhD1x_xXErc,23 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/model.onnx,sha256=cJkZ61Jw2xic321dMt_B96LpK8tAT8dQE7Z3Ugm_9wk,181 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_1.pb,sha256=b9vD-lAvbO5WdOMBewE0sjS9vcl6_4iAPW_FFXA_LLc,28 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/output_0.pb,sha256=q6wBAMfbpLLolGYAiBt9QC9EEED4D5XYzGF1tSQQgLg,27 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/model.onnx,sha256=of_IuZWjgVPNkM-fv_G4AR5eyrmU7oN8dLonOuoCVqw,346 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_1.pb,sha256=b9vD-lAvbO5WdOMBewE0sjS9vcl6_4iAPW_FFXA_LLc,28 +onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/output_0.pb,sha256=q6wBAMfbpLLolGYAiBt9QC9EEED4D5XYzGF1tSQQgLg,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/model.onnx,sha256=-LSKr_3WMkVC8ft7_prQsvhatLidnsA4tO3X4QPo1nQ,216 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=8-s0mM_b-21xuh9gCxveN-F_DCnGgiCmS24Mz2sJGRM,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/model.onnx,sha256=WGnECbU7Pcxyzo3EcOi-GH4DAd67pG9lRRpm_6mzaH4,1092 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=8-s0mM_b-21xuh9gCxveN-F_DCnGgiCmS24Mz2sJGRM,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/model.onnx,sha256=9-89fYqu5IADjGEbbqzQIF2QdUCOQ5RJQsQk-Y7TeYg,215 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=Q17PU4QR2ke-Ms3Jbvm8YwIVODqct6D8iOBWx1lXHUk,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/model.onnx,sha256=Jsqj4H52aLk8mS7O2tA3IIOAKqRJV5SpHnBpGkWlAxU,1083 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=Q17PU4QR2ke-Ms3Jbvm8YwIVODqct6D8iOBWx1lXHUk,27 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/model.onnx,sha256=evJeQt8UxeVRdg5hhuhA372TwI4KC85TooGPm2pmGMk,206 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=jLIBDVFsMai84zPcahQDicWPNPPjc3IHy3sJUKKjlHI,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/model.onnx,sha256=H60GUj17DDSlhCl--rc3GuPdkZZvZfXK99Jb9PCWkw4,1033 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=jLIBDVFsMai84zPcahQDicWPNPPjc3IHy3sJUKKjlHI,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/model.onnx,sha256=7S4gYBITpFk_DyMhCkrv0PXNBWhZi3lUnFQbEas3ZdI,205 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=p5nS_8ARmFPPIalx4PaRRQDUgIeQFN7ErnCeB3m38ZA,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/model.onnx,sha256=rsN-mMp8BP-inB1SYEmVKDOtvJ-lpEbyQgmz1_EBmn8,1024 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=p5nS_8ARmFPPIalx4PaRRQDUgIeQFN7ErnCeB3m38ZA,65 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/model.onnx,sha256=TrGMChcDC10sgL-egbi-a_I1oqVT-m5t3rd26n79apA,203 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/model.onnx,sha256=amoKiR4Clugn99nU0EaQg1nRoABNrU5_ZlY6MbzJ0KY,974 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/model.onnx,sha256=YlDp2phOYKOpNx4anOtWubW2l6ZX5fDQgpAW0Rxu8wo,202 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/model.onnx,sha256=QBma0e8Egn1iqejH0h3jNXjqieYy956imeffXg9xbEI,965 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/model.onnx,sha256=mTDZeOW7N99CyYBbe_MquaYlz_4PdDJndCJRmQ1-dbI,217 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/model.onnx,sha256=KIK93yWXnjSxoOwzEBW7UqYBjzvJXlASuOQVAWcNn2Q,1101 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=M3tV_VhTkcs-tg8qRMjNbRFaieo0qw8nITJY39Tws_A,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=DJQqS-8gXhP8nKgBqwU9pn53ssTbxinuUpr6DbULG9o,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/model.onnx,sha256=ua6HYd_IG6l-E3FdKTNSFGu5HkiFwxLP1GknDq1w6Bw,216 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/model.onnx,sha256=jTmg7nQJOHX8Q4NcyKghDudjv3ZXqLKhpoEYbS7C4qo,1092 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=VTaqgVd8jmvGxs2np_0IVZjhHMhxbltktKMVZ7oKQSw,112 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=qXaDuXS4jBTpMtd2RCpbn4sdw7A6y7YX68LFQjmSkag,67 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/model.onnx,sha256=2r5RqRgA1ZB4SAlPBS-zvLiOi2_ZtK5JxeEymrQEbTk,176 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/output_0.pb,sha256=6Yx7ZZqxOko4EPFziIZlhqwlJqLZz77lIAR6lkQ5Vpg,79 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/model.onnx,sha256=HrCHh4D9-SccREbNVr0KKOxTXJYknt_bqZThp3M9DOU,366 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_0.pb,sha256=EWB21V0Qg_0r93hTXZxBvBlxpp7ho0W9NhfaNQHoyHk,257 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/output_0.pb,sha256=6Yx7ZZqxOko4EPFziIZlhqwlJqLZz77lIAR6lkQ5Vpg,79 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/model.onnx,sha256=vE5drf-iydiwgV7A9GR7LcNtlAcOb4i389revGuEYjs,175 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/output_0.pb,sha256=Bb3KrZse37as3WFj056V_ClYfrCyJjnt2DnhrGk94j8,23 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/model.onnx,sha256=vanvh0gwKcMdDQIPsT3BArVb2Mg-XoqL4fY4Ng_mQO8,175 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=ozqWkbR-YL-E8NoR8OqPUH6OkLXjb-vzUIeOxUHkbBA,23 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/model.onnx,sha256=NFoSyvIEuAsNSntvGbAShr9g9qjoGvWjrTTmeAeMliA,192 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=HZffK_Pkm02avtHvOv7mhM-E3LY-MijOAq1-YgGuDV0,41 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/model.onnx,sha256=c7rXRCGW7S7y1GaEovkkfCKSBDVJhmM8DqamGq8liGc,191 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=EC7d1JJPDs9E3Pcqp3FMyYRM_Ydclfwe8J7KTg0Ae7Y,41 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/model.onnx,sha256=feVjIwASiT48qIHHEiGzGXmS_FLc2LgHWI-uVXYIQAo,189 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/output_0.pb,sha256=Y7JjZDTAji1tTbKuUwgzc6DaSNOnMOpmFJsTekO2MzQ,43 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/model.onnx,sha256=cLMY5hW2k6QjxYHquRfmDO9a0hopP47I3ODrk27xKK4,188 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/output_0.pb,sha256=U3UiOpILvTohrJ7lDcmCm2IiF8wccl8q9MTyLtVBJ28,43 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/model.onnx,sha256=NEq1WRSDW6dkrjrbU6LQBu2ingjwlNZ0XWd2H7k2x0k,203 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=Y7JjZDTAji1tTbKuUwgzc6DaSNOnMOpmFJsTekO2MzQ,43 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/model.onnx,sha256=YZMSj660Mh4kI73f3IDKmfokYk2EnhwdqEzmdaC5W8M,202 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=U3UiOpILvTohrJ7lDcmCm2IiF8wccl8q9MTyLtVBJ28,43 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/model.onnx,sha256=0rdbzI9NKpScLSUZYf6psg5BpGqAWCWX7R3DbJB3rUw,204 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=7ibSI6LwyCIMwafplWVc4TDIpFpsp_gp9a7jPZQvSiM,23 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/model.onnx,sha256=QuLvz4AXd5SwGI_LYyRq9MjzuwW9bBYuDRTzxZIKEHc,203 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=F1Wj0GTUnCJNo9yidS3ralMUw5yeg62NF2QM4q6lkhI,23 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/model.onnx,sha256=hm6mmXP-WpLZSSQpFWvhoTv4TF1C7sz1wDeR9_r2imM,194 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=hnISZrOPRTiH5iggcwleJTg6bX6m-U_oEnF8oQuZqxs,41 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/model.onnx,sha256=_unWlCItn4pGX1rQ65kNpvv7LVnhftErr4MhWdBHcPI,193 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=kpivv-z4wkCcK-I8shs26UmpmKG6Ytshz2EvgjiwKEw,41 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/model.onnx,sha256=SLeuMLRrJpaL1whWfjMX2H4vdQcSjVE1j8p_Is2YZxQ,191 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/output_0.pb,sha256=TtXp182U6LiKAlxhCCqkrszUxdjEEvqx9eOk9Znqgk8,43 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/model.onnx,sha256=2qgVPNkQEUXIIv6XAyHoYtY_NmgTHxu2HNgWD1YVWZc,190 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/output_0.pb,sha256=wcLIggmeEyvBw7Fc2_7q0gHHnCiJKgrN1bqGxV-R6vw,43 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/model.onnx,sha256=Z-hc_RMz3VufOXQULmwK5pnC9MhotEybQrNOG12VSbc,205 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=TtXp182U6LiKAlxhCCqkrszUxdjEEvqx9eOk9Znqgk8,43 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/model.onnx,sha256=m2HDJeknLP2M0F3usH0iOb44KJcVyPBXlrQlBei-YDc,204 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=wcLIggmeEyvBw7Fc2_7q0gHHnCiJKgrN1bqGxV-R6vw,43 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/model.onnx,sha256=M_DtcG5iqcqzc98s0DSgqY-N0qRPMqQuw7Wh_FqkfpQ,176 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=G2XC5D9PzsK5GpL4ZHlTK5OxYFrf70ozEzcBkItwsaA,23 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/model.onnx,sha256=QLKKrC-5Eujvt-EvyH9WFQTM4_6af5rtmEdX5dghe_c,175 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=fCFjoh4xFCI0bizOVGFspYggfTiFgAas8k1Mb9R46vI,23 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/model.onnx,sha256=uhZrDdQHcU_BN8oFyZTihiTSuKbIxGTJQDXLQND9Dig,192 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=Xu7cTpxA2M0y065t3hqWb0R-MmowoXfqGwu0JwdVU4I,41 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/model.onnx,sha256=ay7d2CF3QEKEdFoAk1aJ0zVq5qr_h6XmzZ-Uy7s_fxM,191 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=Wh_Dx6lJN0QUmIuWRDP29XGjpEw9R9Tlz2gzQT_XzUU,41 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/model.onnx,sha256=PXL2jvwWdNRFdDTRuPzPtjLvQGO6CA_abXa-oPMtI2s,189 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/output_0.pb,sha256=NU4b8D9taBjUcD7UZpFmlgF6rWEuaX175z8RcR5RV1Y,43 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/model.onnx,sha256=vFPC039OYaXjgPtoRF3dq5n7GKwaRJPI1Ql38xqE2Hc,188 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/output_0.pb,sha256=mMPCR1Esnn6Ww5w3SHz28klgLCsH3gnvJVLefjQmJMk,43 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/model.onnx,sha256=6Wcrg0issxxFNsBz_rGXOvKbXUyGU-n72hJJN61-2CI,203 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=a01KOwB3K7t7I9cZN-YI2RWzydygLWYRU-jYD3KV0b4,64 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=NU4b8D9taBjUcD7UZpFmlgF6rWEuaX175z8RcR5RV1Y,43 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/model.onnx,sha256=mAzQANQL7yGJEy7ea19UF7emkKR-DE01KeuoqCHsdQg,202 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=mMPCR1Esnn6Ww5w3SHz28klgLCsH3gnvJVLefjQmJMk,43 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/model.onnx,sha256=3QaNyMuspKVWgPGbu8UyFpN5KDA0HDFWjv1MfjOx2EU,178 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=L8bDbzhMnsmauRTvBHYtKfDGUrj8Mdx-crYz4NARWz4,23 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/model.onnx,sha256=NyD7Og13fGa5kHZILIXFTyBJOSeeDfXAj3_8fYbvGlc,177 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=TOI_r_i3le4r-O5Z1HZerCe0ZmjJ8KOtsHw2nY_Utas,23 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/model.onnx,sha256=Nech7zzE0avGRtbwgjk4rgQmC-ETA8Vlw190ScCnqc8,194 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=mNWtHVOjuoK-vYvbrudn6UlFXq2_GLE6SHlutihvD5k,41 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/model.onnx,sha256=3oeBxWFvIGk1KI4AtIqnKGfDCR1BsxwXeL5Oab3mFKE,193 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=fvB-o3vzCwkRPNYZVs6InuQtFic0cQ__H0AXKP50rmo,41 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/model.onnx,sha256=4kJTiebaZg-DH2l-PwkadFWRrS_qRv6g6wlGHd6xmo8,191 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/output_0.pb,sha256=7ok4vwYSfLvbWG8irRUQBo3WGLl3s_rgJXemrrJRqyw,43 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/model.onnx,sha256=FG6mPY0kRbr-bPsuhnL8YEQ7CqhltGMk34CeyL3Melo,190 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/output_0.pb,sha256=1ila67umCRwEUTp6trOZSoLm3kfR0zVDxb20FWYyRa0,43 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/model.onnx,sha256=H6lGw_WyHA59zv-lv2lHVTaCGqHgaR_o8-fIzuoyM3Q,205 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=7ok4vwYSfLvbWG8irRUQBo3WGLl3s_rgJXemrrJRqyw,43 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/model.onnx,sha256=v57sz16zLEhnsl-RVPyy7VG2D-oE7tSZprK6CUQCgdM,204 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=1ila67umCRwEUTp6trOZSoLm3kfR0zVDxb20FWYyRa0,43 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/model.onnx,sha256=mZmJR-3SFDQ--6G0CwQ6IGgLrtTA5b-y71gMuYmBQkI,202 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=-tM_bqHqK-65eWP1RbkvxizF8zO7aiimwgb1H-034CM,23 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/model.onnx,sha256=pJt_pNmAgxZaTmbxZ5b3hdtClp2QkSL01LaW9dh_2bA,201 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=gP6xq40fhaM6-e7UNw1HN64G9nmjUBWgSvnzS5itHHU,23 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/model.onnx,sha256=fidSdw3yQJhcR7P810Ln9DAy913jRkLjVFAu9Btcs2E,192 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=rUr7bDeYdFfv8ODlJx3VxZCObcOQawo6PvpwwxxVyVk,41 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/model.onnx,sha256=jfI2GTWwCBA7kYoQX3ltR7riRcXzCgAlFeoPExOcq6k,191 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=Epgb6VirPLNuYKYEeE3PT2w4qkKao1u3CNpZaiHnocY,41 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/model.onnx,sha256=Le5t6Bv1fb7z-_UeTOsYkbt3SrjnaPb6jhP9dSki1Bg,231 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/output_0.pb,sha256=hxZ8kmFTn4aU_veDr-LP4a6v4IilChYy9YIOoEVHfv8,67 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/model.onnx,sha256=_atfvm_z1owilbBcO4adKbxvsFAcYALNlKXooizYsdo,189 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/output_0.pb,sha256=-0ot9rCkyWkDhV7chj_oxYHNFryuggjVddq8z4qWjuY,43 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/model.onnx,sha256=gqfy3V7eSTxiQ6UTgXo0olNcckZHUIVCMwcA66HzVAE,188 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/output_0.pb,sha256=88XdkhxYXPjaDDn84q-yBWICKN6ikXDbVH5RuCm3EKE,43 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/model.onnx,sha256=vJkjTGTKvBUSYRnYDHfgxFcRK6bpa3pnZ5zv72-JPGg,203 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=-0ot9rCkyWkDhV7chj_oxYHNFryuggjVddq8z4qWjuY,43 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/model.onnx,sha256=-CMn2Mn2eWhFXZQiqj_CIu9RFb7a4aRudqjF5czzlgA,231 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=cQ0Q_SVFF2KsKqm4m_tH1qSv6sSiPriE2i1T8Ktnc_4,67 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/model.onnx,sha256=G2bxijVRgZn1JZJt3QGbNnDsx6oepsfIYamaUD3ZnxU,215 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=HZLley9Hbzlh5in3jlFTDghtNaheN7e3B8SBgGb3c-Q,23 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/model.onnx,sha256=YgsggPp3fCEIwJg8g4jFgLdE8B63jvYOY6-9e-G3O4s,436 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=HZLley9Hbzlh5in3jlFTDghtNaheN7e3B8SBgGb3c-Q,23 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/model.onnx,sha256=T5_7RGmpImy2WrH7D4FS1DbeK1RDqcoBhe5lXso9eFU,214 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=NbVoWb_YuZBVOJxwwGasGxSa91PqRFyopG8pwnsRrZo,23 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/model.onnx,sha256=ebE1RD68Ez28CPZdtFz8FpSt2dJWG4d1UDMpclNjjdk,433 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=lC3r53K5AzukLQcG3fTzO87xOCgaU4mtW52qktRUPUk,12 +onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=NbVoWb_YuZBVOJxwwGasGxSa91PqRFyopG8pwnsRrZo,23 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/model.onnx,sha256=WkoP-bgJbWSEOUCAEdtp5W3QII3v8-Lu3JZPPJCQyW8,205 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/output_0.pb,sha256=4STmxX1bz3tAUzg68411nc4sQSNZgAaUuYt_onSMO-c,41 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/model.onnx,sha256=j8K5jM9xaH8IFMLK1vgVR_CUSpxG8UKiWfstNYwEiI4,414 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=4STmxX1bz3tAUzg68411nc4sQSNZgAaUuYt_onSMO-c,41 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/model.onnx,sha256=bI3zRIns4YaHcHYe99iaPR-9Tyeo-1V-KRYYIFFtP8s,204 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/output_0.pb,sha256=Kt1q2dw9kUxmKY4qFgAWAqeJZUagnKjwuytTKfpNlts,41 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/model.onnx,sha256=g5FV8FqvL8og11KAIsxB-aD9QOeZ_HySCk0HtJGawSg,411 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=Kt1q2dw9kUxmKY4qFgAWAqeJZUagnKjwuytTKfpNlts,41 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/model.onnx,sha256=7HagD67ewDY4s8-74ByYvNF_IKR7parPtsg4XxhQ0sI,202 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/model.onnx,sha256=YoaYN32uRPsLreNfvjCxc_KX_Jlem3oWme5y7aHScPQ,397 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/model.onnx,sha256=GkzGXsE3RHJ7M4rnwI--bjcW4sXRzpu6wx44mNDsKKM,201 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/model.onnx,sha256=78ReP2FSJchrbXYkXWug9ZJL6Y730PQSUQAKVjXI94U,394 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/model.onnx,sha256=Yxeca3t4PmMBNd8A6SAYpLBOatqlLb1_xMJvfpvd9Fw,216 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/model.onnx,sha256=3C_RaXrAagqlPLawsYFg-ft6SaeCIhLt1HsCQrgHC5k,439 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb,sha256=PwPZEPZFRN46ucTDA7WJdQ6DZGzo_FrlkXVuDLJ8k7k,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb,sha256=Cq_UDeh4h6nFLBgZBAWRe4VLZgIhclppB9m_jRlZrEo,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/model.onnx,sha256=26kPF5Om3gzxIpg2VJ8IfFcKVvUtj36jY15NHrl0PkU,215 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/model.onnx,sha256=RhZS-1PyLcRMXwouw2c0XsXI297fSGyEtLo_cKcyQT4,436 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb,sha256=8pEDHKN1HYnY26qgXHG5QbG7pHwvEqss87VIYK8DU2Y,64 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb,sha256=T-ud1oynbPrU6k8obUDvYqxQoCsq0N-S_8SJKxthuBk,43 +onnx/backend/test/data/node/test_reflect_pad/model.onnx,sha256=EwXGwsGH_HicD_vAq0m04Vko7XeMKljNIK-OXT8Q6aU,160 +onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_0.pb,sha256=TuEz1ptAgJa6Qzh6nQx_rsYU5BVmA4qgVWNRPM7AEkU,256 +onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_1.pb,sha256=8s4uRhNf19t1kZ-BWDxuitcnY9MeHgkG6w6i1Sghnz0,76 +onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/output_0.pb,sha256=vRjclkAiKB0nuRzVWk4GeIKCHBxR-QZilgYP5DlBVr4,520 +onnx/backend/test/data/node/test_relu/model.onnx,sha256=hzHJyDRTlaWNI-jSCxr_WqNHCOSCwGYwlc2URQeJoss,99 +onnx/backend/test/data/node/test_relu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_relu/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_relu_expanded_ver18/model.onnx,sha256=KMFio-_6x2DXs7Bs_EyGD11Jy3eR-BfL3LPM9TW8Rpo,335 +onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/output_0.pb,sha256=SqNj4MYf1_XozMtqbVv31LmL5bj5_lZV-tOJ9tLs8Ik,254 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/model.onnx,sha256=PjKGdRIOuPqLW3sDdgcyg4EXa-9Vc49F4q7YG0O3Teo,192 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_0.pb,sha256=39jbCpQe08mPS4dsbK-BTXXytqtNJ2iXlQ87ZOq2p_E,16 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_1.pb,sha256=R5lCYdXFlSEYA9XjPU_Fjhx54__PbgfONnz-Qdy3NGo,37 +onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/output_0.pb,sha256=5DBO19lQ938nrN3x2OoaFb2OR5PxUJ0gS8dSub3omIE,20 +onnx/backend/test/data/node/test_reshape_extended_dims/model.onnx,sha256=NvpIX8BHhGVSwzajtT4jGD6DgwvxhC2JL_VnWY6ABy8,172 +onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_1.pb,sha256=WagSbqYw6WuUYvL67CYqSzbZnVaoUz9MELD3BuUy8b4,45 +onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/output_0.pb,sha256=IDzjEzlEsBbvtMbnKI40MRU6IcXAR1W-gqBHFiXjLJM,118 +onnx/backend/test/data/node/test_reshape_negative_dim/model.onnx,sha256=LOQLlfyiOY4F40QYZkXfoUvLy1I0mWHP7eBBqto1HPU,167 +onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_1.pb,sha256=_45XuV5dYHVVu7Rx1FGNnvotQy31w4eANzXAA3bGEdE,37 +onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/output_0.pb,sha256=h1F8s8Hz2FQZbHF9HSMXEHzVHS1_RFukvMhdN4ouMns,116 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/model.onnx,sha256=tk-0XT5pfaBbrwv76C2W6DbSDURC-EnaX3j_Zx9PjcU,181 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_1.pb,sha256=iuyo7JbFDNgl5IVKR0CPdvTCJjQfguS1qvi1qBtMvgY,45 +onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/output_0.pb,sha256=ZEJUohoXCbDgCdfxDVGfmH90AUhuNfiuq8pHSx7qi1M,118 +onnx/backend/test/data/node/test_reshape_one_dim/model.onnx,sha256=v_GiZfcqHwCai5yE__Kvod7SwDCAQkFcN8LfXIuiBVc,154 +onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_1.pb,sha256=FnE_Y1xn7VcaF4iHxUcnwkMCqpumPFvsjsIvG7gZE8Y,21 +onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/output_0.pb,sha256=OW1VHWrW-p-vlPhvSXpGxaAnh794jpWNM46uGjVODRY,112 +onnx/backend/test/data/node/test_reshape_reduced_dims/model.onnx,sha256=JnoJtz7AvSu27Js4SNt-kXwLDqOZSnOdad8_VhJ7j2M,163 +onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_1.pb,sha256=ouJ6_oGL8_HBKEg7fUJpxVLNhpa96Ql0goSY7PqqYz8,29 +onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/output_0.pb,sha256=X0SC5DZwUl-yurzky8NKAXMQ94Z8WqR5ctunKFK1gIk,114 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/model.onnx,sha256=kPgi4OW-hcTQ1KVSTXIt7UScYY-lADwO4i9OXIlvLt0,173 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_1.pb,sha256=WuXoFZwaDusBjM6stvBuiE2-ueq2hqpxw1IBgbDzXtw,37 +onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/output_0.pb,sha256=F3qOrvE7h1CQDCR8WwQFjdGHVYugNnpU2wa104F5rBw,116 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/model.onnx,sha256=BXNaclM2D9ZItd_ohM56pYgHez1_hWAlL0GnSeqCTjI,174 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_1.pb,sha256=g3yoG_7MeWVeyjtusuY4oWwwveQIuhkh27RQzhIr1HU,37 +onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/output_0.pb,sha256=J5J0ckD6rfn_-S4k1g8mo4qexsZdcE9w7kh_MMB-91k,116 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/model.onnx,sha256=L_KqHcUT4F67aW9jKOV4elpfgNwwQY3A7J7noDsVrh8,180 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_1.pb,sha256=fGG-r1bYO3tPdrYbBsKgm8rNOTpMVc43zP5kzaWsOc4,45 +onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/output_0.pb,sha256=WpdkH70wR430ATRzOjP79tz4aqDju2-ZGEjmriNmZtw,118 +onnx/backend/test/data/node/test_reshape_zero_dim/model.onnx,sha256=JYa2UV08dMTmIjGIG5D9YQFO4_EwJLyJwruXxd68phM,167 +onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_1.pb,sha256=3LQjg-0h7af-IHdpcviFQ7n-7bI2IX04SBTcYt7KGYw,45 +onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/output_0.pb,sha256=OMGl3G0rnNPISyblKGPC3m3crj7IOfBg606ZZ16iUhU,118 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/model.onnx,sha256=NvGAYLAArD0c10T1O5h7aaRuo0Q1N0ahZydZETAIdCg,186 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_1.pb,sha256=xPbOKT20LLRRzkK1NtGYUZK7K7jMcf7SR8v48R7Uaqo,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/output_0.pb,sha256=ZGnKaDrIFCTD_3Yb67GNTX-IVokI9Yr0bh9sWg6us-A,51 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/model.onnx,sha256=_ptXRcW2a1pg6gZDFiIp2ltFvXCRIbrr6ANMwicXsU0,258 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb,sha256=xPbOKT20LLRRzkK1NtGYUZK7K7jMcf7SR8v48R7Uaqo,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb,sha256=loFVIECPdfM4Elw8zNFWIE6JQTefZRc362LdOfJBgPA,51 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/model.onnx,sha256=H6KLpWckHrepT_R1YhD5UzEKXFtCOvzpQBFzkO10PRs,252 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_1.pb,sha256=xPbOKT20LLRRzkK1NtGYUZK7K7jMcf7SR8v48R7Uaqo,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/output_0.pb,sha256=2cgJqsQF1PGm1LLvvc9Dc5u6_YD8DHxfSgkKNV0gQtk,51 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/model.onnx,sha256=ofXD7K2I90DevflmIHO8Ht0p7SutmVeCu1GFfXfRXFM,214 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/output_0.pb,sha256=3RkVD_dvwVMDIMuTFJpRMSnAJZldXEW7WZL2Xy0xj2c,31 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/model.onnx,sha256=fTKB9Mr2RLtnUE-RzyOAC2ijKeCvKvh6CrBlOIHq_SQ,188 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/output_0.pb,sha256=uwev2yGwG2Wa5GUD8WPsgHctU1XZJ2Q1Rf3owfZ_XHg,23 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/model.onnx,sha256=tk8tGvNP6KtfR7UMFW9f3432SLvmf9pajyuugP3BiTY,254 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/output_0.pb,sha256=dqsdDkmbIHzYaAA5V1gXM9ft7EKPO8Y-qCfxD8SjjBU,23 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/model.onnx,sha256=3Nj5SptzieyuU03tjT2Ner6GmjhEOVmWxP3lbT51Tn0,216 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/output_0.pb,sha256=1_-7ZdcqfP_WMa26f4W3pwWFk__1wz_OV-GK-HZe9Hk,31 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/model.onnx,sha256=YcAcJ63zezuxLrBF3Vgsl1TeHMU2Ogd3nLiU7g4v1Mw,268 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb,sha256=Rdy6Z1wI0QCS9oqH-9p6yUHvF-avjYhyozZYTQRcSyY,31 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb,sha256=Pv1EkH_ZwWOQBY6LxFlPlTh5YDAg7UkXgQyPbkfGCTE,30 +onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb,sha256=7weLx1gkYyPrWb_hlbICvh1nnkQTdCCn1usS_9sgXoc,23 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/model.onnx,sha256=1U9urxLLRINgNwIM00veMP9fErOY5QRG5HW6gp9-kyk,190 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_1.pb,sha256=_MYqurm3S5Sgvkddd59VRpxNIVlImSmTr8O0q7TgMZc,30 +onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/output_0.pb,sha256=Yjo_9cj_fib7n4VQV4PsQKY-y5v4-quR63M-EkCrzT0,23 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/model.onnx,sha256=6a46eIOdy_Qs4SxCR7ykEV9VTZVM4Og3pqd2DCtDjEM,185 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_1.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/output_0.pb,sha256=PiAS9GWaz3sX0Gf6Ln5Psc_9dku3ayUWL5hHq9vlzg0,51 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/model.onnx,sha256=4C6ccjEJ_YoSijXTgxAnK0FhhksGC2Iv4_DED-R_3pw,213 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_1.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/output_0.pb,sha256=FQ3KdwTmOlBZYLC7nxQY_fHxEEzwuIxommP9ItoqBUg,51 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/model.onnx,sha256=rGpyoONA3briRF0UkgzM87GAVUswPHrGZ_D9U0K1IFs,215 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_1.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/output_0.pb,sha256=4k2fzRJDvP4TITb-F963MxhGFoSpmv4Gcm1lMFsOqfM,51 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/model.onnx,sha256=VAAd9-jPn5WuhFovIXkyU76g8UAn2Wg0r06aNIiyjxI,263 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_1.pb,sha256=37sn5EOXGUhf2Y-K3TqAz2Ass_BYayom8mdmnc2h1GU,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/output_0.pb,sha256=iKqRlP_EQPX8v6QT7KLRSmrzOZZLemzCdmj8tuVgPXo,27 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/model.onnx,sha256=StlILIeH-jdXqhApX2vrq_z1APeoJPCOA-35PsZ8gA8,189 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_1.pb,sha256=EWQ2LRMYiDUHb77tpBRK0ytYOpI4T28MtPEOhezLW9E,45 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/output_0.pb,sha256=aBoGDHQgxT27m_eQuySjStIVzhxkJMLWH0A55bFbQ5g,27 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/model.onnx,sha256=eK6kffmxQ8WVtiuCHLZ089AYyS125sPEDrPscMxc6zY,258 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb,sha256=Ee8uWnujoqYe5BozCljVH-jTkbA4JDUotF8GxhXEZcw,29 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb,sha256=Yjo_9cj_fib7n4VQV4PsQKY-y5v4-quR63M-EkCrzT0,23 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/model.onnx,sha256=d8DDUXajzkKcuKIznrnN9NRhDlHs2VPMiTFH582mm6I,260 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb,sha256=nioMVoUI5wFpgq-Sa9rYpJCbdtubhwaRAM1ym7zDzAQ,47 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb,sha256=Ee8uWnujoqYe5BozCljVH-jTkbA4JDUotF8GxhXEZcw,29 +onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb,sha256=nAc-MyWd9nHy3TljFTqiL0XzUFYlioeLyRGpZB2Jvcg,39 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/model.onnx,sha256=O-2zQZRkhoy2_cGlaqxqmuwF0lhUP2kWArr3n21yryY,293 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_1.pb,sha256=jl82DpC9SOeZy-jQNk9BvM6nVoa-AgSa4ZtTT7709dc,43 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_2.pb,sha256=ndCok6I6o-QU94zqs5ITMbBNfV2gqQXoarYmY5fVKn4,45 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/output_0.pb,sha256=-7Q9n5yoaXsRRZsDvOtF_c7_YynJmUkeIQgW4rp-zKg,51 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/model.onnx,sha256=_2wYb0fspjXsFxSYql6wFFoiYH5J6ERjjUySWuCyDgI,285 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_1.pb,sha256=L1L2x0-QpyRLeyyjk73mjV7FdzUEAdNemEV0WbcZZWk,27 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_2.pb,sha256=vAIzVU8L_NauQljYoNRgwEqyRXBRLAdxNa_3HqjbY1E,29 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/output_0.pb,sha256=WpJZbrC4oUGdfU2pRJ6Z34aitFfYz_OpfxWpEoEouiw,51 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/model.onnx,sha256=syz90aTDAXM38gNXnKbP5XprnVCIpl4IdhAT-knvE5o,285 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_1.pb,sha256=tAApf3H0iSwfk8uTYnN5NBF8goYF8jHTlgp3mRG7wGo,27 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_2.pb,sha256=vAIzVU8L_NauQljYoNRgwEqyRXBRLAdxNa_3HqjbY1E,29 +onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/output_0.pb,sha256=WpJZbrC4oUGdfU2pRJ6Z34aitFfYz_OpfxWpEoEouiw,51 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/model.onnx,sha256=QCvkupq4I7UtNd64GHm4u1q4sFe2Zdh_ma1EMZ3I9N8,184 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/output_0.pb,sha256=PkSU-XfoDiJLcyLNeQLkN2A9yyc9hXq4v8nm3UcPKq4,272 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/model.onnx,sha256=6mHAIPWMNAum--EwaHvxkkk8c6Dw5IECA-hnxGk7a2w,256 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb,sha256=0Ir5vu-hpsCeNPtx-nUkliiu-Vgm06Vga2TF5lryblA,272 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/model.onnx,sha256=HCQFmu-zRswTfKUSrVJgMqqbqXFvpU6tboIabJfKzF0,250 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/output_0.pb,sha256=AQz_0D5lp8mVlVoHV99xYl1kRmT-i3ZSaIM-2oAmHrs,272 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/model.onnx,sha256=KR4j7ABjJ_jI_hsrjX8JtttiB8Dwbc8A2b4jEfuR1Jc,244 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/output_0.pb,sha256=QmRUXe9rBd0mYIQPWDFpFGFADYvQFVySIweV2tFBvNE,272 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/model.onnx,sha256=mEZo_9rq5fLFehb5FBaV3bKnFUBovWAzdhzhbqdqEqk,186 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/output_0.pb,sha256=fAWEWdC3o33m0DECLq7pDzMgk2P9M_AUYpA6oJmR6cE,79 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/model.onnx,sha256=Ai1_ehB6rOGR1GQse3CvLwJEB9YCv7kiLWebSYLJYnk,252 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_1.pb,sha256=w8rot1dlQO8XzaRmza_A35JMaO-AnoOi9EtykBJy6kI,30 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/output_0.pb,sha256=7Bpwq1ECSX1fKctUVbWV7mStOAMzyI6P5euZ310sOxQ,79 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/model.onnx,sha256=WlGAguzzIkWkkAo6ZfAdQKnSHXL50WIxJ1Zhr0oVw2I,266 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb,sha256=YuaMw9nlwphEIBDxyW46Wap5f3nI5zPV7UYjoA72gmQ,30 +onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb,sha256=e7ETAXX5wHi0EZN5mUMvRnkOxNAyUgy6trbeSN7uPvQ,95 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/model.onnx,sha256=UQqEcTdiIlMdbcPIRMa1I5yM-Qa4RUC7AJelajIyXlE,188 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_1.pb,sha256=3a1OyYYNdnWsgKm8R9EJ4Ja-reMSXI0q04mtA4aFGfo,30 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/model.onnx,sha256=UQRCvBkSGiUgcqs8e3NwS0QUfkpF98phMycKdiYKCOc,212 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_1.pb,sha256=eYyQwyy4YgQ7gyB7cQ3EFSsVJypSRA2sAIsgdo6QPqc,22 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/model.onnx,sha256=N28Zs0qhbIprNOqoC7UKiuHeSpsTIZb8DnTfNHD1sLk,212 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_1.pb,sha256=mmDREgvzTwtEpDJvveHfvSZRixUEC3EI5pPND3xyE7s,22 +onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/model.onnx,sha256=RIKO4GXHzXsw2M5N1YgKGrWkMVqZwvMbs1er6OpPCDs,183 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_1.pb,sha256=nZ1sl7gz-g_V2hXQY5LuvuGaUGoBw8yTWrHeSJMcosg,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/output_0.pb,sha256=EAIMP98RAbzoToZHuzVJfftxaZYNj-guraY2RAfAc9Y,376 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/model.onnx,sha256=6-rxY2SQvDXSdskmMVaMM18HbJfpurkKmvbnI_6n9lI,187 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_1.pb,sha256=1vs5j9PloFBBBanpvHk9w3ue44PVRJ1eYMbKK18UxOs,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/output_0.pb,sha256=j2BVQHsxg5m9FtJaMV_08Y721i4ReIh15UcV_iWXsgA,240 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/model.onnx,sha256=mf61AtWMlncmh64F_VcEHZgN5R65F3gcLtugKrNVWxY,211 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_1.pb,sha256=bEY07sadyrUqd56CgpL2kpJOof8lkigI8NAOAw40NyQ,29 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/output_0.pb,sha256=j2BVQHsxg5m9FtJaMV_08Y721i4ReIh15UcV_iWXsgA,240 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/model.onnx,sha256=sXWUKH1vVFpC8ZJXdWE1Sunu6Ts3hkVax_wWRNeeujA,211 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_1.pb,sha256=lOngZJhTLdAR-LZ3kvPtpq3ScjST_SQb8On7xErMt5w,29 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/output_0.pb,sha256=j2BVQHsxg5m9FtJaMV_08Y721i4ReIh15UcV_iWXsgA,240 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/model.onnx,sha256=4KFn62-_PaftnFvGvGKF0dj2EDdTyyHL1W_Ttaajtz0,277 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_1.pb,sha256=TQJhADxzQwfIkkc2pen1_wFd2i4A0mEwyy0xjW-97n0,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/output_0.pb,sha256=3eAyujmk4k2eAAy3do3PVMqPf1luKx6ThRenNqxaA3I,272 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/model.onnx,sha256=4NEEGSuIpI2t0R7pzQcaQFlJezciMfzLBPn9e0Rwsdk,285 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_1.pb,sha256=TQJhADxzQwfIkkc2pen1_wFd2i4A0mEwyy0xjW-97n0,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/output_0.pb,sha256=sFAaFbl0e1cItIPWKmEoGnPpo2FsJFYi1U_Wq4Ugh2I,272 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/model.onnx,sha256=3ffqPpmk_CBgwSqt0m_4hxKlF67yac4BL9auePr2jLo,257 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb,sha256=bEY07sadyrUqd56CgpL2kpJOof8lkigI8NAOAw40NyQ,29 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb,sha256=8clDIxBXkyuHVQ323HmQekDO90VrPFq47TfOm87Njkk,272 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/model.onnx,sha256=N20l0fhsa8cnQ9SdtwuvD1nO5NknKOe_GsNjBvhia3M,304 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_0.pb,sha256=MEKMWYHSTOeX7aAtTuIDlSJhbhXnd5W9OLBmeaNaDPE,79 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_1.pb,sha256=TQJhADxzQwfIkkc2pen1_wFd2i4A0mEwyy0xjW-97n0,45 +onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/output_0.pb,sha256=3eAyujmk4k2eAAy3do3PVMqPf1luKx6ThRenNqxaA3I,272 +onnx/backend/test/data/node/test_reversesequence_batch/model.onnx,sha256=a3VXmvzlI1t3mIA2hPjhmYHL8fri4xP1_u1ZI2uG1Q0,201 +onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_0.pb,sha256=SkEHD0rsxMgSTW_tjWL00vAdiYAszJiX1Ksx5YSBdK0,75 +onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_1.pb,sha256=Wt9-cJ901jGUNQSJpk5jrUaamSkE48Z9G1veqRrgm8U,53 +onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/output_0.pb,sha256=X6YMiU-O_e2z3CYNrjkrVro88Zp9gYpoMd3iIeQPQ3E,75 +onnx/backend/test/data/node/test_reversesequence_time/model.onnx,sha256=wBxZXx0gVDsbH_UOz8PVsQseF_R3ghgk9fCDrov0lNM,200 +onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_0.pb,sha256=QhzuL3tyAa1nIihKr6jZUzHkfu4GTyPlq0GErxTiLgI,75 +onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_1.pb,sha256=Cq6df1JM6R0nUUd50ZJO7lz1h-jhb2YzMjuCxeVVIpI,53 +onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/output_0.pb,sha256=E74my-HnbjLGI__m_D9lTIR8sU4qlEEDW7AagYb5d8E,75 +onnx/backend/test/data/node/test_rnn_seq_length/model.onnx,sha256=XVN6KM9qoPoLCSpS-LC5Uif_k2fTmGylbZbPBhVMPX8,215 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_0.pb,sha256=fFR4OIXWBj5wmFEuZbfl7GOhhRaSJv9tEZM8VbjQ72Q,85 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_1.pb,sha256=ET6TMaay9jqrVqbna-Wnsfz97AB1cb3OoixzzqcB9SE,73 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_2.pb,sha256=8OukqSSCHVpI2UW8Qhn4j9Y8PmzUUWI2y2Qi7j-l6EM,113 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_3.pb,sha256=YPIH8tZG0ntqRQMb2MWtwnrFHQBCYUBq9n-MBS8rYck,51 +onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/output_0.pb,sha256=J__yfJ1bCTGPdlxsojDRQtQOq4aNWQq_os7EVw4DTag,75 +onnx/backend/test/data/node/test_roialign_aligned_false/model.onnx,sha256=8C_p0IzC5tpFL3jzziJF9mIyZXKTvy3ML9GjhYmFHgA,352 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_0.pb,sha256=MAl6mj4EdjRRLLTTrMR3QypOOeqBR_zfDSrKfI5ZOIA,416 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_1.pb,sha256=0dELrNhfMRb954VgWZmrlXZ9foqomY7BBxzVO39h3F8,62 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_2.pb,sha256=KBLspuA99QkABElyuFbkwAASK19MfsWnSyuLyOuuhlM,45 +onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/output_0.pb,sha256=pBkN2eAHpzdKOrULgdFPb1vBUZYLEkshdoLCpFRszj0,316 +onnx/backend/test/data/node/test_roialign_aligned_true/model.onnx,sha256=8TfQUVxJaPzuFyO3vePxwCS-uoGGTMWt1bfecpCacK4,344 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_0.pb,sha256=MAl6mj4EdjRRLLTTrMR3QypOOeqBR_zfDSrKfI5ZOIA,416 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_1.pb,sha256=0dELrNhfMRb954VgWZmrlXZ9foqomY7BBxzVO39h3F8,62 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_2.pb,sha256=KBLspuA99QkABElyuFbkwAASK19MfsWnSyuLyOuuhlM,45 +onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/output_0.pb,sha256=fJDZDLjphgnhrq0aWFk-lPD_rGXn8507MnHb4SivShk,316 +onnx/backend/test/data/node/test_roialign_mode_max/model.onnx,sha256=qA9lxKwQjJyeCeuPXT-ghlWh3eeAHrv9WbYGRf6zIC8,363 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_0.pb,sha256=MAl6mj4EdjRRLLTTrMR3QypOOeqBR_zfDSrKfI5ZOIA,416 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_1.pb,sha256=0dELrNhfMRb954VgWZmrlXZ9foqomY7BBxzVO39h3F8,62 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_2.pb,sha256=KBLspuA99QkABElyuFbkwAASK19MfsWnSyuLyOuuhlM,45 +onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/output_0.pb,sha256=TlRBT6bTd12HEPhEY2vPxZQBJiTCRcgxHzeyBj42FE4,316 +onnx/backend/test/data/node/test_round/model.onnx,sha256=0_cMKyq3iOq-UN-KzMuy5pMzwSzaArLwpXEGTYI9Kkk,85 +onnx/backend/test/data/node/test_round/test_data_set_0/input_0.pb,sha256=cHlnrY3Uk-RbEkYhAli-6AAm8OTVLrXCadT3V-VzqNw,69 +onnx/backend/test/data/node/test_round/test_data_set_0/output_0.pb,sha256=ZsG9a3LCPTA8lsuKatNZHi17ZVfdZb_L-nBR-4mezCI,69 +onnx/backend/test/data/node/test_scan9_sum/model.onnx,sha256=xhD2OrUhOs2VRKs6i0A8zGY4cRF7JoXuzLcr_HiazMA,350 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_0.pb,sha256=BnhbN_OTtCNX4M6io3UpaIpvxLzrzErNVilo4coaHGM,23 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_1.pb,sha256=t5reF7GY_oHbl7Vv4kVs1SoxvwpCDuisZdvKyL_FV-s,35 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_0.pb,sha256=1sTPVuO9wgsKDIg1gHRzhl3ErtQ1AkzI8laUM5YnrsI,17 +onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_1.pb,sha256=HL309oJqNALe24vCksVqGrZ85esldvFHCW6BJejssMw,35 +onnx/backend/test/data/node/test_scan_sum/model.onnx,sha256=kx8UnHYF_CHpQ6CMgieEJsQM1w9FuxdOFP70-ekGUfs,367 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_0.pb,sha256=hft6PG5mqQ8I6v75s5v-STuBVSUl7jLRHCIYXQvvY0g,25 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_1.pb,sha256=AYFDqPhKTq-30FDGtMNfVnNc7S63t8gevJZ5mCzDIuw,37 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_0.pb,sha256=ATpWiBkuoiOqvU3Ad2myqm3WbAGmyrxfQD-VAfugDM4,19 +onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_1.pb,sha256=LHi4F8MFmjXkX1oYEtIO2SOeEooNoaw2uD1woEvXUi4,37 +onnx/backend/test/data/node/test_scatter_elements_with_axis/model.onnx,sha256=WK7CTrPZTogMaBWL4loizfcx-n60FSOvqF_MFwgOZ0o,216 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_1.pb,sha256=yxAkaBm3PWG9VJ8QL9zIHyP9dhDU0NmwftHGiVWTbmQ,33 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/output_0.pb,sha256=JcgSylIhYN2e8u823w30DFfY3PA8sLsLxUDtn6dGNxw,31 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/model.onnx,sha256=zH2xipnpOkq7FoVC7cDl8imEpz-5zW72QybRS9EgoMw,250 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_1.pb,sha256=LtXsziTJhM9eu2tV2pF68OB993sF-YaVhWI0izz49TE,33 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/output_0.pb,sha256=DjROkWNEJO-bgVoEdccRipm7A57FFhCf5hpJbikVJYk,31 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/model.onnx,sha256=NmexRxrBS5OI5SNRqpyS67zwEpZpnczkzobgHpRFke8,228 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_1.pb,sha256=q0Fin1pAQYBdnSVWMB4WrxdLIAqsz7cEIXK1wpL7HU4,33 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/output_0.pb,sha256=8VeVc3XRkIkfpRbJcVpn2e1uRLVVYuqOH4P1iLBaecE,31 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/model.onnx,sha256=4LrnmkHzDZ3YI0LeVoU5GVjge3pUxV5gAjfXeghreb4,246 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_1.pb,sha256=LtXsziTJhM9eu2tV2pF68OB993sF-YaVhWI0izz49TE,33 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/output_0.pb,sha256=WBm964VPNdWt89-yahLjj-RvVplFLut4ZXE0dfnAUuM,31 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/model.onnx,sha256=0vsDUI5GdeNGWs9SnbEn8Z5XYbneMDWgNTMATmhNkts,246 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_1.pb,sha256=LtXsziTJhM9eu2tV2pF68OB993sF-YaVhWI0izz49TE,33 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/output_0.pb,sha256=WADdYmrlyUDxTlC66OZ4XSg_-wQyGi9T4zlov7eXuVA,31 +onnx/backend/test/data/node/test_scatter_elements_without_axis/model.onnx,sha256=5HX0on3L5s_YHj50f0VGynXETPH7KT5qPkvhRgMB34Q,206 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_0.pb,sha256=DiaJ-ROL20bBztx5Xg3H7swSLlKyglCXlmncvXA-HPM,50 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_1.pb,sha256=WXUWKy1f1Dr3A5TpL6asvPHu54JotHi6BQUtGRE7JOU,65 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_2.pb,sha256=FB191eliy4ig-YiffzExk2oVes_SQmX9mHmi6f9Hfh0,41 +onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/output_0.pb,sha256=LNLuWCnaX_nnESo8S2kfkcdAP2b_Prx7HAGSQu1nZGo,47 +onnx/backend/test/data/node/test_scatter_with_axis/model.onnx,sha256=mCeJdeuAWeQ2cIfU14Z4Ak4vnlKz1CmVH4cLSsFn1Jc,199 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_0.pb,sha256=FNuWkFG-4ZlMWvn8oE62jKzYt8GdCRtfDkBYNgeUSmI,34 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_1.pb,sha256=yxAkaBm3PWG9VJ8QL9zIHyP9dhDU0NmwftHGiVWTbmQ,33 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_2.pb,sha256=JDlgg9wBEw7Afkr4_suXRgyDMXlDVfbgBJOPnls2jao,25 +onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/output_0.pb,sha256=JcgSylIhYN2e8u823w30DFfY3PA8sLsLxUDtn6dGNxw,31 +onnx/backend/test/data/node/test_scatter_without_axis/model.onnx,sha256=3PIZOZHIxXEr-zqvEWLoqwtdYL-u86zgSDXLv_w1CX4,189 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_0.pb,sha256=DiaJ-ROL20bBztx5Xg3H7swSLlKyglCXlmncvXA-HPM,50 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_1.pb,sha256=WXUWKy1f1Dr3A5TpL6asvPHu54JotHi6BQUtGRE7JOU,65 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_2.pb,sha256=FB191eliy4ig-YiffzExk2oVes_SQmX9mHmi6f9Hfh0,41 +onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/output_0.pb,sha256=LNLuWCnaX_nnESo8S2kfkcdAP2b_Prx7HAGSQu1nZGo,47 +onnx/backend/test/data/node/test_scatternd/model.onnx,sha256=bivVceLLPAvDCX2F-7S7g_5V1KP_jTWUKBb1I2EHJVk,192 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_1.pb,sha256=qUcsgYavSojoDVEkWYR3mzbddMcAMBPdRT4-G56dq1A,33 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd/test_data_set_0/output_0.pb,sha256=A6LOHrpDiF3e-qhcVGjGViue1VwB_INvC3ybI-jpnVU,270 +onnx/backend/test/data/node/test_scatternd_add/model.onnx,sha256=pYn7qepwWYvAL_DUNkJ_frU8pMhPl_hWs1xJXhPpCbQ,217 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/output_0.pb,sha256=Pg4VIAYXcs47zRkEaqMYymr8C5m7po7X2ru2phvlYow,270 +onnx/backend/test/data/node/test_scatternd_max/model.onnx,sha256=SFfA1SCU5HdrgvqZhqwbCFhbtT0S4-jAidV-Q6GHYrc,217 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/output_0.pb,sha256=H01S0BHgoas9UovgsbP5Z6NrAjVkCQuZQQFdRv2GsZ4,270 +onnx/backend/test/data/node/test_scatternd_min/model.onnx,sha256=YhCygCjRYWyVCBFo5iaYsG-pGLn2HK0wgTIP4bnLT_M,217 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/output_0.pb,sha256=bxnp_Su4TiWAgetLLCEZyk0yunmaFzrwlozwz9H8iaw,270 +onnx/backend/test/data/node/test_scatternd_multiply/model.onnx,sha256=4_A5H04c4XRoD50uMfujmSqh_Gq2fmfB3NRx4s7Y8Uc,222 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_0.pb,sha256=mKV4k_mYJEXu-r1W90bshbQV9QMgwkHwf9xQ76Rngkw,273 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_1.pb,sha256=yUrlT5iCIq0_2sUQNf_ql7v3LIeB4ZdHnA_kjiY6qE4,33 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_2.pb,sha256=RShGkR2PNYKvBsBx83gqCgu6B6x3ly1wRWNp1JFTHH0,148 +onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/output_0.pb,sha256=M6TZol_avnQUDu8YK3eANT0kknICIs65yucp2T0rXfU,270 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/model.onnx,sha256=4DjLogkrqhacIeo9bDuxaXEiMj2DiDf63gIqEnmOAVI,231 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/model.onnx,sha256=ePNl_XFo8EbbDr1TohiYMiSTY27lWaRUA4_IJwaNPGg,1672 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/model.onnx,sha256=qPccBQaYpxSGbNs26guvmm0OVSGVuLseoBdqhQkDupk,282 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_1.pb,sha256=OVOOloRk_LlopMXvzfRiT17U7xyjZZqdiZtrcdp54gg,381 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/model.onnx,sha256=AwsPBxuS30rFBhQkQTpFjzIICdDK5WR2BKxRlnHweUo,1959 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=qupP19AFkVGsd5p_IG3o67eqQmCi4VOmIPPH2HatK8E,374 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=B1l-vlt8ntQR6mMtlxFwTx5L-JRc48LxU5URv95CBwg,156 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_2.pb,sha256=S4-FwQAxtH_avU6Egu10Eg7k2WkcisObX8kZuTMU1HE,29 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=T1FHwvvDgmOgW7Wcdac4m7Ox5leiRh7vEpBMM_acaaQ,11 +onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=OVOOloRk_LlopMXvzfRiT17U7xyjZZqdiZtrcdp54gg,381 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/model.onnx,sha256=MkIxoow4nc3DSQ6QRUyXxgMXTGo4pnaGmVlsr_jFTPc,250 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx,sha256=b9f_7RDCB-p-c4xXii_LzXjE9b9BFG11eI1th4gN2rQ,1789 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/model.onnx,sha256=3dTRTlrZTBHv1JlBIrcvxSxLP4TUTkV5y_NM_2_6_Dw,309 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_1.pb,sha256=WwTHHroM-9FFzxR9_T4rNpxcDfim9TWe7gZSOyW9dmo,10825 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/model.onnx,sha256=77p7YOdBc-XatsOyn3QWF8kD4Zdj1aW0GOMNJkbl5Ag,2091 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=Oj0wAqZWCkppXwBrkc88a6tsGSuIPPixSSKyu-0iAFI,10818 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=4RPKO8gfYFkdhvfs-BUDko5KhATj_U0MJsqius0TDBI,4336 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=la3r1KC4cnxtWqQmIjhvr5g6d51CtvveNgyfB9dH7ow,2176 +onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=WwTHHroM-9FFzxR9_T4rNpxcDfim9TWe7gZSOyW9dmo,10825 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/model.onnx,sha256=6CST92qbIJai61Z17kv2qWUliCv-4jNORS8i5bswDl0,212 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx,sha256=j8rQDC-MWlFg87VAcZfCrhS-lslAMKA7iW7AzyDfaGE,1639 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/model.onnx,sha256=y8kNNJ56nd8PSzLYECLjEk8XwCDpSWdysau225CSpNI,259 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/model.onnx,sha256=FtGQ7KjUknKScU3L1SUUAIS4gpaqr30ixmBUQ6-REc0,1921 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=ECSYPd0TVGdd40h-c438gJx2ydi3K7_5RBP4JFP4my4,33 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_2.pb,sha256=lv65FooWlI3jBxoDOoZFOvy7S8opPsYwNL5tiia8U3U,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=3aYW5UER_i5SRrjYt-SDD8VMa-GvcwrTG9Y9Qc-5CYk,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/model.onnx,sha256=15CKZ6DFK9pgqZwiJaYE8xGF3rBGiYCjA46GWKXt9UE,229 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/model.onnx,sha256=a5I16sJlQjIhADbyISsEp2VJu6iNrYzHTWlcQM5f6As,1614 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/model.onnx,sha256=YY5-0tZwDx90tQD82OBpjTbmRqdG_OKVunHsjH6mhfM,296 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/model.onnx,sha256=09dt3pvbvWp5yUKOS65ubmHCevNtJ21KbCjeUPF8rvo,1913 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb,sha256=7c-ar0sMCQdJWPdtJ0UpaFamw1FPHpEbrzYZq0LmkLM,29 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb,sha256=8TWjevDFjBey-IIoPfPMfeoeTsioE4dSFepfqkKERe4,11 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/model.onnx,sha256=ULvWGcrcdSA1N_SUhkV1a6n2qI3MTPLeqWhZdqgwUz4,236 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx,sha256=x91VgaxENlIQOA2y-v5mUc2FFt5VjHG8Gu4KDmrUAyQ,1663 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/model.onnx,sha256=kuUxbSd2Kk-OVlzmBwsJPV2hJYpFtd0IJXqvKo4bffw,303 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/model.onnx,sha256=2tcnV4ot7YtPLDc2hrj134D1hYL78w3GK6ST4G-DkiE,1965 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_0.pb,sha256=4ra_fFZovmMBj-YqaUnvA-maMuOR9tgeNMc5Db_5fk8,129623 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_1.pb,sha256=ZB-f_6ZfwtvBYdYj1AmZYVZkOrWazb_X1yow65GR1sQ,51861 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_0.pb,sha256=QG6n-tNdHkQgVv67CaAhmakmLGNLAPn0d_3F0ZQcLhs,25941 +onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_1.pb,sha256=XSkwM4eCCjrPXkQeTjFxrP1R3X8PGrHLj1UaChCsHFk,129630 +onnx/backend/test/data/node/test_sce_mean/model.onnx,sha256=3-aUSOHOXSSfPlQt8uevWOY0JebH_Kfy4U23ceBqJMY,148 +onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_3d/model.onnx,sha256=b5f8KkCsoJ4L67xiLvpfytT09dUUaLEcgfZ5ROroihw,160 +onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/model.onnx,sha256=q-u73xENPehluTdlJWM5_LrRkAcNfHTrB9OHxLcaTIw,1305 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/model.onnx,sha256=N0mTSdtEJf0VC6pr_80Z-iH6lZKHqyoFLABQN1kInU4,211 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/model.onnx,sha256=Pw8adJBkNBaFPyqtq5nf0C6e75H7tSROEtcmDhevIzo,1572 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=kNoEKy3hlfUjU19ueKYQpkIk-4x7sch0y0l7QJwS_fE,59 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=miNyQyEMweya7bpEMp1TzAzXJzFp6xF-tqsM_YwAgYs,11 +onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_expanded/model.onnx,sha256=TfH-LhShXm0l-eXwnqag3gi4pGL_VJtIyTjtRDrji5Q,1252 +onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_log_prob/model.onnx,sha256=rVrCzG3FrS3dBFUDfVMIr4uj_G-SWjxDAxT9mA1mMqc,196 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/model.onnx,sha256=xN4nEG5gFvD7tP7DFSD2UsbqWMpEmdld0fnUWWQjCmQ,1512 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_0.pb,sha256=ukRi1Wf8MHKfHhzBXTTjokAYLg59piNsWW1WCJoZKbQ,11 +onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/model.onnx,sha256=SBpEoe9urLW0rKeW0Ac3BzNiwtc9v4bMTW1nHNnHRuw,183 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/model.onnx,sha256=hiUDHPE0pIkYNzMom_XlZLWqOZEGlpnDlhmVoXTHkoE,194 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/model.onnx,sha256=NPfg8j3S2-3d77D-bWCAA3P_paurP1cRDZHhkRyN8oE,1522 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/model.onnx,sha256=HP6L2jRokXh1_vYgTh-CA4Pqpu4mw5sys0ZaBECvzic,245 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/model.onnx,sha256=jEDXQgGxGjSzMNfNn48mwHMUbpfHPNAxWhW2-iA0P7w,1802 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=I4cSUTJG17QP5oA6xVZKsUhMOd-3Ykysb6WzcbuY1m4,59 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=PFOkOYcvliqNXtaW0RiMuvEKPotIC1lrIuQlASKuwqA,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/model.onnx,sha256=A8FoRpgKtUOk4tOBHau3h4ZipX4Hu0RxF8-keeJwghw,202 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/model.onnx,sha256=X9nRxKLRogAJfBTFCU2G6-HzYKhMp3ep4M7EwDmbVNE,1530 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/model.onnx,sha256=sYLdAh9Wrfmia2nhAuMOFPnatKFH9bxxgrInChYqFvQ,257 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/model.onnx,sha256=RCwsAOHhRl-O5bFL_b4w-Ua5wUTSr8hufvHwXzTZTaA,1814 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=T1V0dSN1m0drt7O148bSLjanf8_Y6jYvzLcOyWMeUcc,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/model.onnx,sha256=q9QvMFTS8OztLXMlaXeKvt7LRrVmnlPDm5020UaXHkk,1469 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/model.onnx,sha256=j7HGJhVhHWH5CFK5UID5XF2ctIy43BXBlsqx6KmPFwU,230 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/model.onnx,sha256=VzorXg051TojMytCig-YX2oEh35Gmuz_mQ4M5S4WuAA,1742 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=RyZME3YrdXmqynJj4q0osF7rcCSLXSIG2ufdzx0CWNo,33 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=-p2yYFxEuzJ3QVJAAEY02AlKOWgqfAh-pYOeft2_X-s,11 +onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight/model.onnx,sha256=FDtFwSxTJi2o6AxnBuYfJ50s5T4D7mCELpj0DsZLVbQ,176 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/model.onnx,sha256=8YacVoGPm3GpfQQDrJMUjOem0zDK5U7sgwUptKajO7w,1378 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii/model.onnx,sha256=ubPeobCw3w8cF0I1Qnr2L_N6wGyzQ-0Wg3F7v_mcUcs,200 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/model.onnx,sha256=NsPI86Dp0m9do2WsjEkCA9R1JcYaMDi1UcDhrJfn5xc,211 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/model.onnx,sha256=2FoQTNK043NuohFyUgPwpRNlhzDbhO_aLT6cBQ4lAcs,1497 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/model.onnx,sha256=bn4-smvay63gs1M_duVEpUKF1r0LYcHjChuS97GXypA,262 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/model.onnx,sha256=r4Sxfan1qnUwWoy2WqbrGK0euPoX1xB5G4jyHLnY4Qs,1774 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=s6b0VpPGzh25cOop7adn57jvPue13bYBiWeyf_RrcfQ,133 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=trcZ3XMzOOuOFUO4W2aWJTmt7OFdWqdw8PCSQR0mprM,59 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=qsY4ogfxxosqu-qK9YR3AW7Hq7r51jui_D3hT_1Vvxo,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=kvOCYAwJY6k1Dxx1Zl2374xcARw1xSaVCGAyNt7GDto,140 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/model.onnx,sha256=1AYaMPMGNskTnRJg7Y0lDPeEYqOEtomdbz3rfcBZNmQ,219 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/model.onnx,sha256=C2QnHfrdT3fox922LPCYt56dqOh7wv0hzlesUZKm810,1505 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/model.onnx,sha256=7jOM2AOOk_vbCzoIpmYtfEEra5Sk_CesOa_8wQDLxdY,274 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/model.onnx,sha256=5D5IXJS0E3jfGyP4bKSC3Xxxx-Py8x_L7bLfsgozeZQ,1786 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb,sha256=TfLTx9UrsR2ZmBWzR_7JZlnzgcwoLG9VbMGWmwiRBYE,856 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb,sha256=YqKk9mWOW1FVsAOz4P5b4Rkm3_Opfi4966ewfW81WBM,350 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_2.pb,sha256=NfzalgiAf2wCTk7FTCYv25NIOkkHFSogWvLGFqvdfq8,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb,sha256=84SOfKbFoEmqcmwtI0T00WQkBlWevdpnax2C7UfyKIs,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb,sha256=w-EurMdSNKZnr-TaXWH4MRaTpJ4Oj-02F1ZbQw4Gch0,863 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/model.onnx,sha256=j46HBvdOCXuiQR_0FH7hr-kTwUuYykrPqZCq_hYcUps,1444 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/model.onnx,sha256=IdUuxD1i3D9ZVQBa2r-E7cBsRGa5pslBpvLxNAvIRuE,247 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/model.onnx,sha256=MZDb9GUNI8EDzj_6fsm21bEEe-hzeTJybNPUsYuaEQs,1714 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb,sha256=YJUO7ePUACgNVajGJigiRsGzGaqL0hHgIAz6jyu88zk,33 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb,sha256=0JMPnsJnw0rYj2LJGjJHGXrFcuwORQsPfEJdn7048yI,11 +onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/model.onnx,sha256=bi4ZJXOlblQde7zQJ2IXr19-7Tuzh7ABGIF1y9UBkxw,223 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/model.onnx,sha256=DZKdS7gtR9_bhuodjbc-XDv8AIXyxzKcjxcd4mojvVg,1644 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb,sha256=lP_xZt4-fH-c-MMHxDWyE0nPc82po0Cj8pMGFj1zxNM,11 +onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none/model.onnx,sha256=H2lkLn0o5LXqCGKwv1US_QPA4ziHj_dWCD_VRr-x0So,153 +onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_expanded/model.onnx,sha256=jvMjhz-FPf3Y5Ljjl_wmeuy3w4SCJqd3eqboiqLZj3s,1256 +onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_log_prob/model.onnx,sha256=Y9YRxncQJ320tXRz50KQeX4soUQ_g7qUQqNvr2dmmac,200 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/model.onnx,sha256=nDowvW1SSVlbo-44PvNAi27cBtPN-QkGjBweoaXEgSU,1516 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_0.pb,sha256=x2eu67Bj72ih7ElYhvsY3EgwooqYYka6FOBY-4e-f5c,21 +onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none_weights/model.onnx,sha256=vUIbLrpezyXgtQIFBb85vvUQZc-I5OWnzy3fwqygqK4,181 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_expanded/model.onnx,sha256=Gj0emH3XxL0lpeXKFM_5A_TyLlojnAxleEZd-IFi_ZI,1397 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/model.onnx,sha256=s7n7tjyaNx2mI62GzKgQa73qF8mTVqTIfbSBEikGNgg,228 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/model.onnx,sha256=3VIOOJuLcgdPaAwOLtfYcd2q9TR6JxU-pvVYvIWqAhE,1664 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_2.pb,sha256=3kILcVoqN6HplPyGS5NBip_Uxq8x53NnWk7p_6p55qQ,29 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_0.pb,sha256=y-XkkLpEvSyr9CE4PdlzMmWIvBjaeZB0A0NCBrJ19ig,21 +onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_sum/model.onnx,sha256=eKWzrBbwBTgYlHY-2HmzgUTx8HpbkbYXYDKzaPGjFsE,146 +onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_expanded/model.onnx,sha256=deboOkn3M8rduO0dixjQGrjXaKtjr8ayU4P9l73GD58,1236 +onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_log_prob/model.onnx,sha256=2tYIhEZKQCXLk0k_GwDtKRP-nd259yfV-ZZTbPVtUtI,194 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/model.onnx,sha256=usBI99QeRs6byBL7GjCGujjTkngrZVtWdSG2ou-dg6k,1494 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_0.pb,sha256=pj_kwJ8mI7R2Z9WWgaYUu6ZDJi2pczh33QryHGs7FBU,71 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_1.pb,sha256=rsaomDCWHheHMGl-4PbZMWjzhyTJa7yWbeNY-pEMS7I,33 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_0.pb,sha256=G7TfEJjhMn00Lpl6iXNHr_RQDPDaYWFElmZsgbqn13c,11 +onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_1.pb,sha256=jLA4YVCTOH97BUXLmUfsiEHq3tr2wW34snMbOINmEBI,78 +onnx/backend/test/data/node/test_selu/model.onnx,sha256=bK-4hgbeiz0E86daBeK_tjAdYtOEIPz2jhViyP6Comk,133 +onnx/backend/test/data/node/test_selu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu/test_data_set_0/output_0.pb,sha256=3t_C-XZiQzxkvHFf3gx504Kj9Q0MV9112pt5kMmd8oQ,254 +onnx/backend/test/data/node/test_selu_default/model.onnx,sha256=6Oire7P4k7mvp8_8Hn-OI3-262N26IQKGWQFWQMqHCg,107 +onnx/backend/test/data/node/test_selu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu_default/test_data_set_0/output_0.pb,sha256=_aFrBuR3jDgYVvV-OBwrJAzuyFsY0oAPRG4CXasl6nY,254 +onnx/backend/test/data/node/test_selu_default_expanded_ver18/model.onnx,sha256=h3cIE5-IoDq6fDDAAZ1YHGkozoprP8-0EXX6oKVQ0VA,1680 +onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=_aFrBuR3jDgYVvV-OBwrJAzuyFsY0oAPRG4CXasl6nY,254 +onnx/backend/test/data/node/test_selu_example/model.onnx,sha256=-G90oXdLJLM77jxlPngzQpgARw_-8xtHF1iLffaL2FI,125 +onnx/backend/test/data/node/test_selu_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_selu_example/test_data_set_0/output_0.pb,sha256=GV9rQBElEpmyFwZK5vUCoErkUB9RzczSO8s8wBrlC2U,21 +onnx/backend/test/data/node/test_selu_example_expanded_ver18/model.onnx,sha256=6APAkckMLmBXple_3UQwMVYpf02213InCALqYB3YvY8,1664 +onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=GV9rQBElEpmyFwZK5vUCoErkUB9RzczSO8s8wBrlC2U,21 +onnx/backend/test/data/node/test_selu_expanded_ver18/model.onnx,sha256=qjTTbqvlMjwWwE44MeUPBOHQp88UpqbST66W_nhW_zI,1464 +onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/output_0.pb,sha256=3t_C-XZiQzxkvHFf3gx504Kj9Q0MV9112pt5kMmd8oQ,254 +onnx/backend/test/data/node/test_sequence_insert_at_back/model.onnx,sha256=dclz71fwabxjiwz7ZZPpZ3ERqjKUCfxs9MmwS5o-S0I,181 +onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_0.pb,sha256=WDgw3x97Oup88446uaFPYpisr9Lmw6gkCgC6dO8RTB8,108 +onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_1.pb,sha256=HM2wXt_MR9LhixZe95BE_6V4E0I8aGCth0LMDB_HfFM,38 +onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/output_0.pb,sha256=ztM0AhuLe0puEOS9gTDqXrLfm79yY-n3E2NT6ZVMu1s,147 +onnx/backend/test/data/node/test_sequence_insert_at_front/model.onnx,sha256=jHJltVXI4xcX2wLCEOTU8zTdCgFE-73rmpzFqAb5U4c,216 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_0.pb,sha256=WDgw3x97Oup88446uaFPYpisr9Lmw6gkCgC6dO8RTB8,108 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_1.pb,sha256=Hw_0b-P2L4hJ3YPDPqlTs0s4rH9VdGOA2GO_hkQ3xaM,38 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_2.pb,sha256=hRxu_mZX41ntrJWWbxx8f7P6EnyayB8ka0iNrMaxFj0,24 +onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/output_0.pb,sha256=T17FYTW-QhMbvm3f8yY1hDND0c4r6qEtLdIGlcQblEs,147 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/model.onnx,sha256=OfGcJofqQCkVFhPal0FCQgWSlvjbr1shOVMI2nxKq8M,272 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_0.pb,sha256=nCXX4WEnc0Zu3v-2E9cMzpL-HDU_mXtYYAVy4nBG_to,150 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_1.pb,sha256=4LWEZM0lo_jM1KcnB2dq0CYg0TvFm7G3_eRttrDsycU,50 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/output_0.pb,sha256=MYwdCW3clBFkSs7zcMQR211ZOPnLwIkOVyLHhSUwlFA,150 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/model.onnx,sha256=dyU0kfVT2Fx83iA2ADqcXZnzZ3M3g6AB5St0Dy5vMeM,2583 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb,sha256=nCXX4WEnc0Zu3v-2E9cMzpL-HDU_mXtYYAVy4nBG_to,150 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb,sha256=4LWEZM0lo_jM1KcnB2dq0CYg0TvFm7G3_eRttrDsycU,50 +onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb,sha256=MYwdCW3clBFkSs7zcMQR211ZOPnLwIkOVyLHhSUwlFA,150 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/model.onnx,sha256=Mc9kMXbr184Szpv9fAbC6BMTnCTJdG83fws0BRhWEGU,268 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_0.pb,sha256=cGwNd7wWWJ-FuNDIPlO8IvEIyjmzK0D-xYjIam7MXhU,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_1.pb,sha256=bf6wd6KFJk459ileC4koSFigL5H6HdmP33e-4lH815M,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/output_0.pb,sha256=PkOXYpt42DXPXr5LGcda5uLFKC3W4SXgWNrvjupnYxM,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/model.onnx,sha256=WQtKBAc9qxRR1Z7p20KsXH3JvS9396ukdYuqfo6woWU,2502 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_0.pb,sha256=cGwNd7wWWJ-FuNDIPlO8IvEIyjmzK0D-xYjIam7MXhU,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_1.pb,sha256=bf6wd6KFJk459ileC4koSFigL5H6HdmP33e-4lH815M,74 +onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/output_0.pb,sha256=PkOXYpt42DXPXr5LGcda5uLFKC3W4SXgWNrvjupnYxM,74 +onnx/backend/test/data/node/test_sequence_map_extract_shapes/model.onnx,sha256=Jsl6R2LLrjHqFbg1N_uoGT7dW9HtxevfhzLm2lZVDl4,248 +onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/input_0.pb,sha256=mPhMK4W7csMlfDABLzSUi_9hj5Yyoaybjwu7Megeiyw,17452 +onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/output_0.pb,sha256=PXiF7who7_NSvRSbm7qpuMjQlD5XXC40cVlJBFVo4NI,106 +onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/model.onnx,sha256=xCqJXbZ7WsC9KoFpy3BvQMIR1v5b_n9DYuRhRPQUdK4,2232 +onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/input_0.pb,sha256=mPhMK4W7csMlfDABLzSUi_9hj5Yyoaybjwu7Megeiyw,17452 +onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/output_0.pb,sha256=PXiF7who7_NSvRSbm7qpuMjQlD5XXC40cVlJBFVo4NI,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/model.onnx,sha256=OEeIP33hLWof6fEFh_haP8yrxUYh7w1TePk86XFJrFs,220 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/input_0.pb,sha256=6tnw5WE3C0cv0L08TL4bxvHXwwdVH6diP_77Wwk_6a8,149 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/output_0.pb,sha256=1EIyt4XmclkaRfxbArKm4RLQAJ1XgXG3_0vGgEm0lOY,149 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/model.onnx,sha256=21q_NLTDki4fmu_UvzCQbYGplZXFVeEp8LktrHp4mN8,350 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_1.pb,sha256=ZyvRjOUi5VBwdltGImSNNn_iVdnJ4lCr8fJNRgGenw0,18 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_1.pb,sha256=h2zwPyLH6s4cI9yRu_DJMHHm1wnDg5SXWFDAWEaI3zg,54 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/model.onnx,sha256=nP2doMsKhjazXp5WYeLS8IWMGgF3Qh9jFsf4QnjSgc4,3664 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb,sha256=ZyvRjOUi5VBwdltGImSNNn_iVdnJ4lCr8fJNRgGenw0,18 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_1.pb,sha256=h2zwPyLH6s4cI9yRu_DJMHHm1wnDg5SXWFDAWEaI3zg,54 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/model.onnx,sha256=hiA16-f3aO5Nt6NmliOYBS7IOU3u8PUXz9Gcx8sjPg8,2307 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/input_0.pb,sha256=6tnw5WE3C0cv0L08TL4bxvHXwwdVH6diP_77Wwk_6a8,149 +onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/output_0.pb,sha256=1EIyt4XmclkaRfxbArKm4RLQAJ1XgXG3_0vGgEm0lOY,149 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/model.onnx,sha256=gBknA8YcoQ3V89G83B5Jh7ypAYRVOPZ2yiI_NXj4NYw,346 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_1.pb,sha256=edLeh_wZP5_dANUseUALIqMRTOZ7y1QyX7w9_rZFYdU,82 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_1.pb,sha256=QNVN7ibNoj0ZZ8qF6QDsbXXk5ReGVQrR58d7XUF7Lzs,82 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/model.onnx,sha256=7Q_GyTpRAMwU6C1nN_emXFXtUQ7mPJpZvzmVsc44ob0,3524 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_0.pb,sha256=p9PoQWTo5bC27UoTmyKqVW7FNgPzuy19YhT8PfT0k8M,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_1.pb,sha256=edLeh_wZP5_dANUseUALIqMRTOZ7y1QyX7w9_rZFYdU,82 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_0.pb,sha256=hMkE_GYM8mWkRJa_E5S3GXal67uKMxKuOiAHw9POsJk,106 +onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_1.pb,sha256=QNVN7ibNoj0ZZ8qF6QDsbXXk5ReGVQrR58d7XUF7Lzs,82 +onnx/backend/test/data/node/test_shape/model.onnx,sha256=3ezcnGfVq47rG8QmTU9r2YCSDgwSg2gWgnwU4ZcwnUI,93 +onnx/backend/test/data/node/test_shape/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape/test_data_set_0/output_0.pb,sha256=EECFSLSrOZp2gtSXfesFT_CNAvoEOqauyDoYlnKEOTE,33 +onnx/backend/test/data/node/test_shape_clip_end/model.onnx,sha256=5l2MUvyWGOd_g8KIufIHqsV7jMzRcNlxbczKDevB0FE,114 +onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/output_0.pb,sha256=EECFSLSrOZp2gtSXfesFT_CNAvoEOqauyDoYlnKEOTE,33 +onnx/backend/test/data/node/test_shape_clip_start/model.onnx,sha256=ZVtxuyaphNP8Hj9nS7mT-nLhL8CmK-qftbHKfgW-ARc,127 +onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/output_0.pb,sha256=EECFSLSrOZp2gtSXfesFT_CNAvoEOqauyDoYlnKEOTE,33 +onnx/backend/test/data/node/test_shape_end_1/model.onnx,sha256=LuD9y3od0JLPfHTwthJKxSzgH4-Tq0dDaLR-s-zNDMQ,111 +onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/output_0.pb,sha256=ujKSnDUgGwN2lii1DHBi3GFScTBofqmZ4RzFbFOIc9E,17 +onnx/backend/test/data/node/test_shape_end_negative_1/model.onnx,sha256=ZRwBYuQNMHdC2tGgidfSo5nvm20JH6Lkk7UkwuYkmRM,129 +onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/output_0.pb,sha256=o_sMz2Vgclt0Ror2cqSXaN2p7cm4La1LMKCB8O_0aT0,25 +onnx/backend/test/data/node/test_shape_example/model.onnx,sha256=Ga9diuxxa02AQGz75OIgn3OXoADzC27tQgM8eYFE4WE,97 +onnx/backend/test/data/node/test_shape_example/test_data_set_0/input_0.pb,sha256=4pQ6jBxU8_tBNnaRVRgYgck68GhQp-YW_tL388GcCvE,35 +onnx/backend/test/data/node/test_shape_example/test_data_set_0/output_0.pb,sha256=6ikEm3TGVfmw6AYUxs9Hj6Sz_9fYkqmojZP1Jzf94l4,25 +onnx/backend/test/data/node/test_shape_start_1/model.onnx,sha256=LLSXX_jKGQnYcGiBOokfB6HKBEp59Jr-fDUQ6y8krgo,115 +onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/output_0.pb,sha256=6CbIjNHfclOJfoITJrtphF0oSHCpNlMWJf5rgpAe7Hc,25 +onnx/backend/test/data/node/test_shape_start_1_end_2/model.onnx,sha256=73XhZqBPHyX3LfikMO0214V84zTNE5pZtRlJeu9w9B0,133 +onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/output_0.pb,sha256=EIeRS9lwJGLIo_UX9RbLDKw-bg_pno5AbyLkr0eDwbk,17 +onnx/backend/test/data/node/test_shape_start_1_end_negative_1/model.onnx,sha256=oQNBw-Fkpq4WGEdk2O7iWUZ5Uqlh_tNBOY_x3MK_n3E,151 +onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/output_0.pb,sha256=EIeRS9lwJGLIo_UX9RbLDKw-bg_pno5AbyLkr0eDwbk,17 +onnx/backend/test/data/node/test_shape_start_negative_1/model.onnx,sha256=XhRkbXqTzbEZN2dcAAVZEILa-r6AOrgmp6bRqlL5yG8,133 +onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/output_0.pb,sha256=E5EQLnbSPOMjgkdKPi9jK7WKlPyQIdVIdbNaQTDYhrs,17 +onnx/backend/test/data/node/test_shrink_hard/model.onnx,sha256=hRk01cid7ePJWw54gaQvV4SuhFswtdeY0sMW4cCV7Mk,109 +onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/output_0.pb,sha256=KreC4NTAYK5M6dHrWIiG52RveZDpxh9mGTsf43xT4sk,29 +onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/model.onnx,sha256=g9Xalz8K-ARbwHMGzGKnXHdUHfdtfl1Xg_av5lSu7aY,1761 +onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/output_0.pb,sha256=KreC4NTAYK5M6dHrWIiG52RveZDpxh9mGTsf43xT4sk,29 +onnx/backend/test/data/node/test_shrink_soft/model.onnx,sha256=fd95F4NzSxY8j8N0YEuX3RFbmVvQk78Qzm2JpNX7VhE,125 +onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/output_0.pb,sha256=AbQplXJ5FVu2LaNzGC0t3G9EZhZUCsd-_fnyXRD9T2I,29 +onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/model.onnx,sha256=b-762wBGgDraNAQenMZF5yYpIi9UG639NYP1A8Cueaw,1761 +onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/output_0.pb,sha256=AbQplXJ5FVu2LaNzGC0t3G9EZhZUCsd-_fnyXRD9T2I,29 +onnx/backend/test/data/node/test_sigmoid/model.onnx,sha256=yepFvj3QD9Q4Zac5RYx0wffH_TJfr4KUAJ9DrpwGKN0,105 +onnx/backend/test/data/node/test_sigmoid/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sigmoid/test_data_set_0/output_0.pb,sha256=0M1TGc-0294NBpXmRH6IueVH60XOGwbeqLHuWtwlYaQ,254 +onnx/backend/test/data/node/test_sigmoid_example/model.onnx,sha256=qOwSJGf4ve6g7bQYHFcESH7TCyR-8MnWManHLNU6yCQ,97 +onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/output_0.pb,sha256=n9DyuVyiD6_UcKq3n3I64IT13QLjk3QfNoHdQTVflTE,21 +onnx/backend/test/data/node/test_sign/model.onnx,sha256=5l4xY8OBCnG5LepNxNKpVslAvTsQ7luIHrYwBJBeERw,83 +onnx/backend/test/data/node/test_sign/test_data_set_0/input_0.pb,sha256=rjz39Xc3D8_98MARLx2sEOivP3ylvsTlSYV1gS-Bkjo,53 +onnx/backend/test/data/node/test_sign/test_data_set_0/output_0.pb,sha256=GYc7eDjQSxVY5ZNV9JTqvwtl76bQQ-5Lj7KU0VWq2xU,53 +onnx/backend/test/data/node/test_simple_rnn_batchwise/model.onnx,sha256=EsuXrzQ-Ob09ghioZ3NZdLzngyvFW1fWBerh7zfaJ4g,242 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_0.pb,sha256=X4Jx731skujCbqYlfE79v4ovLqbqAar9VfhQTegviw8,37 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_1.pb,sha256=-qFlupAAYG72bVDrKQjQwSrFWi7iN5QBw4xnAFPcW84,45 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_2.pb,sha256=dGa_abJyaziCNP5gMI36AA1qPkXY_LbN8ysUOVmvHyk,77 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_0.pb,sha256=Ez-xZ1K8qEGZMxzQU_vbW69DKAZQtG3EiqIHGbBQt4M,63 +onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_1.pb,sha256=nXDD6IaK4uJCe6-oxjWmBH0vVBgbRwZ-0yFCq_-3OB0,63 +onnx/backend/test/data/node/test_simple_rnn_defaults/model.onnx,sha256=9FBv3ZwgUVQyC_aykS7yGwXVv7BGTAFFyT8GrliGouc,196 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_0.pb,sha256=CfdyEi1TF1qNXdr7S9ZjPY0_c7pWtxM7ou3bNl3fNIo,37 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_1.pb,sha256=L2zxMm6uL4QSLsCnRiqUzv-9fp0-VkDW34RiKxcyg3g,45 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_2.pb,sha256=kU8zrxPzF60vfcmkNonlRPNh3BWlyVnLbMwQ5CkKp8A,77 +onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/output_0.pb,sha256=OU_yJMBnE3tT08kLB6QX9tCug2oOoUznNbKkxphDC2k,63 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/model.onnx,sha256=fe8V2dsmBZF8BGsqYmew2dxlaDBhi_d6mw18S0wbhys,229 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_0.pb,sha256=eujm2YGHVRU93EAGK-aPA-aFEublku2wP288wJjVc4M,49 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_1.pb,sha256=XvvuxoSRCrX0paTv67nqpKoXd_aJPHnXNXHAk58EJLo,73 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_2.pb,sha256=eHvrnjVBev9Xxrb4pqD28kF3B0UDphj4glVsRcqMlGc,113 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_3.pb,sha256=xxxsj5zURFnPlWj7Qthy8BnSXEWPmD0jqteuG9OYLzw,51 +onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/output_0.pb,sha256=XxDQiHg3N9hdXmZ1DvqGHcyQxln3qD178X2V3_tAm1w,75 +onnx/backend/test/data/node/test_sin/model.onnx,sha256=MPX3UXM-DfTcxk4GwxYlIsSHnHJBT2fpQq3aiPUYFy8,97 +onnx/backend/test/data/node/test_sin/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sin/test_data_set_0/output_0.pb,sha256=9o8tToPY2FZLrQ9kpgkTSRtcGUruDpzj4Mv-1YM3x7Q,254 +onnx/backend/test/data/node/test_sin_example/model.onnx,sha256=wduzRKh4BsPV587Mg7J_L0aiWfhK7y_LTFnion9Tf6g,89 +onnx/backend/test/data/node/test_sin_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_sin_example/test_data_set_0/output_0.pb,sha256=rESUsCJt7xlSm0XiIouAgAB5X2EDtEkx1XgwSgNXt60,21 +onnx/backend/test/data/node/test_sinh/model.onnx,sha256=0NBUelqvm6ruB5Gn3dVwtjP2iRuknT1aBQA2iyg6JT4,99 +onnx/backend/test/data/node/test_sinh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sinh/test_data_set_0/output_0.pb,sha256=zEQv_P636KZBRXg0oYuZwujFuQmZeZlKmqdxiVwDfs8,254 +onnx/backend/test/data/node/test_sinh_example/model.onnx,sha256=L66imtG3NvcSnDCDSARKLJ_RukbUfBBXfghiQpAWZjY,91 +onnx/backend/test/data/node/test_sinh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_sinh_example/test_data_set_0/output_0.pb,sha256=K9t2_Mw4JTwHagenQVbXUofxj_teQvFtDY4StMA6np4,21 +onnx/backend/test/data/node/test_size/model.onnx,sha256=tedT8vxs0wz8dz-VmvKzVHwz68ahmDILwFVoIwmQtf4,87 +onnx/backend/test/data/node/test_size/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_size/test_data_set_0/output_0.pb,sha256=b1cKolCwb8qATNXxOwy-uZzIoYoFpdZ3uAldE3zbmBc,15 +onnx/backend/test/data/node/test_size_example/model.onnx,sha256=OnjZwDJi3dsHuuCr_3fQBRnN15J6lQJ7Q-PtMMHPTk0,91 +onnx/backend/test/data/node/test_size_example/test_data_set_0/input_0.pb,sha256=4pQ6jBxU8_tBNnaRVRgYgck68GhQp-YW_tL388GcCvE,35 +onnx/backend/test/data/node/test_size_example/test_data_set_0/output_0.pb,sha256=7DuNFW7Z7uQ1cybMsorcUI-Yli8oj4V5HZFJX0W2oVk,15 +onnx/backend/test/data/node/test_slice/model.onnx,sha256=-Y-njaE0gcBSHb4aXWALKqZfPQCALE7BvM-MvRmTExs,212 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_1.pb,sha256=wc0xhhIxzp415JcdJvpBr3MTluCa3ilwjbTmaicBxXg,30 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_2.pb,sha256=cF5G7dCz_SnsX419hWpbVK4j_5H2YKZE-5xFMquukGw,28 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_3.pb,sha256=3uvlJ_2xYPsfOzK-E0Fz2WR-a1Yvmf3r1G6DZPUQ8v0,28 +onnx/backend/test/data/node/test_slice/test_data_set_0/input_4.pb,sha256=FYpZ2BP2ch3ngdORN4Fd-XXCd1OqSsJv2WWY_whU-Jg,29 +onnx/backend/test/data/node/test_slice/test_data_set_0/output_0.pb,sha256=D_IVQ8WutqrVCZXsKWyJBT7ouKphKsCc0qSUJxTHWqM,614 +onnx/backend/test/data/node/test_slice_default_axes/model.onnx,sha256=4JJ6BOFJqe-cAZhCh_bTrU_jfCuwTmIyu1shAFTomA8,171 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_1.pb,sha256=0MyK8o_JTn-8OHMKQd2Fbs5NEoDrp0ZhGk5VXN4dmzU,38 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_2.pb,sha256=gMy-BWymFe5-HqAkM0EEfJd0pohqpQfkWvnkLE591wo,36 +onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/output_0.pb,sha256=x__ywPxcTlMOMVGXHmZiTOgKJLZByNMQhBM7bldOtX0,814 +onnx/backend/test/data/node/test_slice_default_steps/model.onnx,sha256=jwnfWp6zT12XSVPpY-HYg5haSqhx3yadBTmABYLgD3Y,198 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_1.pb,sha256=0MyK8o_JTn-8OHMKQd2Fbs5NEoDrp0ZhGk5VXN4dmzU,38 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_2.pb,sha256=gMy-BWymFe5-HqAkM0EEfJd0pohqpQfkWvnkLE591wo,36 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_3.pb,sha256=9iIJIH63usRCzPxS79uoJJal5z6hRmFovI6qk_j9cFg,36 +onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/output_0.pb,sha256=x__ywPxcTlMOMVGXHmZiTOgKJLZByNMQhBM7bldOtX0,814 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/model.onnx,sha256=k_XTlsDXa9msN9VdHe9K_J3ki5KaJeGOwfGPqtXWb0w,230 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_1.pb,sha256=XWv_EpyftbZOy7BvmcGybZQOKyOWxra7roBZ3Z22qRw,22 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_2.pb,sha256=P6LxgBoMoyanncUlS1nQkUDkj88OFJk_Ve-Xzhl2R1s,20 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_3.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_4.pb,sha256=H6nsc5oVsaH4Y0X2D1ZXmG5CRvWCq2I_iVx14iTm1rw,21 +onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/output_0.pb,sha256=widw8tjNc3GiW69yXjw3DNXyrRew0s0tW58CO06AOro,3614 +onnx/backend/test/data/node/test_slice_neg/model.onnx,sha256=JxZ24gL6ooXtIkwVYa4_T1xB4s1QRMztgMyuflxup8k,216 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_1.pb,sha256=y7Lo1gIZ0Noqo6CgxoS0eeiFhLvLERZtwLtJfDD_kQw,22 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_2.pb,sha256=HVPAD1MvsIO_DXFtTbbGyV4N8iyv-amZiqvFCmDwXo4,20 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_3.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_4.pb,sha256=H6nsc5oVsaH4Y0X2D1ZXmG5CRvWCq2I_iVx14iTm1rw,21 +onnx/backend/test/data/node/test_slice_neg/test_data_set_0/output_0.pb,sha256=WWi0BR0FvzzDXkYKRxk7YBwjvUAnpYN_1glTU9rocFA,3614 +onnx/backend/test/data/node/test_slice_neg_steps/model.onnx,sha256=jmxK1-OxeZ9jaaFhAH3-Kvi-Fm34eWPtlzRS4fvSM3I,222 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_1.pb,sha256=-Zy7pr4EQ4B7KtRMFQTOCSlyXXftEvJJ7ZN-ZDeNuZQ,38 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_2.pb,sha256=TtilbvYaT70fTxtYWUr_xaWr5e2v0OCMPMdtm6aZhfk,36 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_3.pb,sha256=9iIJIH63usRCzPxS79uoJJal5z6hRmFovI6qk_j9cFg,36 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_4.pb,sha256=7YuunH2YMZ_XZ8Axu63BxakwocdYdHjdAuBYtGoruJg,37 +onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/output_0.pb,sha256=yignEmTSPo1HLtKNxvQrL_hjHzz0YCWadWmUKIjD-Kk,470 +onnx/backend/test/data/node/test_slice_negative_axes/model.onnx,sha256=I_yla_KIgD4D6RFpTWtQrCU3f_1yFvyZjeisKwOknwY,198 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_1.pb,sha256=0MyK8o_JTn-8OHMKQd2Fbs5NEoDrp0ZhGk5VXN4dmzU,38 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_2.pb,sha256=gMy-BWymFe5-HqAkM0EEfJd0pohqpQfkWvnkLE591wo,36 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_3.pb,sha256=GzIxNVTw4ACJiY_83J53w9FTq-KK-8hroLrrDcD8Ql8,36 +onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/output_0.pb,sha256=x__ywPxcTlMOMVGXHmZiTOgKJLZByNMQhBM7bldOtX0,814 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/model.onnx,sha256=oOedHfZOtIflvQ5uiRdbfgb6Tx5LisRu4_PdGV_ZIZA,232 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_0.pb,sha256=EiB2JiuXu9Np31LSxkkbIbZra3nXCjnmcIsaVkoiD0k,4014 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_1.pb,sha256=54hVGhxKE_jcB9_6i2I-XxQHazFEivW1yktR1utgllg,22 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_2.pb,sha256=P6LxgBoMoyanncUlS1nQkUDkj88OFJk_Ve-Xzhl2R1s,20 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_3.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_4.pb,sha256=H6nsc5oVsaH4Y0X2D1ZXmG5CRvWCq2I_iVx14iTm1rw,21 +onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/output_0.pb,sha256=rrPue6VSpt1lUoRyxwKugP6KM5RSPt607YQ4WQ1KttU,13 +onnx/backend/test/data/node/test_softmax_axis_0/model.onnx,sha256=rPvEUpIpvKEMpLsORpNlc2C3eF4zPG3alrx0am9jiaw,125 +onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/output_0.pb,sha256=gReHANPYz0AKw3vwpUSfcfbkJyjj9NahVmvP3q9Eziw,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded/model.onnx,sha256=Uvf67IryWaNIbghB11ybsMl1oAd0RS4otNp0DYLc7fE,859 +onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/output_0.pb,sha256=gReHANPYz0AKw3vwpUSfcfbkJyjj9NahVmvP3q9Eziw,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/model.onnx,sha256=dXadX9DosmijwVIn1f6Jj5jfgGffos-9wm7XFUkkSl0,905 +onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb,sha256=gReHANPYz0AKw3vwpUSfcfbkJyjj9NahVmvP3q9Eziw,254 +onnx/backend/test/data/node/test_softmax_axis_1/model.onnx,sha256=-fdXWdlN_2pRTAR1NWUmS16_BOKalktHpA8N_fvP39I,125 +onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/output_0.pb,sha256=2NtZxKwupZCfKtMkHWpzmQmC7c88DQrshZJByIrSFHs,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded/model.onnx,sha256=bWJ1bsrya2jyX53AHNO_N8wj0ED72nM3lRP318wrxFI,859 +onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/output_0.pb,sha256=2NtZxKwupZCfKtMkHWpzmQmC7c88DQrshZJByIrSFHs,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/model.onnx,sha256=O9rrLRIkGh1qvn9uXTP_GuY_NBWnZ1_QmqRxr-bMK_4,905 +onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb,sha256=2NtZxKwupZCfKtMkHWpzmQmC7c88DQrshZJByIrSFHs,254 +onnx/backend/test/data/node/test_softmax_axis_2/model.onnx,sha256=xI2MXHglefKmAVAq3tQcFcjgsm8eSu3TN-nbwtyF1Gs,125 +onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded/model.onnx,sha256=vndP3LBl1H73mq-JQ7igZVawXO4X-wjubBFQpxmX3Tc,859 +onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/model.onnx,sha256=vg2LyI1uLoTTsvne1I9d7c1OAEyqJAbT63sfLFhXrQ4,905 +onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_default_axis/model.onnx,sha256=cdN4CJp3aOtL9kxltySsMgE7nfDR0qU14TA4ZMPUYpo,118 +onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded/model.onnx,sha256=9TkAiCwfQq4IjN0VcW-QHCxpbdUTMb1dywNefX7NUg4,951 +onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/model.onnx,sha256=5jS9BaH8YIvWGy83ht5IRW_tfxoiSKxmnfkWqH9gD_I,994 +onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_example/model.onnx,sha256=feyA07cOiiKh-hENcmC-hWKB5kyneLCin5Ub7GZu6TE,105 +onnx/backend/test/data/node/test_softmax_example/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_softmax_example/test_data_set_0/output_0.pb,sha256=AxlcbRehwEN4TljnHvvA3UwR5A7TPVjLT-4ruMBkjVM,23 +onnx/backend/test/data/node/test_softmax_example_expanded/model.onnx,sha256=YbOfYjHr1VLVKasKhncA8X-GxiVvBHTvlRRgalIfHOM,881 +onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/output_0.pb,sha256=AxlcbRehwEN4TljnHvvA3UwR5A7TPVjLT-4ruMBkjVM,23 +onnx/backend/test/data/node/test_softmax_example_expanded_ver18/model.onnx,sha256=RpKwwJvijOgEJTtwWqBJgjRkgwkoqhxwFTnuD8NTQLY,919 +onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=NHt6xFA_Q0se0ekO4FsGJVcWaEWivQQoZluHhSWn6JY,23 +onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=AxlcbRehwEN4TljnHvvA3UwR5A7TPVjLT-4ruMBkjVM,23 +onnx/backend/test/data/node/test_softmax_large_number/model.onnx,sha256=SSF-_e-pfB3flN7K6UKFtiWmtvsDV0hOA4giV2S_cSY,110 +onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/output_0.pb,sha256=VVIksa1N2Whk8zHrBBuhgt3c6Grf8KBuxwwrI5lJM0A,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded/model.onnx,sha256=_dWdXF9bLoxc2Rxon_ICSor9xHyr1rAEaatQaDs6TEA,943 +onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/output_0.pb,sha256=VVIksa1N2Whk8zHrBBuhgt3c6Grf8KBuxwwrI5lJM0A,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/model.onnx,sha256=IUVcW3Q_5J_U6sBO1BK3jPPdG67xElsLc5t77ASZ1EQ,986 +onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/input_0.pb,sha256=8aqq9T0ktdil6R8zGhL-Sdrp2dpDCnSGzKl7HZiLcaI,43 +onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/output_0.pb,sha256=VVIksa1N2Whk8zHrBBuhgt3c6Grf8KBuxwwrI5lJM0A,43 +onnx/backend/test/data/node/test_softmax_negative_axis/model.onnx,sha256=LqbaqeEi_FLpNHU9XxKztZRbswQAo2oWyJwT6yAn6pY,141 +onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded/model.onnx,sha256=YwZwOKhiEh3xNC8oa4tNTAyg0sQfKpKeYLmR_JnwILw,963 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/model.onnx,sha256=uTMJBQCkfux5JdqgY4yKzsQJS2HQUFU8cEt050_cO2s,1007 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb,sha256=HXYaCnrmFAQgJqqc4KNL-b30SEla9MMJlhvZwiCK0Qg,254 +onnx/backend/test/data/node/test_softplus/model.onnx,sha256=QwSuVk_2IYaooRgcjHxq5AL7aAK-PK0-WEkNLxI8dNk,107 +onnx/backend/test/data/node/test_softplus/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softplus/test_data_set_0/output_0.pb,sha256=rHJ50Q-HF9yqjDagvyD5Y-sN3gPdoFkLA5AoQ-arwCY,254 +onnx/backend/test/data/node/test_softplus_example/model.onnx,sha256=GUQ8w8gigz93BTvsCpYKeAWBJYvyvP7VPr7OAnMwM48,99 +onnx/backend/test/data/node/test_softplus_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softplus_example/test_data_set_0/output_0.pb,sha256=hBr-1WJ2kvuYa9H8KU8JwzCmjoiJc3Hx2EEUrm1R7Gs,21 +onnx/backend/test/data/node/test_softplus_example_expanded_ver18/model.onnx,sha256=o8N5kGU49K5hQSpJktA_yOwPKSo3ryWMITSc61obz0s,653 +onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=hBr-1WJ2kvuYa9H8KU8JwzCmjoiJc3Hx2EEUrm1R7Gs,21 +onnx/backend/test/data/node/test_softplus_expanded_ver18/model.onnx,sha256=oGQzrTvruMiAZAh8rh0ieWvmiBWmF62IBASvIx0Necs,596 +onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/output_0.pb,sha256=rHJ50Q-HF9yqjDagvyD5Y-sN3gPdoFkLA5AoQ-arwCY,254 +onnx/backend/test/data/node/test_softsign/model.onnx,sha256=7DK5AqrODujVO_bU07Pu-auaDdc_6zsGXFxNUFQHDVc,107 +onnx/backend/test/data/node/test_softsign/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softsign/test_data_set_0/output_0.pb,sha256=C1uB1I9A1YtJLV8Uk5qi0Kt4Qp4JgvRtwFC7jgpvPv0,254 +onnx/backend/test/data/node/test_softsign_example/model.onnx,sha256=HDQ1Q1XdZYZF_7B2aRHkgOORJMZLtR6JxIKS6jct09Y,99 +onnx/backend/test/data/node/test_softsign_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softsign_example/test_data_set_0/output_0.pb,sha256=0PjRkEThQLPQg-L9OX5IMgy3AKDBFVV19sCL_5lIw8s,21 +onnx/backend/test/data/node/test_softsign_example_expanded_ver18/model.onnx,sha256=ctkO0bzc-LtS7pGIvJ58OYyvGngyUVnUm6a7aLWgSek,661 +onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=0PjRkEThQLPQg-L9OX5IMgy3AKDBFVV19sCL_5lIw8s,21 +onnx/backend/test/data/node/test_softsign_expanded_ver18/model.onnx,sha256=kzujxj_7QVmYB_slW_nCKpbiowBThOZZHxqqBqCE1CA,605 +onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/output_0.pb,sha256=C1uB1I9A1YtJLV8Uk5qi0Kt4Qp4JgvRtwFC7jgpvPv0,254 +onnx/backend/test/data/node/test_spacetodepth/model.onnx,sha256=5bhFh8fjQS6TNDdICtgmDCob_KnzRygkh-56CaGgYeg,141 +onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/input_0.pb,sha256=RQwrUqEeNR-xpz-3gUYuK_U3iKOcH02SYQbl9v7xBq4,592 +onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/output_0.pb,sha256=bCbPbnCmL7gHpAW36xdWiJsJAR-Edj6WLGvzeQv-Dvc,592 +onnx/backend/test/data/node/test_spacetodepth_example/model.onnx,sha256=COrE-uxJ_5EJlYTiRbmDlzVrB-abPgnEKwV2BRJrWxY,149 +onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/input_0.pb,sha256=vzHIoweipp3I3wmKCKgBriLjySIPGzTodMmImqlK_js,111 +onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/output_0.pb,sha256=tit_KIMPTKvj4s3AmV4lFHs2di-xrcHDuk7J0GRVVDY,111 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/model.onnx,sha256=PdguF3n01jJ2BWS57bgVhz0nvJ6lAKsshODlU8qXvfs,254 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/input_0.pb,sha256=0MMLUhV-IwhwMRPXDWkkAOYhGXFio1ApRW7tIcwmzYg,41 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_3.pb,sha256=klI1oBl0uNJfSanTYax_iQ_y6jhdGIbAiyDMBPVj_6I,20 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/model.onnx,sha256=DC3MsMOmKoYOIeox6oW-ea9I9xE8UTpk7NQVYsl8uAM,249 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/input_0.pb,sha256=ne0IY_mmYi1Myo1AL7u3nGpHodjQpJbXmhu5LICcJMc,79 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_0.pb,sha256=lZJx7RYf8c-urSeibZ8DnaW0kP5i2lQfQly2Fb2f-Fc,42 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_1.pb,sha256=ZBvUdSiV_UXZTEDGHukB4UtnoIR11YOlHOXxleju8dY,42 +onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_2.pb,sha256=4EcXbQUeqluX6Taji-9zMhQCwDm1QZdb3FXNmAuSAx0,34 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/model.onnx,sha256=kq4EG6GOwMXdzGmK0_Cw1AJeLP3Bx6ZactogJKmm2vo,212 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/model.onnx,sha256=gHiamqUc_ThuSGkUE2fiCMc8DCfclBbFO12AYU7UKKM,232 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_equal_parts_2d/model.onnx,sha256=cTCvN8fr_EQTkk1XgE2uYKCh1dxQLqFdGxc6IFkGeMo,202 +onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_0.pb,sha256=SRqisx8PBlmhEqo0lYWXWQ2JyCutfOy1SP3mfHqpUKA,42 +onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_1.pb,sha256=4oCTYs32ZK3rT5vrT3FIds25XjGHsz8MwlbQkr_sEZY,42 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/model.onnx,sha256=3Yo0dSUSNjV5uBK52USIf0OPPIeWkkVsryj52ISwMPk,190 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_0.pb,sha256=SRqisx8PBlmhEqo0lYWXWQ2JyCutfOy1SP3mfHqpUKA,42 +onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_1.pb,sha256=4oCTYs32ZK3rT5vrT3FIds25XjGHsz8MwlbQkr_sEZY,42 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/model.onnx,sha256=jzvzdKnSNBTAOb6TiEs_N-f-g_tn-MALqiyObWJa-yI,209 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/model.onnx,sha256=TyUulY-Fid3BZkoAjctVoKT86f0zWauE3Yu-cMhNY5o,229 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_1.pb,sha256=ppWgsDUe535k0J7J7eHrM4nXbzwrP1d2HRDBbGokHYs,24 +onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_2.pb,sha256=wHVtUBsyF8K-U_XpjGbmnest6VdUNcj5uOgMRhN-6y0,24 +onnx/backend/test/data/node/test_split_to_sequence_1/model.onnx,sha256=GzaBCiipHJBNDLa7A-NAWzP-HIBl79qkQvswgMA5J0Q,159 +onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_0.pb,sha256=hohal__2jZZ7sW8FBCBj6k5KwzGvWUrrFo7_dmF8Zrk,86 +onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_1.pb,sha256=rRPJw_MP4GzZF9UqyUHod5oZNTZDCYD4LJ4iubKW3KY,19 +onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/output_0.pb,sha256=fV41UEmrLEzyFUfJvb60DaR7S_hdmzhe23IXBLiBtC0,109 +onnx/backend/test/data/node/test_split_to_sequence_2/model.onnx,sha256=DaCK6v5UOuPg7Y47KtsL8b9wFNObu-DITh8SeaWnbeU,163 +onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_0.pb,sha256=hohal__2jZZ7sW8FBCBj6k5KwzGvWUrrFo7_dmF8Zrk,86 +onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_1.pb,sha256=Z3UXDkJvBF4Hf1WnsQpa7ifhVWCdbGzMyb-BGdfxSfQ,29 +onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/output_0.pb,sha256=-QRNSvDp1Qn7lrM4ldwcAd5Crm7M6kfAs4DAU-muPJw,99 +onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/model.onnx,sha256=otmU9iu6BnhwdACervDDqfKR7i208eAAua4s8xaUjUQ,161 +onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/input_0.pb,sha256=hohal__2jZZ7sW8FBCBj6k5KwzGvWUrrFo7_dmF8Zrk,86 +onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/output_0.pb,sha256=08IDo97JLVHNcylBdWoEiBpsK_sehJED72UcixmIZic,127 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/model.onnx,sha256=NoEZGVziDX2zoDtLOYRVuCTkdghM66-MlXVZWg6MGPg,209 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/model.onnx,sha256=uAI7cQQ5yrWC4lV0L5RRIC9JgXCvkV80WyJ0EdzMTVk,209 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/model.onnx,sha256=D-cYrAkJDR1UeR3zk5_ylK5WFx_WNOsJSS7_p44iOnk,221 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_0.pb,sha256=9pl6VjjiFVClVzpC4AhEkRQIBd1alqZxXzThCmDLhKk,34 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_1.pb,sha256=_3ZLeX0bUaRISuadzex91jHCMjQPZefG5c9_ZZj4zvs,50 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/model.onnx,sha256=tJv_THJn53mN0BM-XB4V5dxm3iQNPBLV2lUTneO6xjI,221 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_0.pb,sha256=wcsj07dMPwy_TgfeqO_LZn4LBOusGc6f2Toix53A0ks,63 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_0.pb,sha256=9pl6VjjiFVClVzpC4AhEkRQIBd1alqZxXzThCmDLhKk,34 +onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_1.pb,sha256=_3ZLeX0bUaRISuadzex91jHCMjQPZefG5c9_ZZj4zvs,50 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/model.onnx,sha256=lW6SmYm30zfpsf_Rb_-6pX8weVSZdb5ZSl4JPbcfRvM,206 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/model.onnx,sha256=sTCSMCCXeFnUb6_1YMMPlvpkoMJJlliDBbSk1EfcSO0,206 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_0.pb,sha256=6-4ny9aa56B_H1JS86gEwXcZdWOABmTlWFY0-GRimGU,37 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_1.pb,sha256=UI8Xnn4y2HCHt4mE8KiqJl6XfIYNb-qx9UeaIBJ8cic,29 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_0.pb,sha256=PZBD8ZeddYVsOIQKh3QdgF1GWMmR7fqW0Vk4_-zjaME,24 +onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_1.pb,sha256=2Q8n5Jfg3-M-8gGJ4RH4-w6ZMopbqb-TkncpX-x_ZYg,32 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/model.onnx,sha256=iQn5gh1rElU3EDnVlW3xQKsWeTKUIPlexQG_eBrT1kw,229 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_0.pb,sha256=PNWgucFe5Tf1mGk98Ir_bEaOELmES3FAPZpKbskJO6M,13 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_1.pb,sha256=o-O8kmlClSSIjeKhfy88IVCUriMV6Wsi10eqicjIVHA,37 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_0.pb,sha256=4cN5_4IAh3yvrFKoOn7wqzTUZaeUlMF0Y2JzSlAev8U,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_1.pb,sha256=SgOFp0XrEtOKXGCO2yCwjM-mmrnGiG43OJeVKPVQSCI,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_2.pb,sha256=Gve-t8o-LviHnt0QBVUYwp7TJLd1j_sJZbadWj0t-go,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/model.onnx,sha256=o1DgL2iQ7ybNT8OokLTzkpyEUCcdiC0XnhnGiLqcOPk,229 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_0.pb,sha256=PNWgucFe5Tf1mGk98Ir_bEaOELmES3FAPZpKbskJO6M,13 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_1.pb,sha256=o-O8kmlClSSIjeKhfy88IVCUriMV6Wsi10eqicjIVHA,37 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_0.pb,sha256=4cN5_4IAh3yvrFKoOn7wqzTUZaeUlMF0Y2JzSlAev8U,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_1.pb,sha256=SgOFp0XrEtOKXGCO2yCwjM-mmrnGiG43OJeVKPVQSCI,16 +onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_2.pb,sha256=Gve-t8o-LviHnt0QBVUYwp7TJLd1j_sJZbadWj0t-go,16 +onnx/backend/test/data/node/test_sqrt/model.onnx,sha256=h4jfkNJWaUfcoSQGcqHwdY15o5OLRjVoCc-1b7dVwS0,99 +onnx/backend/test/data/node/test_sqrt/test_data_set_0/input_0.pb,sha256=bFw_k8kydnJjSxU8NNjUFVzKoPKQ6fGU_od8777JidY,254 +onnx/backend/test/data/node/test_sqrt/test_data_set_0/output_0.pb,sha256=As-Nz2MWaj1kh9fTPsNyeNwMUow9_A13pahFbHZVk-0,254 +onnx/backend/test/data/node/test_sqrt_example/model.onnx,sha256=7uQM7y_IGof70AbsYdJdLDmTWw0_7WDKZtPj4N_q8eI,91 +onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/input_0.pb,sha256=Nrf34J1rWfH_mvaflbCOOw7nNwxeOO-haem99-KYESk,21 +onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/output_0.pb,sha256=KW9J7uTWmyfHYqYwYwZyv64IeAl6_iDrPha7DI-bhcU,21 +onnx/backend/test/data/node/test_squeeze/model.onnx,sha256=7bhGdCvwG_TflO3Wg7Sm_F3-wcxgWqOBizx9Ch2TC1M,135 +onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_0.pb,sha256=hFcc65NzF2jKbEvO_e8J60kUbf0yiM7kqrgc4fH_zcw,256 +onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_1.pb,sha256=3ZIfNI5JADuUCnYUjr-VBN77qOrY7__k-MJ2cszFazI,20 +onnx/backend/test/data/node/test_squeeze/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_squeeze_negative_axes/model.onnx,sha256=4W3OsZoK5_9Kf3NYDOQ-yHXRGaPHQ40o0xV1-THHizs,149 +onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_0.pb,sha256=aB6aWPKjpjxoogC4OWA9AtqtA_neDA-penHUJfcxTCQ,75 +onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/output_0.pb,sha256=Nw5Lbu_KXM7uUzsNQJyxkH74rempglPVlAcohSxDoLE,73 +onnx/backend/test/data/node/test_stft/model.onnx,sha256=tsMRYdduSuEfzNmFvwSvdo4n6XHrwMgNfY1Hs93Kj8w,199 +onnx/backend/test/data/node/test_stft/test_data_set_0/input_0.pb,sha256=8AO0tqkf6LPSAI3rAdEMf4BpkfPwW4XMIcz9Mc_CFO4,532 +onnx/backend/test/data/node/test_stft/test_data_set_0/input_1.pb,sha256=QWZmtDzOdzs5-9Q_NiVq1dbgf4ogy53xglu2F4-18dg,24 +onnx/backend/test/data/node/test_stft/test_data_set_0/input_2.pb,sha256=U21-PeJEIhgtSvlY30evxCn0p-LdDUIhR1irDFEoFmQ,26 +onnx/backend/test/data/node/test_stft/test_data_set_0/output_0.pb,sha256=IACcg3anVjOxSt-5wInGQEIOFNYVEJfPZP9qEIJfEZ8,1101 +onnx/backend/test/data/node/test_stft_with_window/model.onnx,sha256=7Ix1wx_t7d6ZphvQEq7CqQjtXzzPcLO0xR8nGwNugWo,201 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_0.pb,sha256=8AO0tqkf6LPSAI3rAdEMf4BpkfPwW4XMIcz9Mc_CFO4,532 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_1.pb,sha256=QWZmtDzOdzs5-9Q_NiVq1dbgf4ogy53xglu2F4-18dg,24 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_2.pb,sha256=IhzB3rW7gW6EGWWvRfMRQ6BgCta2JXMI3CRTtJZAU5Q,78 +onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/output_0.pb,sha256=x6UcxitYuQKMPEbAp_8mDlbgawNcFCG8r4X98dbj040,1101 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/model.onnx,sha256=8WTCxTE83fSRwhNrP-Qh__Qmc-PmIIExxvbdUY4uyoQ,222 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/model.onnx,sha256=93DFSw1HvmrQmyGjSG4nm8Dck9Ucc3cf63YZN_NpC1M,197 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/model.onnx,sha256=jaCqkB5G5s9lkylgpZSBESwA8IeKqqtEqPSOsC47w-o,222 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/output_0.pb,sha256=7Zk-IeCaqHCfs5Z1zqHp5ERKMABu8eMRVVYNTMLdFc4,37 +onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/model.onnx,sha256=UX3g4dMXYOc0tuakv3AsxS4QxTTRPeWmb9Khcidb7rQ,214 +onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/input_0.pb,sha256=XGok6pzumeWYmW61YcE2gO49FZP4HhO5L7VQiaofooQ,23 +onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/output_0.pb,sha256=fve41mqTI11I7kUof7Bey6Rtk7Sv23j8xV9xaJLPzQ0,9 +onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/model.onnx,sha256=GHPpZvp0i0FgVto26sff1Ics_yUdMEKiSC-Adv9Q3UA,209 +onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb,sha256=5_crR6dG0l6PE3Zf0m0C1WePv2dsKuUUSeSBHD4-fx8,65 +onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb,sha256=etP-R5bCcemRt-RrzQK7MPjXOQwqbEBeZCcYma1Jb7M,49 +onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/model.onnx,sha256=CxFs65zLw1qHXcsN6vxSznvl3RFdX2mzbTO-WQBm0UY,156 +onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/input_0.pb,sha256=uBHq4M-aleAVs_ZnyQty-Yz85ya7wK6Dp7RjXk0bUZw,24 +onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/output_0.pb,sha256=NhjGWjPVxmkR0f35ghfx6YQm3Is2Eue9LWCC-NaQqQY,24 +onnx/backend/test/data/node/test_sub/model.onnx,sha256=mP10ldWkDDKH8APo3PpHCAEwuvxrP5mwXhG9tfEPvVM,125 +onnx/backend/test/data/node/test_sub/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sub/test_data_set_0/input_1.pb,sha256=qlmuuQNl3eLtxabKfNE6cbZHjYcj-DzNBr1M4rz7GSo,254 +onnx/backend/test/data/node/test_sub/test_data_set_0/output_0.pb,sha256=8dGJKtTismvzTYKNniWX7nI7kGv6E-yTz7tnd9fXnK4,254 +onnx/backend/test/data/node/test_sub_bcast/model.onnx,sha256=4wE4E0xFCLz9T8Z6v19gh5g9Q34MR-hWv5qLgNAbORs,123 +onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_1.pb,sha256=jYn9FLUzE9ETJcxFW48XqSehRlyePPjUoI-gtNyozBs,29 +onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/output_0.pb,sha256=LyA5dyUqm2I4X1kd6ky4dvMue4RkuYrzpg9F7suqdhs,254 +onnx/backend/test/data/node/test_sub_example/model.onnx,sha256=0qCw4c6DH-9qPZRZFBEhJXzz0cuRYN_AA_kgjg_cB1Q,109 +onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_0.pb,sha256=07NXD9M8ncP5OIBozL5eyrRmifhNqQKh-yXwmBAQ5_Y,21 +onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_1.pb,sha256=ldaXLvrKYcVHRK_B5teZ_Wc4K33RQimHHQ1UI9lc1r4,21 +onnx/backend/test/data/node/test_sub_example/test_data_set_0/output_0.pb,sha256=PE0UGZkx639vsMtw-TNum1iHVl0LeudCk4ehTOso4a0,21 +onnx/backend/test/data/node/test_sub_uint8/model.onnx,sha256=dOOLhNUqQJJzBYvl2d_gr0tELW8JumtINUnPeTHZ5hM,131 +onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_0.pb,sha256=rbapTNwdifJamIWMOKri6wDhWXBqZFmQI0E7KSh-ukM,73 +onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_1.pb,sha256=Bhd20g540nbcCIDE7mLNKXv0V7lCD01cmdVOeXApWTc,73 +onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/output_0.pb,sha256=SvCJ5U5_hcZH5kKG_KITYVPXfAFRfOEGcLDhyEo9uRA,73 +onnx/backend/test/data/node/test_sum_example/model.onnx,sha256=XZP8TSc2z90MlswCEnr5H06sUKLF0UvocBc-aNWaoqk,170 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_2.pb,sha256=_PLxlJ7xl9XIGa6nbKkonHq25eO5mYsALw5JQS7zyx8,26 +onnx/backend/test/data/node/test_sum_example/test_data_set_0/output_0.pb,sha256=uwkdb0lH_dEBq1A7Tmw4xNdVFOnbXYnaLhqJPa70el8,26 +onnx/backend/test/data/node/test_sum_one_input/model.onnx,sha256=6UQdw-WAFYgRrvWemfXV-9CzuTjQfgyYujsTaGUVV4g,111 +onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/output_0.pb,sha256=ZKhVafwrQna2mYQVSKmI2eivwdOVRllNuFJ0a3S4awM,26 +onnx/backend/test/data/node/test_sum_two_inputs/model.onnx,sha256=N8dWqhy-TnLXUw9HSex51GW0uGtetk3z_AiUh3gMZ2w,142 +onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_0.pb,sha256=N_bAzbz_zIhMsxt_JXexH-iLaQmHJs7Ci6YiUFcbYqo,26 +onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_1.pb,sha256=CT8EqMoWnZgfvIbZCTZCcy5yi-scc6HUEY-s5dz8uC4,26 +onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/output_0.pb,sha256=TY8-bJ08UEwSu_EVLVl6Bwb7549mVnCWsDUHC5XHv88,26 +onnx/backend/test/data/node/test_tan/model.onnx,sha256=8y5lt8ZB9lM4FB4Iu6hdul54IA6-RTw12uBqGPN9ZKc,97 +onnx/backend/test/data/node/test_tan/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_tan/test_data_set_0/output_0.pb,sha256=WD2kasDAEGtoHDYoy37q3vXYt3_gFrugnEMp7rWQXrs,254 +onnx/backend/test/data/node/test_tan_example/model.onnx,sha256=LzUncM0mcZ79YwBaqrgityWvvT3oDjk7wmtFqdQ2nhY,89 +onnx/backend/test/data/node/test_tan_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_tan_example/test_data_set_0/output_0.pb,sha256=fqcp5u1o4BVyNsOREf4iXsbMXZziCecBb7Q7w1dF_70,21 +onnx/backend/test/data/node/test_tanh/model.onnx,sha256=U3A5tfcs_Hp17L6AxqD4qHr26dvWD_WZ4Lixxk8hGlg,99 +onnx/backend/test/data/node/test_tanh/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_tanh/test_data_set_0/output_0.pb,sha256=9epV2ujx5MyrnOrUIjmF5O9si_CqNGqtoyDQ6aWIGFg,254 +onnx/backend/test/data/node/test_tanh_example/model.onnx,sha256=AoBuuazpOgUw3IGATd5Au8wqhcnxvtw5xMRcno4TH34,91 +onnx/backend/test/data/node/test_tanh_example/test_data_set_0/input_0.pb,sha256=RY7cC3PG2NU1nqWO6C7rbFiTMHWg1hK-N8IVnjp9UIU,21 +onnx/backend/test/data/node/test_tanh_example/test_data_set_0/output_0.pb,sha256=nFD1raZkukttNDNzXe2Qh0UKEk9cX0Ul4lLASfmYj9U,21 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/model.onnx,sha256=-EniRrPntw0dzQmhYCut6sPuBkfQU1xkIqQQLLoiTiw,323 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/input_0.pb,sha256=RuSeM5AAJoMD0_LUG3RLk0WKe_Yu3njy5AIvlpXBEGw,59 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/output_0.pb,sha256=5IdNsCA9je2XbErSYUmWdkfPsfxkwrUf7op6GaqXqf8,67 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/model.onnx,sha256=pS_36SRouNVGZo5He-ITKOBEKYJWADwNET22dbyuVI8,323 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/input_0.pb,sha256=RuSeM5AAJoMD0_LUG3RLk0WKe_Yu3njy5AIvlpXBEGw,59 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/output_0.pb,sha256=UD8F8mfp4Z-P7z4_poshzkhI1ONkSs8RWiioBZ6wXSs,67 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/model.onnx,sha256=hwFqXbWQ3m9HhGM1RdqQIWwT-0ShxF1yZbX8begEDIc,325 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/input_0.pb,sha256=RuSeM5AAJoMD0_LUG3RLk0WKe_Yu3njy5AIvlpXBEGw,59 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/output_0.pb,sha256=lZon0vYsJAmO9YgPUKEXr6zIAZvJOXYSLvkymMrzx_Y,67 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/model.onnx,sha256=GS8cEAj07bUmc0iwrHrR3BXlXmzJkKZG6iNwv9yORMo,310 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/output_0.pb,sha256=OHQudUdGevZkYWHLjqghPTQjpE_rzikFq-mnC3u2Hkg,37 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/model.onnx,sha256=A2zNW-p1Kd0gFy1nlNxddLRwPfi25aBcGBN1s3tZgho,298 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/output_0.pb,sha256=HqYz4t-IV0NRYVNdxt6tHgAr6cXkXZb9bhxw5eRZSG0,21 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/model.onnx,sha256=9BzVp8R0xgTHrWa6iEpnJE71YDoMSeA2j-bwkNZB5tU,309 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/output_0.pb,sha256=bWYlhOyhr89Gu8Egsb-EZCem3F2ITmQ2T-pAAMoBkSM,37 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/model.onnx,sha256=7pVbMq_QNlnT5GEO49GAtvrWW6sUFq-dbT3m0cYWSdo,311 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/input_0.pb,sha256=YCc_Bptl6ovGeLNS8nNKpq9kZn61r24klmgDmte_FF8,57 +onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/output_0.pb,sha256=fWBlu9B5oyr0J1oSpwScOYEOm4wpBfIXOGcZDLMSEtc,37 +onnx/backend/test/data/node/test_thresholdedrelu/model.onnx,sha256=oTxyJkdK3p9Uf-aVTJl_ndNK0xwLrbJbZvSAeoOYiC0,138 +onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/output_0.pb,sha256=EYPDY0T-gVBpBycVsSv96EYC8I5OQKmOXlUd0PlqqTo,254 +onnx/backend/test/data/node/test_thresholdedrelu_default/model.onnx,sha256=TJw1TED0YtDseBnwHp5uw-5SK6LRCVznrmJSmE-UE9A,129 +onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/output_0.pb,sha256=R8JHO3yOt_f-HSe9W_6opD1vEVd0J_9IyfYvUqvYHb8,254 +onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/model.onnx,sha256=Xjy0FUJJHKbF_mLVMfXrmoLzkCIs5SiRNXSJ0DQqdpw,993 +onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/output_0.pb,sha256=R8JHO3yOt_f-HSe9W_6opD1vEVd0J_9IyfYvUqvYHb8,254 +onnx/backend/test/data/node/test_thresholdedrelu_example/model.onnx,sha256=kJKpeX0TjKfz1KkxpNI4jpxjQ9yifzgn08Zttg8n7rI,130 +onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/input_0.pb,sha256=GyqQxuM6edhbQcLuvJ7Ff2l8cqNvuhOCWT6tq6GrCxQ,29 +onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/output_0.pb,sha256=56tfAjuqWM64ZQOZoGZe2HownMu6FhctDhrCWEX-U3c,29 +onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/model.onnx,sha256=dr6KzXPOEebHoFgYsZ2zIYjXMA2jz3p_M6Lk-0Ed8Uo,977 +onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/input_0.pb,sha256=GyqQxuM6edhbQcLuvJ7Ff2l8cqNvuhOCWT6tq6GrCxQ,29 +onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/output_0.pb,sha256=56tfAjuqWM64ZQOZoGZe2HownMu6FhctDhrCWEX-U3c,29 +onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/model.onnx,sha256=2RT0LcAGiGKRmi90hz2kxYpH3hUoMaXxSG-aM6goZOk,905 +onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/output_0.pb,sha256=EYPDY0T-gVBpBycVsSv96EYC8I5OQKmOXlUd0PlqqTo,254 +onnx/backend/test/data/node/test_tile/model.onnx,sha256=QfHZNXzmqFwu78ZWpKbrIoairQG5_T80e91VExVm5nQ,127 +onnx/backend/test/data/node/test_tile/test_data_set_0/input_0.pb,sha256=gw969Zq2ZPC3oIK5VZvEvK3ygLM6eqRhSyV89xoSWa0,496 +onnx/backend/test/data/node/test_tile/test_data_set_0/input_1.pb,sha256=3hLt-sVia_TlsVYqobdpF_RmIXzm-x9MlyzSKruqYmM,41 +onnx/backend/test/data/node/test_tile/test_data_set_0/output_0.pb,sha256=Rs-OKCKQNoROZ4obyQdCkRgsW6jV-IFq2p2uGO-rcCQ,161297 +onnx/backend/test/data/node/test_tile_precomputed/model.onnx,sha256=QXGzsgDOILyxC9mjPlMFdY7_WGynokKvLHY_-gKC5U8,123 +onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_0.pb,sha256=0phUVbSY99aYNDvbb4I7ZwTF4_oqB7I9Teh_3LZTlfk,27 +onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_1.pb,sha256=8YdPn9kXj5gTtZWZFpSg86zsyytFp2VxVrzLf29WrDM,25 +onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/output_0.pb,sha256=UhTwBP5SsiJy8mBvMpnEyfL8TWSEzsn2xB-b29BSfRc,75 +onnx/backend/test/data/node/test_top_k/model.onnx,sha256=nBQnNpnRF182ToZriwV_zz4kksH_QSMuYLbQhTL1rL4,172 +onnx/backend/test/data/node/test_top_k/test_data_set_0/input_0.pb,sha256=XI00qhavYkKl_aHKei8a3IH_dsLyhI_Y57J38wFhkU0,59 +onnx/backend/test/data/node/test_top_k/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k/test_data_set_0/output_0.pb,sha256=vzxrEwUR_AoNSo5nsdkq3fMRD-TWJIdQTFnoTF5HOE8,52 +onnx/backend/test/data/node/test_top_k/test_data_set_0/output_1.pb,sha256=Lq4Jo5XkOjWTnkaaHX6oxn_k4xXtVuYESe87xYE4-JM,89 +onnx/backend/test/data/node/test_top_k_negative_axis/model.onnx,sha256=KS5REJglVn3-UblpD99uxQCnR1zpyrSl2UEfs_9S3RI,195 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_0.pb,sha256=XI00qhavYkKl_aHKei8a3IH_dsLyhI_Y57J38wFhkU0,59 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_0.pb,sha256=vzxrEwUR_AoNSo5nsdkq3fMRD-TWJIdQTFnoTF5HOE8,52 +onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_1.pb,sha256=Lq4Jo5XkOjWTnkaaHX6oxn_k4xXtVuYESe87xYE4-JM,89 +onnx/backend/test/data/node/test_top_k_smallest/model.onnx,sha256=zsfOUFk4VRFbwL0MPCYpnGe0KCdqnMT_jf7Vc3vf2m4,212 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_0.pb,sha256=ryRK_hmxESRdBORPiEQGCBWqPscZuVkuLVdq4UiTkIk,59 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_1.pb,sha256=2s0pITsSkAcfbYtBMMznqlVPskqVWNigM8OehwDxlhU,17 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_0.pb,sha256=6NbpYxWiqeXH1aQ5Qsdxf5e4Thh3nDRzyF8nMxMU-v4,52 +onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_1.pb,sha256=8o2XaU6qQNbXjIpJgqXwjpFgTIBjtdHfok7ylx2w6Nc,89 +onnx/backend/test/data/node/test_training_dropout/model.onnx,sha256=_U1yAo0mT0ZiMrGogrUSlW9iqFgzt3A_NHvtD3RsdvY,160 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_1.pb,sha256=Ihb6BRVhibKnewisCvIZ4IdGYIG8RISUnIQOFl1wHSo,11 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout/test_data_set_0/output_0.pb,sha256=CmBjvEq_A4VxiIqoeJA9geeo6q067Zraon47UAQZysA,254 +onnx/backend/test/data/node/test_training_dropout_default/model.onnx,sha256=E8V8aUIcRgk2Jzy1WECbVjULWmOL0MyNnMS-oeliSSs,168 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_1.pb,sha256=x_s2_p7rxoVX_GfqD2NvSwHUYcx5i61p2DlsgKolOJE,11 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/output_0.pb,sha256=6RLLCaWhovCKRwj2lZPTEcsCXAXwpny9iHnJWVbZlqY,254 +onnx/backend/test/data/node/test_training_dropout_default_mask/model.onnx,sha256=C7Pp6QXLnuc9iCfBtAl3NoTgCa6B2sUoc5ybkyV1ovc,201 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_1.pb,sha256=x_s2_p7rxoVX_GfqD2NvSwHUYcx5i61p2DlsgKolOJE,11 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_0.pb,sha256=6RLLCaWhovCKRwj2lZPTEcsCXAXwpny9iHnJWVbZlqY,254 +onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_1.pb,sha256=U7w4KTIRqkX6TMfa8mTB9l88U4Byw-Gxr5-BTRWGzC0,73 +onnx/backend/test/data/node/test_training_dropout_mask/model.onnx,sha256=qrU_n6FT3SwpNeSO7-h52DxoUtxc4KhMKHWsPonexbc,193 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_1.pb,sha256=Ihb6BRVhibKnewisCvIZ4IdGYIG8RISUnIQOFl1wHSo,11 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_0.pb,sha256=CmBjvEq_A4VxiIqoeJA9geeo6q067Zraon47UAQZysA,254 +onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_1.pb,sha256=rPswqfqePkmopvWjUY6xwIBzHLn8yFTlIEaC7zi_1ws,73 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/model.onnx,sha256=RL10VHLor0PqHsgjfcEnElK4hn5Oms5B8ryo27O6XNw,171 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_1.pb,sha256=hZowRFBsf_dlyYrjzzS179SSCrfk16UaslAIJqe0JkA,11 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/model.onnx,sha256=NZ9lNocdnX98wzwAEj_tUsTIqPcSaDYXQeogAy4QxSs,204 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_1.pb,sha256=hZowRFBsf_dlyYrjzzS179SSCrfk16UaslAIJqe0JkA,11 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_2.pb,sha256=ykb35DzfMoMhKwpLutzmEnZcfmNm5ILYorWGgJ6Wk34,8 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_0.pb,sha256=4E7JZEL-6RPD2ZoGlbe4UZXnssgawDGOHg15V0RhX58,254 +onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_1.pb,sha256=4sWzAHgaDiZSCGEr949BKLl9dNfAyqyQpzL1ccqJJ2M,73 +onnx/backend/test/data/node/test_transpose_all_permutations_0/model.onnx,sha256=jqjlHkGBfK4NqC3puhGlroMaVb9XcsJqG73wSDxyhqQ,170 +onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/output_0.pb,sha256=8m48HiFPwfnlF03aRhdOZsTuw4GtLKS-6Q7Kdu2CTHY,118 +onnx/backend/test/data/node/test_transpose_all_permutations_1/model.onnx,sha256=mhfN_6A4tz2qdrb9rjhDlZwUsShja-7Ot2Oaqs1IveI,170 +onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/output_0.pb,sha256=KdRdeEJ8zlT8RRzybOAlbdCF6M66iCYf1ZXc1lZw7QY,118 +onnx/backend/test/data/node/test_transpose_all_permutations_2/model.onnx,sha256=35PFa2aarV1PJSbDzteiK8DGmpMm20nyKt8JEV2YQC4,170 +onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/output_0.pb,sha256=EDwdkyw_W6NnH7UTmY_FwWB6vJ2zZNEfhKTkro6t2mc,118 +onnx/backend/test/data/node/test_transpose_all_permutations_3/model.onnx,sha256=i7eK315QJGUU85fjkzBJLdoi4x52-x_xOsnoLD3udbI,170 +onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/output_0.pb,sha256=hBbLAZf6HxZc9v80VT82V1DlS_5sknpc9ejUOibhPDs,118 +onnx/backend/test/data/node/test_transpose_all_permutations_4/model.onnx,sha256=EENz6zMz97lBhLpk047TftavCEzGkvDx0TpDbXjB0yQ,170 +onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/output_0.pb,sha256=eFo6pA8Z_W1f_lj5SuJSWG5TGGlFZaNO3jKaR7gq47o,118 +onnx/backend/test/data/node/test_transpose_all_permutations_5/model.onnx,sha256=BzHf0V57l9PH5iJyqIrsRuv93iyubdLwR5m4EmxxKl0,170 +onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/output_0.pb,sha256=cHZA22uz70nv-VGa4Pz3DDZlMtCkO7A42XLP232Va5w,118 +onnx/backend/test/data/node/test_transpose_default/model.onnx,sha256=aP2dQnyUZoXh5UNb6osbjJoUVkKUyx282pQZWGzw3Fg,141 +onnx/backend/test/data/node/test_transpose_default/test_data_set_0/input_0.pb,sha256=Ra5qJ0bmZk4Mtqoj9EhsgTyEoqrmqYk679L-Ki7OJPI,112 +onnx/backend/test/data/node/test_transpose_default/test_data_set_0/output_0.pb,sha256=cHZA22uz70nv-VGa4Pz3DDZlMtCkO7A42XLP232Va5w,118 +onnx/backend/test/data/node/test_tril/model.onnx,sha256=lhJDHmrNmmQmM3IE2vMEwWyxqjuE6E-lkEW1eqAnFRI,106 +onnx/backend/test/data/node/test_tril/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril/test_data_set_0/output_0.pb,sha256=0yOBOAhKCbt38Vyz7y8JwUrBoiwNlUWPKG9XTvmkyRE,172 +onnx/backend/test/data/node/test_tril_neg/model.onnx,sha256=lGWNM5bmJR0DyK5sZonj8a3CqcI9iZV8cABSDM87kaE,126 +onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_tril_neg/test_data_set_0/output_0.pb,sha256=kYHROrSW_24f7h99TB3GfxE41l-6Pa-_xhnWeLyG9YE,172 +onnx/backend/test/data/node/test_tril_one_row_neg/model.onnx,sha256=yt6xj_XnWkJPKqkFDcbF8Dy6aRmVtXShqsMdd8gFF0Y,126 +onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/input_0.pb,sha256=ScwWPKBfy94Tzyt92uIxTxzOec9LWF6m_ox8cdpH3R0,133 +onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/output_0.pb,sha256=uQ0LME1uBl6FjFBG7-4pUsoQdykXVZdtHnbP4AclmWg,133 +onnx/backend/test/data/node/test_tril_out_neg/model.onnx,sha256=Pw6kQJ6Wxc_IG-6C_HZOswSAEUCLz4cgmPit3sMyTPc,130 +onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_1.pb,sha256=Tt-kDFMTEYFiH-Yfmgak7F401t7I7nrv4UpeGtdKD5M,15 +onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/output_0.pb,sha256=QfgazYHaPKrLW8AspgXsm4Kbyrfo3VZkoC7P73D11R8,172 +onnx/backend/test/data/node/test_tril_out_pos/model.onnx,sha256=z5gAacj6JzJo5-QaSZACl3WTeDFo68Cd9-yNVv1aTz8,130 +onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/output_0.pb,sha256=3PmW_Dd84mJIfxdwLn1HgG7o8YwHhSGboTBaruGHyAQ,172 +onnx/backend/test/data/node/test_tril_pos/model.onnx,sha256=qtHANJJBn7vNMrkVc8B8nzEJObPVNtWtS0T4nFRFyIE,126 +onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_1.pb,sha256=gW2ZrFQv3ahq6TbMYWhXMbs0jzUdce0TXUK4945SMm4,15 +onnx/backend/test/data/node/test_tril_pos/test_data_set_0/output_0.pb,sha256=sstFogvuO6IXlRUwDjX2czo9TEKLz4Yv-y98cszv0so,172 +onnx/backend/test/data/node/test_tril_square/model.onnx,sha256=TXbYCWCohDH4w3nd77x_vjeOgCIFKiuxBaV2bqvCA3g,121 +onnx/backend/test/data/node/test_tril_square/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_tril_square/test_data_set_0/output_0.pb,sha256=vdj5m3p8LBerTUcy8c8wUXgkKaCdstCfJyVpgzNKUog,158 +onnx/backend/test/data/node/test_tril_square_neg/model.onnx,sha256=qu1dUTCnaTWKK-fri2UpZv3Zz7j8oLpaZozxXiBpbr0,141 +onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/output_0.pb,sha256=RZf7iUnfN42u5ktYpTiiDwOXwdrhCQtT13GxJQZQH38,158 +onnx/backend/test/data/node/test_tril_zero/model.onnx,sha256=hnZmDv5ZOJztbmhw2IDOo1gFvL60AeMqWhl8UVjKTQw,135 +onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_0.pb,sha256=Kapx_xKdYnTZDHE0gZW2f4mFu_JoDYcW68ayR-ev2dA,13 +onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_tril_zero/test_data_set_0/output_0.pb,sha256=y0-YZEpnT8AdgNRD6Us4QuB-FZaplytFQlXV8jEkrKc,13 +onnx/backend/test/data/node/test_triu/model.onnx,sha256=gpkyt4sDW1kzNziEz7gV68zyVAgo_57JweFnE0kJnDI,92 +onnx/backend/test/data/node/test_triu/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu/test_data_set_0/output_0.pb,sha256=-RYXmZuISX8RTZVbK_02g9AoUJ6v0GuQ4IE_4_KEBFE,172 +onnx/backend/test/data/node/test_triu_neg/model.onnx,sha256=eD2I1le73tiWp5Fg--vV_u_NXKv1sNEwOcXfl_um_rA,112 +onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_triu_neg/test_data_set_0/output_0.pb,sha256=7V1XOQLF1dNocafYdMS-s2KYghNF3sRoYBRbeWR_vxs,172 +onnx/backend/test/data/node/test_triu_one_row/model.onnx,sha256=6_MwfrUOU_ZKMO0MhSE90ZuX3M--xqjNrXv1CSgHeIU,124 +onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_0.pb,sha256=ScwWPKBfy94Tzyt92uIxTxzOec9LWF6m_ox8cdpH3R0,133 +onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_1.pb,sha256=5dmgjxbBKzMl-btFlxmcAdeSrI3mggZSyGhb128Fw0c,15 +onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/output_0.pb,sha256=9bTgow1Cm656P2OpenExYLW1EomHftqLJulgaXYdf6o,133 +onnx/backend/test/data/node/test_triu_out_neg_out/model.onnx,sha256=XXpDfKfYM1Qp1XZDKqXainml-cAj2U768AmLeMnWfWU,120 +onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_1.pb,sha256=Tt-kDFMTEYFiH-Yfmgak7F401t7I7nrv4UpeGtdKD5M,15 +onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/output_0.pb,sha256=3PmW_Dd84mJIfxdwLn1HgG7o8YwHhSGboTBaruGHyAQ,172 +onnx/backend/test/data/node/test_triu_out_pos/model.onnx,sha256=uazDxppu435fjfwPfPxeEa8weRtNved_HuLgy1SpxwE,116 +onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/output_0.pb,sha256=QfgazYHaPKrLW8AspgXsm4Kbyrfo3VZkoC7P73D11R8,172 +onnx/backend/test/data/node/test_triu_pos/model.onnx,sha256=tFHTxvcfOmNdZ7cbt8HE-a2UBj2mqMyMGE0Tb2udaEY,112 +onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_0.pb,sha256=jDVc0JhPtInMnx5F5UakieVJD3xICkyoLxm81-hMvaA,172 +onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_1.pb,sha256=gW2ZrFQv3ahq6TbMYWhXMbs0jzUdce0TXUK4945SMm4,15 +onnx/backend/test/data/node/test_triu_pos/test_data_set_0/output_0.pb,sha256=SLp3CwNp4vx0w13204jSX4McKeiz802CKiITnHiyldU,172 +onnx/backend/test/data/node/test_triu_square/model.onnx,sha256=RFsaV-Vew2pD0XJ9FHjbS3oYY9LIUlCVDi8Cu5ImGsA,107 +onnx/backend/test/data/node/test_triu_square/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_triu_square/test_data_set_0/output_0.pb,sha256=36AMhLCF7SadJX9HRMgzRid74z5gEDPfF0pMKmZOu_A,158 +onnx/backend/test/data/node/test_triu_square_neg/model.onnx,sha256=zRGX45x3GZWKvvdWcydY3usiY8y3zqHKJ0mGaC88ifc,127 +onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_0.pb,sha256=1lg6-XA3blxfCn0jtzXBITxdSjycH7mbLTN9GItwNHE,158 +onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_1.pb,sha256=i0ZHP5YqdC9NiwoL_Bm7HypdONtt3SVFXYuFeG3mUy4,15 +onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/output_0.pb,sha256=bbzJaIibrNsk9884uaPj87_IBzuFWPmqc44QkKcbBQ4,158 +onnx/backend/test/data/node/test_triu_zero/model.onnx,sha256=iGyvccjcRHA99U1iqg8YmoSstOgVlB8MDgGfmArNLUk,113 +onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_0.pb,sha256=Q4GTabNiDzUJ2uTk3sAfLoeeFVE3N4nsJcyCSfj7r0A,11 +onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_1.pb,sha256=9bqFzalAARJbjjUBHRhuduhGUfbMRCaZbI2Jr8ayV7g,15 +onnx/backend/test/data/node/test_triu_zero/test_data_set_0/output_0.pb,sha256=Ofi3T4wcGmuiSbXYfYn0XSNmCZg-m6mMiCUYdRLjTyA,11 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/model.onnx,sha256=mI9ze_3FIMLoYnysIxv7sCLQs4gENmzvxUiQlnpEkNs,237 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/input_0.pb,sha256=Ns8OxpGU_k8PsN9mEqOHyqV6UppeCIXanwl42u0Ab1g,33 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_0.pb,sha256=LAq6nE8XXq5Mlam5kdTIVIADwEBfKtEo2fHe8-L5GHM,25 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_1.pb,sha256=Sxq63uhbT7l8GKBrtiC01yTSsQZgfHSvaaJGhCjbdws,47 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_2.pb,sha256=mgccksCXBKUz17RP65cS7NBD7n-XMa24IFiz6uIG5L8,71 +onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_3.pb,sha256=hPqVSpfdfcRPh5WvGmSgoojnYL_Baos0WzTXzYvnalA,46 +onnx/backend/test/data/node/test_unique_sorted_with_axis/model.onnx,sha256=eyviJg4BbaPZDQ-eC1eT_BO6nLcCG-9DJ1cqVNGCfaw,251 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/input_0.pb,sha256=-84LKk25M0JkwiVnp3fuOqet5lFGsWn9dkwOZerjeCI,47 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_0.pb,sha256=vMMWxLgUqNcKAkJLK7e4z-tIriWOQds5LQAJtgfkSmw,35 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_1.pb,sha256=xtKkdir_J2mcMJQPbbbmwXHUX-ZEs5nRyjgfBYz7-cA,31 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_2.pb,sha256=MtOqG-EXKfAEBzZbrrGh8qjnN1QcvDtmZIQxyYqi4gU,47 +onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_3.pb,sha256=v2ScObavRe4FpFQK5d3imkd0Sw8otdQv1znGst4Y5Oc,30 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/model.onnx,sha256=FlWgY6d_vk8x-490N2n9Qv_NCdybuq-6t0jinEr0eqQ,262 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/input_0.pb,sha256=6a9P3TPDB6QH4-3m3Gools1cGlBo_OIbWJeglabhcu0,77 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_0.pb,sha256=YzN-pRyi12eIXyALCN5eHojPdmVGuL-DMINTwLaK5WY,61 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_1.pb,sha256=BVBCngYFGHlKon1y_ZXgRTi7fN4UnWIl3BIx3Uz_0zA,39 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_2.pb,sha256=Q55BSlLZREX4SafY1xiRetTNeOjxaBk-rIXBKS_UOoM,55 +onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_3.pb,sha256=w9rka_9R3rrKcnipyjjE1aYp1bHAUXRAHaF6k1VFKZ8,38 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/model.onnx,sha256=BTdTVahQ20B9sj7qO7V0ORq4ctappfgvN7-dkPRuXVE,269 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/input_0.pb,sha256=pUCGtsou5GEKcbl6nLdN9pU29-_oadU6jb0lSXogOXo,47 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_0.pb,sha256=elaSiSMuIeTR5E3jLR2MmJYlSGW8Lf7kHm7XK9I21ms,35 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_1.pb,sha256=nEcWVbGWyBXKcIc0WWAAKlGfOu-ezo-7gMwo0n5jz9k,31 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_2.pb,sha256=dbkzp5DFsqzeGFufr0S2WHfnQj8ygai09efxFpfSBS8,47 +onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_3.pb,sha256=v2ScObavRe4FpFQK5d3imkd0Sw8otdQv1znGst4Y5Oc,30 +onnx/backend/test/data/node/test_unique_sorted_without_axis/model.onnx,sha256=u0wxMZgmvT8CQ79k7HphAOOqdPqIpSd1wc5iHeMX888,218 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/input_0.pb,sha256=Ns8OxpGU_k8PsN9mEqOHyqV6UppeCIXanwl42u0Ab1g,33 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_0.pb,sha256=1ZcKwXNjKdAcaeAtk_IWYB0fwW7DigTs9dL-8OcYehM,25 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_1.pb,sha256=Vzsgo_9q0aWXU7KrUGj_Ulkd-zmn6zGq8qHe8h5toX0,47 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_2.pb,sha256=DJYa6RfMUcag73E9JldAu99PExISkx_iQAYEGVl7arw,71 +onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_3.pb,sha256=FUDlaCFeY2YPucjoGxW3edfoBJyoqAVz_r5Jt9q5TWA,46 +onnx/backend/test/data/node/test_unsqueeze_axis_0/model.onnx,sha256=Rrbs20ASrVxVuGw7Lsv3LskRagcMZjI0UT1izRf4DPM,146 +onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_1.pb,sha256=3ZIfNI5JADuUCnYUjr-VBN77qOrY7__k-MJ2cszFazI,20 +onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/output_0.pb,sha256=7pBNI_l4wxYb22FSOMO0t85L0wi5LsIih7xtBBY5EtM,256 +onnx/backend/test/data/node/test_unsqueeze_axis_1/model.onnx,sha256=-3p53ZdFS0aRbajRZN_-ONXlAkWkYmbv-O3ar0OX6c8,146 +onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_1.pb,sha256=o4le8V6iPIlHLtoGuvyqO5LaEop3xA-fhQyODESQhjM,20 +onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/output_0.pb,sha256=erjuk57H84W6c04_54gQIjRGdm6p4nVaR50I7tFpFyc,256 +onnx/backend/test/data/node/test_unsqueeze_axis_2/model.onnx,sha256=ifkesBikjeOINcIetsGdAXo7EVRrWdLc2QZ5_pPQNwg,146 +onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_1.pb,sha256=U_wQ65FCC8JB-y4RR_g61R_1rF1iPdWLzt_RQUQuh5I,20 +onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/output_0.pb,sha256=FE6UwTuZHYy7nJYxcNYOjwbR6cpMSo5Mc13I4BxMW-o,256 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/model.onnx,sha256=yyXXH0OoTiMSGW2RQToz6La5ibC6aRShblB2Z2SVAp4,162 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_0.pb,sha256=aB6aWPKjpjxoogC4OWA9AtqtA_neDA-penHUJfcxTCQ,75 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_1.pb,sha256=5PAkeDfyfr_LK59jYKRKHgLSB1uNbqL05Q6iDP3bYKQ,20 +onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/output_0.pb,sha256=M_rXEhjcZ9MDQd1SSpUxWFzwhQ_3dx4LQ5X6I5isi8E,77 +onnx/backend/test/data/node/test_unsqueeze_three_axes/model.onnx,sha256=Okvdy03NqYI4-_Bw0OqvGkQUPnSsWOh7iNVJS-qrpNo,159 +onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_1.pb,sha256=XTLt93U00nr062yDPpKmKXnDxZAp-uRTWSE_mpGSYoI,36 +onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/output_0.pb,sha256=YspzhMTScvKa4iChfYrxn74bnYhE6oZNMMffc6VkSHM,260 +onnx/backend/test/data/node/test_unsqueeze_two_axes/model.onnx,sha256=KzOrwYM7hWzBBMRCpm6TEGxyijxMDSF8_tSYvk5vh8c,153 +onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_1.pb,sha256=XBER72Hv68bXC29lHTLkcZZvWEOlhd5ifYnNGSA-QlA,28 +onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/output_0.pb,sha256=GfzpZxLfr85XoTxoLpWubUTBYq7QM3L5ovPrc5_sQ1U,258 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/model.onnx,sha256=VEVr6sy9Me2BmeMnhefSUOxSEMqTOdd3qx2uUmI9ukg,162 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_0.pb,sha256=AYD1ZlMl40MHdzbkkD-kNROucUzrEx3u5FuEI3DfKJo,254 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_1.pb,sha256=YePFsHywIWhMNzc3PugUCl7h4RavlIdU5IJGj5Jf09c,36 +onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/output_0.pb,sha256=YspzhMTScvKa4iChfYrxn74bnYhE6oZNMMffc6VkSHM,260 +onnx/backend/test/data/node/test_upsample_nearest/model.onnx,sha256=lC2-Cymd0v6CU906ju6rolvrrM6lek_-uoPdNsHQQXY,174 +onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_0.pb,sha256=mLXavIMpEU-t1w77qkVcBljM9nIegS0-j17fhrivmno,31 +onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_1.pb,sha256=3a1OyYYNdnWsgKm8R9EJ4Ja-reMSXI0q04mtA4aFGfo,30 +onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/output_0.pb,sha256=sqObjzJsZ_nVStepjZKmx3dOTVd9cGqBu3Uw2w6tYFg,111 +onnx/backend/test/data/node/test_where_example/model.onnx,sha256=4YX9T8syogoVpTQ7KiWunBIGYGSGKAOklJh9uEdjEP8,166 +onnx/backend/test/data/node/test_where_example/test_data_set_0/input_0.pb,sha256=ghkps-yp5CRRR8fRbC7fiqWG19bL00TcORlce2Dr8og,23 +onnx/backend/test/data/node/test_where_example/test_data_set_0/input_1.pb,sha256=lPIc8OteAp_-7KlBv6zvkdDRdCAfOoxPPaN_av_HSJQ,27 +onnx/backend/test/data/node/test_where_example/test_data_set_0/input_2.pb,sha256=7893d1VgDXW5UWBTA27uzhL4FaPrjXYO5MNy9JB3a04,27 +onnx/backend/test/data/node/test_where_example/test_data_set_0/output_0.pb,sha256=3asllVK1SP7UhYXVLz5tibbbeultaVH_nFb-UOh8-pU,27 +onnx/backend/test/data/node/test_where_long_example/model.onnx,sha256=IiJZuUKLbgaVXnSuiOXQRbggyn5ymP42iJeHb75n96c,171 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_0.pb,sha256=ghkps-yp5CRRR8fRbC7fiqWG19bL00TcORlce2Dr8og,23 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_1.pb,sha256=ihk2_EF7Vli4ISkpvz__BQzOCl_2COzVep_4BiFH43g,43 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_2.pb,sha256=f_zUgnAQ6lnkBPWONXb6jcZgcQ5HwulMKehbqLKYwqg,43 +onnx/backend/test/data/node/test_where_long_example/test_data_set_0/output_0.pb,sha256=XgBYedUw_ZiqoFlcvsS7HsIoJNZPFm-DE9Bx6qZeF70,43 +onnx/backend/test/data/node/test_wrap_pad/model.onnx,sha256=S0EKcZuU2tmLzgnOiaDXjGT5HA85iU6DoC3jEG666EA,154 +onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_0.pb,sha256=umu-JvCA2frJXIw-HvgygGTng85wErTWgIoWSJRivzE,256 +onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_1.pb,sha256=8s4uRhNf19t1kZ-BWDxuitcnY9MeHgkG6w6i1Sghnz0,76 +onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/output_0.pb,sha256=g9TcriXsdlgExNte-G7DnSP10rAenwXVxWkiA-pXqM8,520 +onnx/backend/test/data/node/test_xor2d/model.onnx,sha256=3GJJUC1tVd_FIuAx1ZCV29I7vpp_jwEO_A_C8qFQl3c,119 +onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_0.pb,sha256=LjNp_gf5HfToURj-fOV-TL_10b7cTqoOj8RfPTNPYLQ,23 +onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_1.pb,sha256=goZmxegiEZPjRTXScUiQU9fpxPndF4EqAZy8oeToa8k,23 +onnx/backend/test/data/node/test_xor2d/test_data_set_0/output_0.pb,sha256=wYcj4-6dNRFaXwU1hntV05Gy5aHpr9Vv7uCuV61ad50,25 +onnx/backend/test/data/node/test_xor3d/model.onnx,sha256=cQQUDctDV6dJcdwK8vYh668uk1M4oHKIM9Oueba62ro,131 +onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_0.pb,sha256=Dr4k5dppNqEaWmFsMUXw_Pbp7QoEpqkXv4Bodqt7zMQ,73 +onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_1.pb,sha256=v5SpTzEGQijgxpt3GQdqFdpD-LCqlDgrPace75EL5pQ,73 +onnx/backend/test/data/node/test_xor3d/test_data_set_0/output_0.pb,sha256=Vh-V32zTffsrBgNhRvfhcFOZ1svl-bmYxXnxZHCuAQM,75 +onnx/backend/test/data/node/test_xor4d/model.onnx,sha256=zorAb8QHzWBFMEznyeOGSrgu-gMQ1B5BCQYS6sWXNkI,143 +onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_0.pb,sha256=sMKxU5gNQx6mv89ZOkmV0QCdEu9f8EhE-MZuoWNbcek,376 +onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_1.pb,sha256=9JaUvXVRf_NYTRwYWtPYsbSoKJDwOXPZuRBgFY7pYPc,376 +onnx/backend/test/data/node/test_xor4d/test_data_set_0/output_0.pb,sha256=7t2mIHhiY74BIpOpK5SfckyO__tT-EiLhluUCYb-6TA,378 +onnx/backend/test/data/node/test_xor_bcast3v1d/model.onnx,sha256=ZareaBAuTyUxBY2ReZrYhH1ejl0N5Qpgu45vJTsqlOQ,131 +onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_0.pb,sha256=wF52hvLEXCfryTN0FvgWPKXSx3PPlpiaC_aAZ5IXCMc,73 +onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_1.pb,sha256=0cP0kHJ95VbmGsyJW3rlozPO38YQocSctc5buLas0ZI,14 +onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/output_0.pb,sha256=8tkEvTgVHtTWyJZ3JJi-ap4ICdUqb0TyJoYleM7Xwjo,75 +onnx/backend/test/data/node/test_xor_bcast3v2d/model.onnx,sha256=PNKaP79liHG8NtmiYaeafrRs5qi2XUSu5fN37c0RqFw,135 +onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_0.pb,sha256=2Hi5gZzCyk3SWtB8dhtS5tIMipISnPJGI1SIjx08Fe0,73 +onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_1.pb,sha256=J1neLsOqZHTvGdagBF8_3O6sQk1byuUIMABR0wJxASA,31 +onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/output_0.pb,sha256=jsMfiHOic7b2QO8cGqTo5WGnBTeBPx83WXxh3j_bLkg,75 +onnx/backend/test/data/node/test_xor_bcast4v2d/model.onnx,sha256=jG3UhG63Rb3lWqlONWth4lsfURxHt-y2M_y10XGgRTU,143 +onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_0.pb,sha256=TG9PpNJBW-rhSdwYDpmwCMotWc8SOe2e2cLAoXaNQ8o,376 +onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_1.pb,sha256=D4JIlfVUzijC8rk152pkPsDWa33YJRlmutjMvkT-1FI,41 +onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/output_0.pb,sha256=Qgh2Pvp5xceZzOVQ9LbIq5hSoPcfBb2a3_UVolJSwH8,378 +onnx/backend/test/data/node/test_xor_bcast4v3d/model.onnx,sha256=ka5mFaag2sB3Wo-gr591NnmvwsVpkR6hQyR6KBmZWY0,147 +onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_0.pb,sha256=1gaunFCw_HO0ZAf_sAp9bfcwVRJW_aTJIwkv-2WYWMw,376 +onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_1.pb,sha256=26gLYNI9eQESqKzWzx1zrE8YDDCNIvfAE_0m_FoeT3E,133 +onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/output_0.pb,sha256=PSXb0kYNrXzlksKUyQCNo2US4L4q5PW5JY-q8RDCTDc,378 +onnx/backend/test/data/node/test_xor_bcast4v4d/model.onnx,sha256=itvh8evQEuNJ5pxrge9J62QTcH0OOr_3FRCL-v4fOIw,151 +onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_0.pb,sha256=f63fGhPch5eTkAvMXCrJTC0FOIdhKnaSfJ8Ox9hnol0,39 +onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_1.pb,sha256=iCGDAU6H1-WHvqKKRCD44UWeluKsnFCWMpevbsJ5ASU,105 +onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/output_0.pb,sha256=K5QEaUMGmY5feFywFKuoQfnj0csdxH87pELYOw4ib6Q,378 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx,sha256=8mAVDhS8q2983UD42Tn2UtYcj6o_GOx31Bf6rOQnmic,234 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb,sha256=zV1Vt8e4rt7BBMwCWTvpZ4ewNN6urxrFnE0-oTAebYo,155 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb,sha256=qn9ze93KKekBUHX1zcPFPQszhnb0xCGUQ2cUi4v-PBc,82 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx,sha256=8mAVDhS8q2983UD42Tn2UtYcj6o_GOx31Bf6rOQnmic,234 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb,sha256=93fhfQkyWxsVEbiwnmhx5RtN3NuGixryFHcYGrBqiAk,155 +onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb,sha256=V98iRFVVabmSxa6RQGlOA7DLuTsCfMwULBopoq5OgEQ,82 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx,sha256=TB8sJRl2IhMEO9FUoayJ2MM85Fw3RhU9W1e5BipjB5I,180 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb,sha256=bNLdgLPEgneV2dYpx44Z_cNcu-P-1TtLe3BxHBzvSSc,877 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb,sha256=F40fDjWldQJxabM_XYkLzpEMez7jL6OzeJlgbouXRrc,229 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx,sha256=TB8sJRl2IhMEO9FUoayJ2MM85Fw3RhU9W1e5BipjB5I,180 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb,sha256=TpDPisxlYGn58g52CgJ4HAsFm-BsfjIwEszTQcTV8y0,877 +onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb,sha256=Y_cshxOA9B_1xVCMY4SBn0Cmt_NuFf3gL5tmh-vNvPY,229 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx,sha256=pJRrVDIgyVnsXheUw0l8DEsCI3H-A9E1Fytt721SEvQ,196 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb,sha256=n-2GBmhLD0xffKPoJ5FnFBEW1kB0aMyZdET_GWifw6Q,1551 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb,sha256=FShc69O3dlB2g0mQ8-jI2kGpMyTyWdMA8TAFosrPyQo,207 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx,sha256=i4Ana78vTj4DG_7vWo9TQqp8rR1SsMJQzNPtEZtncdY,196 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb,sha256=y_Tl_lr5uoFfr_mDOVp10o1Rqwto3dUX7uyqbZphtlY,3015 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb,sha256=50IuhwLSEvlySwQziXRKplBocjNERvL_Ug_QVvAtZ7E,207 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx,sha256=7bss8slZ11_xPh6ekLnbPqwSx-2W7nzBlfSNrWguH_s,196 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb,sha256=hJelxSiUlg_o8SL7GnKSbwzK1xTJmFwOGbYnymULc60,1551 +onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb,sha256=PRmuI0KY_2RPQttWtH8mIBA71Ab1VLR65BqK2vmqPXQ,207 +onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx,sha256=KavPmaT-7YmXr1yv85ueUtemurjesyB5noD0v3Mc7Rc,378 +onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb,sha256=WUmYIvacvUxOv8Z44Vt5oWHP3Rq0lRjXV0uTRrVB4O8,251 +onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb,sha256=F8hXf4ujaw9wkKXJOH22sy9d-CfBDLp13y16hP8_Qg4,251 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx,sha256=8Yd0nlXaftKBaeljimCYJXMW99MU6ro6DDMkNFQzZ1I,354 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb,sha256=WZIsl8gdTSpkybVdM2eC-UDdnwUclJpv6Ciz1dJa2Vo,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb,sha256=prMmsJs86e9qAfIsik9a4EIZbCI_YgdcebO7mH571KI,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx,sha256=pOJ6Q6RfjazEKRDHG3tfkl3iPgf-7XzDh1NdW6z1zIA,354 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb,sha256=Xl_bu5yQ7sA6heXBH0AC1ycwOKKz7x8yyDnXqGKsNKM,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb,sha256=0UTSeOyp4AgM1BSqfX8F1zt4Axxg5eWpxprQRlb-v0Q,877 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx,sha256=oQCFAVSP_Lwz8YD_w3Qhg99sqtnJ-UPESFVhyfm_Z80,362 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb,sha256=xWcOlLS21xbvStXK5VyuQOqhPjlYHJVyXl7sb6DhOwo,1551 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb,sha256=QLvTKHFqJsIIaKNyJPxi3QB5_rQtQ7VJ_cvQ1sdPOKo,1551 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx,sha256=yjD59gbBFMjuznApZPsJOxDoyKk1ce8meoT4y1aPun4,362 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb,sha256=KIyabETJj2PkS0Ck7y5IPAhEXrPQ3QLsQlstwZvCCnY,1551 +onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb,sha256=et4SSsQj6ySOcT9jh8TnzwTGicmyngVZafqJnWQ0q-4,1551 +onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx,sha256=0SsEC_Z0DrELQVHraXG6BzRPfrdrI78eD93nd40gXXM,177 +onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb,sha256=QoOUMz7CIm79Vi7-FqFrNH_Fpm2pwjiJTJ5KHGsB-uw,397 +onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb,sha256=crHpXo4F_TPPkniDuVYpgF3TfubVLZFeSEKvqhTkvpo,1861 +onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx,sha256=Z4QCn29y1djJ3JZnuFj4OIgsAqqSZj47jJ-FpQqc8Q4,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb,sha256=M1p3HfX3tyCNxMOUXytdx5cq4AUFr38MGd8C5i6PTHE,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb,sha256=XG8Vzj2qFCJBwS1zk5kl16mtDZXs3GjkTqX7kYHINqM,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx,sha256=CWlj2QY04xL0V39Rf_Q_Eyy90kVUXLK6lWICIpET2KE,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb,sha256=3E2ZYHLqPEaVB7HRQ5NvJlXwC2luExxp_d1W2XYUhxI,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb,sha256=Rs6ytMEQmbUEfOLDX76YAQ6hDS-JxU3qR4v_lisgyd4,251 +onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx,sha256=RC8liAaCSm35TMxBRnNrJKIMam82QkW1Jkc0O_qRi5w,433 +onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb,sha256=i2XCJCDESsEGqcZJiBpBtu-jRPVzh7K1h9PecjAtXK0,203 +onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb,sha256=Do0wjZqxfKbFCsZirn1INKtXTYSN0669VnKHyV-7wvw,203 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx,sha256=TARXa4saDVX_6iYTSr_N3VAWGjAh65alUwmJi27dOBg,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb,sha256=vCs38klXgXvMU4xaQIA24rh0jrrlgyZ-JknlD6uk_0w,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb,sha256=5l7hug7Ooa6l_1pY7-BPJAQPe01YEanl37UKEalctvU,411 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx,sha256=RPJomwlFC-2ZMW2wwl6o6YfYAtuprYuVgvnNE-NMsmo,473 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb,sha256=BV9L90-Mjw_hKFJo1KDsckTs9KNfDEYYNzOtEDEAbEY,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb,sha256=QrhPUkU1IiaaQG9co6aeB7PPn6I8zgqjRG4Dyt1xc0w,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx,sha256=6BtfkkYnCOH_OddQBr2fi6Nbbwjo9YWCPKonFxCBW7A,685 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb,sha256=KwIVOkQUfZQsyVi4WOkmxQQ6jrtqcbVC9Hnu63ZoblQ,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb,sha256=P8I3CDmlvUVih56z4CBHvo_hwq_FP4AtTab4nYieP4Y,411 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx,sha256=ZWRfSCErOjTP1vHZYQlCHMv3poCqHNdXlIZQ2QhVakY,601 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb,sha256=uS_fv_8ZJYypoe5d-EBLOLhaPQ4ATE_KPHOIQ3Gqeto,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb,sha256=oK8jgBMFbuJE87uSWda7mMKDDjFBmE0Vts17x29g3Dc,26 +onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx,sha256=ptjiJVis2eF_cYg7wJuQy01kSdZ3LZjuoILl2hSdnR4,525 +onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb,sha256=9CHLFEq_ik_V5LaqT7mcz6SNeHOIhuIuv_jvyTNSRrk,331 +onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb,sha256=0pNh7Y0jeuA_RGC13raCipZ1qiqZu-Yz7cL1jAhOlEg,171 +onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx,sha256=y432KyJAGqZE5G4TtVt6xfPDgU4AL_k5pLvhEnIPwGY,593 +onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb,sha256=1OBmuNrH0n2t8NGHYARcjbatJIjaK5tNQ3r5RJ9td5U,853 +onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb,sha256=Jlk7Om0xPxTfTD3ERkm1VAo0x_lWP1M01vtDQ-MOGHA,653 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx,sha256=ifRT0arIIJm963Lu92VvSZGQoS2OQnQh35GwDZVF_BU,449 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb,sha256=oIPHf9UX_VMt_rNrr4y-WwbCf3Pa1ri9dzYzyPtDCAk,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb,sha256=_RPmQnqkoj4aVc9bQIhHiaSTggTE3t3AtUEfL1DhddM,525 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx,sha256=fpGjNOhOxeUycys8ikMj065ilM73_LW2yQbz2h9ZqoQ,449 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb,sha256=8RivKZOj2PWj__57mFbs9rnGXRyydS9uMXCK7_D1-hs,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb,sha256=DHO7upgdKnVIz_7I0aN-oH1prFbEDoWKHhUUuD5unNA,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx,sha256=9BZDcN_FQ4h5-GuyKnsrFiqFluDBhVzxy7ZjQYAYv9Y,449 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb,sha256=z4xSxpRG1WwCJdeH1dvUR3B-8pzhtCg7ItADQTwkoNs,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb,sha256=hKMKPzFqMzJQW_UZrWEU4utjyHzPavSUrjM_QLccCB8,141 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx,sha256=p0zmWsZaMksp0qUv5dTsNa4bt-LLPIWkaUOeB38Q_YE,609 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb,sha256=4QOtaGsL1JztJ46gZNxToNKt-hzvC_b-gavbU-JTrvc,1165 +onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb,sha256=d_Gg8Pwi-UEIlyZPIIZ1aIpFFv1whi6Ufjl6-j64yxw,1037 +onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx,sha256=M4Tog0lHqJerdu9jcCuKNjCuEVOW0h9Eq4u36T7hjwQ,513 +onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb,sha256=R6GKeyEpmjB3-rRHJ7mnjGrTRfKCFJfguLjBEnZiGH8,1549 +onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb,sha256=w02ja9QxjYGDw606aWk7_oSr5lUCoStmytZlVme1evw,157 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx,sha256=uh-iRrzSbF6r96Jq4NTGnKV726HBDnv-5phjp3iiEJI,601 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb,sha256=ATzHdOKHF7WLjEWSJmSuW_6v2nEyhI2ixRB2r8lbfvs,973 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb,sha256=jECSkjosOUIiACcNQrbmZ9wSua10w1XivubTJ9ExL5E,781 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx,sha256=4x_JVppcm1xB2Es0ZKdSu54IT3X1UfN6pF2LTdsRVZA,601 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb,sha256=W2rRPvSGGsPzKpUVpFBw2eR1bfsdMu4vo66myacAb0M,973 +onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb,sha256=99GiPC_yeuHqMA4l-fWHO3Nrfptqn1h6yiyH5Vhyj40,781 +onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx,sha256=ZsLuWnDa5_i6ms1o58ROf6NeBf82JHq8Jyg6ZK0jNxQ,546 +onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb,sha256=5AjXIP60cvhAdvKlUv1Mf0dnZ7YOESiyGhYH4A3zzMc,733 +onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb,sha256=XH-ZGTgDbQGOnSfcNq-orV6S2C8x11xzPDVUknUCLvg,525 +onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx,sha256=7R3bRZT7rxJC6ll_papH9LqxC6xLMXLfjjMbOSyu8NU,737 +onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb,sha256=Cy-XsPZPkHKiafZJ9Y7iR7zj7sVVL3i4RAIjb_HN00o,877 +onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb,sha256=YZB_7e9uqA8ER15q1QenHfrIUXt2fQnPgOTbLX8CF-U,301 +onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx,sha256=egZ--Av5rYKCJMGEGGns-pbOVvH5tqyISxx6BQqZeOI,737 +onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb,sha256=XIlefsfSL9PVbGn4KZSR6YnajJ71vd8dW1NI3rlXRQ0,877 +onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb,sha256=_OOVJ1t07lBsD3OmyMjhCFDd9iQeMw19glVEC4lOIaU,141 +onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx,sha256=16JkMwetdzIJqDe9IN5rsD6C2fCNZUWat4q7kOW9vYA,1481 +onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb,sha256=4If0txoCf02Sxyb-TKsVSmnfyPeCyJUl0vlDcjhb_3Y,1455 +onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb,sha256=i7pEvDV-ZSeyS2rU96YaFK_KLKGPMtulFLQJx7ERNwM,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx,sha256=gJoR548aEmQX7kEw-DegL18l6WG9PZiRG4myAGZJLLA,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb,sha256=sgU-wF7Lo5l0dwFX_FgXV2B6pO6PBk8C6Q8VuYl37Jo,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb,sha256=ZVXm7ParEHvjD0FRcLyDw0sCStjwNg9LzyfB2YFLaZI,879 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx,sha256=MF7-hVNyKxpSOYCPOtMqj4PPLumZvEyNLpKKdH0VZ8U,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb,sha256=EkFpNPI0uV-PEtZqr5nJ4DLxhk94Kip8KNpzHEL0Uq4,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb,sha256=UoxcAqI9HHOERFKkYWf27G9B28-MFakBAtIAoYhQiB8,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx,sha256=v9ICh0w4hqY5snMTyD92gTHhW1g7VQ6WVnYQoLSa02o,1633 +onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb,sha256=M_PRS9s6oz5E5R4hGjSJG7OtJdfGLWGW45Fn_UZWYY8,2575 +onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb,sha256=npPaSWCc4w_5xBE4uyXB2YRxGWa_hjmxTdOCrk3kb-E,591 +onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx,sha256=M-IZkgZ_-Br1YoiwQvut2UFFXftUFF5UuqcNniqn_Tk,1434 +onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb,sha256=_MHSqR1rF_XUblE_4HbjInNfEM417inei05uy1cPIeA,1455 +onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb,sha256=ELnUZu6Tub3Nt-SbqAnuZ_bF167tpWqqxD8TE2rsa3k,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx,sha256=EZb1n6bYJciHlcZPAzV08Wi7q1HcxvJXCy5aPOfynQ4,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb,sha256=HSk4UoX2KpcGlXg1SnnnWI1iUKh4PkPXxdGLlx6fXQc,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb,sha256=QBprsW8RzmVrAoLVM0VQ9D1DOBZqh9YmluoNuDAlPKU,271 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx,sha256=LDPW0JXDJeZnhYI12RKv_IwIdrS1U3GHr8uYEY_Ivi8,713 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb,sha256=SswSGowYkI_cfPsk1g9hEVsurerN_J2gFJJ_aPiGKwg,3015 +onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb,sha256=bmi0M7qU67vZyg50hdRO46QU35LTp2SmykyEnr3jK1Y,879 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx,sha256=uiawKtrZn1qlhaKVjfD97MeD5wpWP4-BgfsgWqAHAqE,772 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb,sha256=04V2wjKmR5vpKXskDgyX-9EPbsPah_j6pnPgdn5m5ww,517 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb,sha256=2sxWuV8VYus2X51ShW3kRGXXB_YgSaP4pFbPkVxWvto,3853 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx,sha256=4pzDYfTqDObpNKLQDnNoO4Sf4VCzALkhnj6g_KMbZXQ,725 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb,sha256=cDragHQ7hS-xtN1fMIGWyMXJ2NerZwn_JSD8CNZSGAI,517 +onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb,sha256=IA0L2r215O76xM761W_inWJBIV2dK4SvKb6guj76kt0,3853 +onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx,sha256=2SeXax0MIzkha8Ha39cc2bQLXMTLIUwAgomrGh9xbaI,120 +onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb,sha256=luvTZVOagQKAbBjB9-H7TBlYEFI2Uqu3FTQRMTybmpk,130 +onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb,sha256=3p3X7-mRaLL9ssscsdr9mHcY3-Hn-b0bbAJ64qKhWyo,130 +onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx,sha256=_0o-LP_DjPwbBW0Dxap5Bprj7jdlHjX4UfbmKn4dZ9Q,188 +onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb,sha256=_0rc6-MctiMvWy8M6NSWVsm4bVxLADLFjOhsTv8xIMw,40 +onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb,sha256=j1g-AeOS1kcJXRL72P8UHZsuaFt2UiCjUXUoNDKnZRI,58 +onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx,sha256=F5vU9vTQYqruQnldJ38QSMMLOuLQJEDfmwy2XlDO3hY,188 +onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb,sha256=_0rc6-MctiMvWy8M6NSWVsm4bVxLADLFjOhsTv8xIMw,40 +onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb,sha256=poXwHivKwggktTHae36VM5QmG8dryXX2SOtNAVUssuM,58 +onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx,sha256=HQmhBaiXteu956BHP9oxeAwiqMlBqDwSX6tEsrBHau8,156 +onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb,sha256=S3wGQIwYbwGN0JopQ-SYCMqnIkBQ7EbqwE5OQRUBJ50,128 +onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb,sha256=KFzb3xYeFeA9xHmKlNhI6AXtfYCz99ON8DVzG1oihmE,68 +onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx,sha256=Xry3Ey1Ohmwx0Ou4JlncDobNbJVSokkJ2CyG5qj6DsI,155 +onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb,sha256=qgaBlwPclOrBoRpDWaRQKo47MQzUrXcHEoJo9op9vnM,851 +onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb,sha256=EEGmzp1nC91QOMpO3BXPusSKwYSBpa664LSOkOzCJH8,431 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx,sha256=iQptij6gd52DigK_wVZk1PNZSkgFwgzOx0w6iePLeeE,126 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb,sha256=SK7wRI8g-o1mvSNjDS9utXtEG8ATWXM2dr1VGOW3B7E,130 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb,sha256=q-0YWwHtpdz_9DWan9IbokhV1p9ti73MMonkFJpJ710,130 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx,sha256=NM4JUm95vZvdMzAT2F5D2_q1XyfmtcCsocRF6IcpC-M,126 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb,sha256=djYXx0SejTe9i5wHFcKEo2abs4zfpMbcRLtUxikCSJE,130 +onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb,sha256=BCvDv2KDQ6j-LtkWz5ZcSs_6ZgNyVYBsTEpY5s_SxYQ,130 +onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx,sha256=YKNUaSXYMmhseI0-oicy_q71vFJ-BGkcMuyfZ3yB9hI,585 +onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb,sha256=EVBDYsD6CZzsPoADTCeqHJmWarSTvnqSUkucBqN8YeY,169 +onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb,sha256=Y2MWMPgxI58ITCWNv9R1pkfR-I41JAKqIgdzxvTjoxQ,137 +onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx,sha256=Bxzkm2mGNbCQSHaX7ObRgizQJdCQL0o5-XEbub1DPo4,492 +onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb,sha256=pdTU_UjclLXaiQv81fct2hf0azMiw-kEUrvR4Y7eeAY,169 +onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb,sha256=GLoTdF0mNzWWJSk7Eh1dUDd0jJtGYRZv915Fu-4wrYs,137 +onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx,sha256=7OG_h8rN3YDf9U3fCDZxSE1snbwrkZE4qDytlOnLm0c,115 +onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb,sha256=aIvEbzha6zVWoOMyDQk0X0-F7ycVmOTQQPDPzCK_fdM,809 +onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb,sha256=kcLfEFJdOk46YnJH2AKfD9a9UeoM35TZKOLZ3H1WTdU,809 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx,sha256=IEtciU1nSV0VFZbrIf55J6lfpZ6_3VXOvgyPbdStnr4,160 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb,sha256=NGuPnKs6gIclbkt4IRL1z7WvbPm8A0Gu2fX-SaNVePE,331 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb,sha256=79siDNKe866D0fCh9xWgCat_Iltxvm7n-C-8h6HK2qY,90 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx,sha256=IEtciU1nSV0VFZbrIf55J6lfpZ6_3VXOvgyPbdStnr4,160 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb,sha256=U6fj0KCQ4sggGDgUtqsPr81b3thuxSDfIYAuIK3q0ac,331 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb,sha256=9l6v8PiMMo2UIsA9mYoZcuS7ewxdsrqfYQPwp3XDkAo,90 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx,sha256=flUyj5LMCtVUzJvaeJGW1xkB577pgEV4YIcczdGPNVY,165 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb,sha256=4qJvUOWUo3f91o8JddOTERM6MTcohmKrISyEnefIeiM,880014 +onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb,sha256=pOgx9JOSU_e-2nS5DZpaauJF9NpUBcDjN9OTYyVlgAI,87298 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx,sha256=6qw0Jl0dJZcgUXdgknbsKXPEtbxIPBxBSmuWU7TWBmA,176 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb,sha256=Gz4idq9I1lPqAHpTOusIQ_hfTeZvcEw0pXwdnFibumg,601 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb,sha256=fkrqthNBgDvYIaVm_bv6g2do8vvs-0AMbsKCLxf7DJg,205 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx,sha256=B9dO0myVpZkPOTNRE_KSWNGZ0a2zALqPoRIpIEjBWg8,180 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb,sha256=KERNzX0dOh2dZWTf0dVh3ftuar0N1aTYH9kXJSuIjfU,4000017 +onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb,sha256=qmgdxgxSdjm-gXp16_WG_bGQn6U29XRZmLzNN8sljis,4313 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx,sha256=EkVIxU2Gvd-03OLvhzQwdP9gM48Ila14pNmsySHlTJ8,192 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb,sha256=dJ5NUUUFLIBlKgA8CIxs2U1CdTelFQM6GaOVcjdfXH8,3015 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb,sha256=MxSYbK5mw58Ewucz6ommkVScxLBbaSHxhnIoaYbIovE,207 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx,sha256=EkVIxU2Gvd-03OLvhzQwdP9gM48Ila14pNmsySHlTJ8,192 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb,sha256=4xZ_MzlwtkraNLfBDMDjlNHR87cReCK4aN6jKCSvfic,3015 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb,sha256=jkevhpPha2nlXOhpYzU6bPhiiNhixWbDdJz5Yh6WT44,207 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx,sha256=Y-1oo-lij06opYfKEwu65De_E_wn1_M10syRyZD-OrU,192 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb,sha256=vFZi989muj43A22p864N0y2TeuLIirF1QEWpeo0g0cQ,3015 +onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb,sha256=QWM4IdynZ3TeBEWJlrWcmiLuRzF8-GUDsIjU8RRaeRM,663 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx,sha256=4mjvE2iJgkg7zRTS0Y0Mwmi3rbxDzPNAXF6lw2kW0BA,140 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb,sha256=dwCj5dOo0Xb0LWoFEa02MXjNCBKek1Mb7p9loqn-qBY,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb,sha256=WVVfw7lN4bUO91ljJuOCrF0aAsAVeO7VxMWLJCPPf24,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx,sha256=IvY8tpSEk0hJlbRtt5J_IzrQsIDrbYvGdRmHj_kAgyg,148 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb,sha256=qUglE2t9TlGG2PODCNryl96IZCMJRnn2s2kFKPtidug,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb,sha256=kTwdDuY0JawlXDtQyKba8alf87POvLW-H0svciJZIRs,106 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx,sha256=wt-aOA3QVpCLDlTprLv-5QTXKC9xqFoAF90G6m_D1Ls,148 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb,sha256=D1kkTnMRur2IBSkmCXshOMXBM31Trp3gcsBnHLoxwPY,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb,sha256=G_Dp6PuiE225MDYlJKnajeiYlMCwWTwm_3EvFjOzfto,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx,sha256=kukgvtj4KMURYyG6ZxeZb7uPkBlyolfPCSDI2O99Jk8,157 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb,sha256=NVK5z3BB-7fMzSpEAVe9KJ8_sjW6_oteQ-lFs07YMmA,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb,sha256=5SPkRU_nkyPSqWawHP_s5I5nFnGXcea7i6rihB_vWHY,493 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx,sha256=VvZt8tBvrh1vuaXYca3DxeVODOxpsz2IaSRWtPgh_jQ,157 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb,sha256=kjNIdTEFfb16oMR_21gnH0-x1yufQ20r0JJwtEt-4no,2895 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb,sha256=k6V8hNaUEXKnZCUTKlyCcADbPdyZwabu97D4qzyU63E,2895 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx,sha256=6I44FjDRNdOgmuwdeewtzNZQbbTYuPs50CxyS21RDIU,165 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb,sha256=7CLbhHgR9jhf6-fSx9oVVDPkyB3qVJyRqQVVsjM8TnA,2895 +onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb,sha256=b6pQPzS39brhgz_HkZsQaIU1rvRZP-ONgl36n2vGiKA,2895 +onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx,sha256=4JEqlXzNhKwqniaLCOWSFSueWfuOn7VbaFKr42KIHKA,331 +onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb,sha256=A576kvtGuxWcgI872W5-c89GMBV1iQTtr6ZzsihfJf4,589 +onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb,sha256=XpsHUnOBLIoYD7eZK2V2Qwq6haDNVQI1_pg4jJZ5Zm8,589 +onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx,sha256=tCWj-a4XelmO7y2SKKhmBKytRa9gzWH04L64BxoYBGM,569 +onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb,sha256=UKNDvDbMADHM63IF8twG9QID6pTJ3Cdsd3AazzCesvk,409 +onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb,sha256=W2gyxT0Yg9UxhnmysFE9lzrGT_6F4ZywIk9N5sxkiAs,409 +onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx,sha256=54bYFvc3RA1Ljsf68rFWpoazyI0bo_4V8nOzFnkRFKY,112 +onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb,sha256=Ey2pRpSgVvZhAp_fXdJLIVAidkpih_7XTMas2aU_x3Y,493 +onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb,sha256=p1LjECbj3CHtzc3dIr05bBrD_GeLzWOd0xNVstAg-pI,493 +onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx,sha256=rRj1gGqwtSlWd14E5jpTt8i4gXR-gsHktOFH2VeclpY,159 +onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb,sha256=GdrCTnPr9lRVY_XPRDeMDg76bWDKxczmbLprbhFz81A,1549 +onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb,sha256=MItKenrxsfen0QqbAl3PIx9MTh2X8UsVszVaYmbTGNY,3973 +onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx,sha256=iWrndt5r6y9xH9tJWVR_srvWd3qHRI-YzfMLgHIe_x4,156 +onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb,sha256=rvprCAB87mJqy5c2K47dXKz6lXiAg6Vk0PCSNIIf8fg,397 +onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb,sha256=CpGyltobSp8j5PiTJ1ELDekd0BvP3YG9VLaB34ibKds,1861 +onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx,sha256=kbYX2BrYvTBNgqZ_FNNx5meiOXyCu9-7tFlQvzv2UfQ,104 +onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb,sha256=57MtXdSWmk8rV37-gl-meavMAFrNk1I1U1jRtRnfQv4,130 +onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb,sha256=vUvpliH3lpuLdxxQcTLm47OOxuFnkSlElGzpcbbcTlk,130 +onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx,sha256=r-jXvTu2OB1uoHSEc3weUBfipW-j-bomHEToiLRndZg,115 +onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb,sha256=xGqhiolQj1AXF_J9DI6RshclHdkTtvUfjA9UNeoH34g,493 +onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb,sha256=_aud8_qgy8myKoty42ouDGvc8LqB9P0wziM1WT9Udv0,493 +onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx,sha256=M8YU-Plr8Vox-xvg2ytI9dvOtVRmfrFA1WFtqrz1RrQ,112 +onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb,sha256=Mc2T2AKRlGbMn9JhKQCqvdNhMOd4yv6eoizRI4rQ3Es,809 +onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb,sha256=cEBcNyA-UO7PvJP05BNFPg34O0b9xuI2oIH0HujbJCA,809 +onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx,sha256=LkzcLVf0mVmKlV1Q7LaRz2roqZVUWOShqLA0F7CS3qw,125 +onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb,sha256=6EvkXgsM1qeqy4xXvrNmjzFgQIfUg1LADvKujrkhutE,809 +onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb,sha256=dM0ZzuuwBljCYCl5gwtz6dyl7xbwPq06OSJpbZz3rl0,809 +onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx,sha256=LW7eq1fDhqzTUcpreFM8MW1P-SXMU6R_-6TrI0bSeeY,100 +onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb,sha256=RHCWvbZJ2puJcskrkyp-UO7VJXgJbbtfngv50m-XBrQ,809 +onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb,sha256=T83BVCZNzgIMJeO_KjnLFCl3fvO6pI2swMn7AcHv2z4,809 +onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx,sha256=77Av428IZawS315gnrFwnQoxmzSxc8yyvjGvbpcg8I4,191 +onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb,sha256=OgR7ov0pN5ABVMr6BCcNwgO5LIM2kD3aZC8cakpK-JU,130 +onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb,sha256=dgsXbFOSn0KYtbVe_G4dJ--YwtKGY50m5L2hcy88lgI,130 +onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx,sha256=g7REbYpEDQKk-HFEUTr_edrTqEJzP7p6U41qAyRe9pg,112 +onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb,sha256=h-yYS6LvZ4ydAM-99zICo6VeQT7O187lkHDazxIon78,493 +onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb,sha256=GFqBj4MG7PAiujxMR6uzcTqQGD8YumwF75SzqvusSdo,493 +onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx,sha256=mijCH0L13fd-XfpTow-vPLjuxzYrpqpewCmica_m4RI,177 +onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb,sha256=a2xkpLGBgCHkK36Ch5z9mMQMwaeo46gYSt_95Q7ViUs,397 +onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb,sha256=6aGq1RDiXJoI805HAFtG0ryTkbOZ6KvzjeoNUX8ZVuE,1861 +onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx,sha256=iVa0we93ifXSp1JapVRj8Hm68mLpWXF2QQOmjcBZ9r0,131 +onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb,sha256=z9p6Tc4CGDfcMevMb3WI6R9nKVLSrmdsPnwCzB_YRz0,493 +onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb,sha256=5NXTb99k_ebDZZ8QdvNt2ZbVhIREH9c454g36hZXHcY,493 +onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx,sha256=6b1s4M7kUTlLThqFJhrps_HEEDGGMRwmDcvg3LcMk7w,126 +onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb,sha256=vM6J5cm2YZRB4tCZwuPWtA4ItF8o4Hglhi78iySDgsY,1034 +onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb,sha256=LCqEWC3UH6W3AVeGaohUPNU8BJ0Qho_C259h6WlUN9U,1034 +onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx,sha256=cW81QWpRLL4gWbYmKzo4crNfSP3o5kv7R59Xn1NTOtY,128 +onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb,sha256=1T7S2mfA3VyTw_Uu_xR1KZOkk6fR8gH1lRhqe77kCKc,493 +onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb,sha256=i3rXEzAEknBVyPI7uZ9b_3quJTfUfQRlhrHJPDzrI6U,493 +onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx,sha256=AWWX8ISlHkfjfBJr-8cOPCVIVplDrZQ81mBh1Yg_3EQ,114 +onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb,sha256=II_c6Nd8HW6Q2S8wb99jN6__oTjkOq0LVrftA92K0Jc,1034 +onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb,sha256=L8ZOHtpkcNP-l-p17BcmWTK6ZUDAGA6OtgpSwjFwxfY,1034 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx,sha256=4yoo6WnkuoE4hyDHi5yq3l3xs73PPdGJBDn8tsCtbmg,146 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb,sha256=WeKTF2a0gLSgFSE7RPu7suC8BakLI5JwxRIgcYBRMpE,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb,sha256=GlJ6YO-W-nl6W8Rn7NiA3VQBynnDcw0CHU0K60hAPxQ,30 +onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb,sha256=vAWPseKpiLhg5xbLv4brD66PGujVCowAWPy5xHf7MNs,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx,sha256=Q_3UC9xYgU-Z1FCDqowXgtQYE5TFM3dv_nvw5nAW3GM,151 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb,sha256=dBZjS6f0YZq-PAmutf2KVyc5Ic8lkbaReqAjdLKIv9g,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb,sha256=Jm3kGLGMLfCLdjtlidztrRUtVcz4HaHKYpZojt7FbHo,24 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb,sha256=buFw95HzCCj2kzEsyFxO6VbO01-le7uTqki3YineAh8,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx,sha256=4yoo6WnkuoE4hyDHi5yq3l3xs73PPdGJBDn8tsCtbmg,146 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb,sha256=G1yJUQGsG2uWKJX9PURVlIHVI1GLbKwq8oLWm3v9lEA,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb,sha256=mH_dZUm9K3R0jgvjqdsWve2qIOmh5Gu8qVQveA0iQyI,30 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb,sha256=KaDIjtF8dJTqVmxbm7bl-eNiGZM-3z4NqdhX8MFX6mg,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx,sha256=W0u6KMQhEmUHe2aMKtEd1LP8RhdYPE42ZX0h4U1zU3Q,151 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb,sha256=Hgx9BDvjzAKv9uel5a1TqPgT_UgnDmf0WC7f8d3QDbI,56 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb,sha256=DvWV31gp254KnBk4m95GwdcvLI8e7GI0PIHV7Fb4akQ,32 +onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb,sha256=6EYYoWZQq5vpFlC5uj2bjNQs084U-fyAJdb5zLiphZc,56 +onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx,sha256=PGsgLxLVxE6B-YnT5dTigfgO-0VUBuDkNxaLHQIpzIM,158 +onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb,sha256=aeAhCMgJONISiYFLETMGwolmnEWUviB-0r05x4Dj_QE,56 +onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb,sha256=3qSzQRI4ETvMsUTXU1C91aUqqIWvz211iPcREF1jNL4,56 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx,sha256=pkXscfFqeA69tuw-s-5H15Yo8M5_a7-vwfoUF1E2kjw,245 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb,sha256=F8HIxuMvLzdYqNBU1WOhSu9BNb9f8sE2Nh4LScjkCv4,32 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb,sha256=wReWT7hu1wvpzVbdy4OQ3RLHmIGleWudjXtNzQxN3z8,56 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb,sha256=iSPe0APqyrCBab3JfQTvuXWKxYW1jq3wMM0ndaVHepQ,22 +onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb,sha256=2Q0N9b_FX6_Eli007JAr0zDu3FWCKLmiTtqJqJJJ6AY,40 +onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx,sha256=j8SoAGDrf68-0Ty2zB9CuCbVpRP0WA3g1eYPyqwwthk,168 +onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb,sha256=Zssp45J1LZPvS6jAzlFOyLE5-R6r4ib6u0lGwdgrrls,10 +onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb,sha256=miH5Y5Wk3S1nVM23Js570P-CGR48fQrIQ2nUNDTy1U4,10 +onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb,sha256=ZFQSF2mOXhSlpLV3SiXplTBx4phBjRd63bhIcvS0scg,10 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx,sha256=Pv5XrJq5yDInM7YsNbYSFxdbZAxWT8s4a1yK5uX6lWw,138 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb,sha256=4UQkC9my1MZR7yS-gxUxLhHoDPcZRxOKVvPLOmF6I2Y,18 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb,sha256=vcT6Vt5kjiPQn_uVM30-vRqsKZvb0EHtSHQA-Zfe8dU,14 +onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb,sha256=RSc1IkqRdFLMBmDEQ7JzmC62gTBmianfJ-_9l05ev3E,10 +onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx,sha256=d4_FGVudXbf56YhRlKKo7749XttVrIqHTtHnihmtwGs,126 +onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb,sha256=4akqZ8FX-HKNqVP2ano4QBijtZtg1XKrXBX2HLkDYYI,56 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx,sha256=_QTccgjLy9EPX9UF-JVnTvkGZ2QxzO-WCQCVesgj5Gw,135 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb,sha256=F8HIxuMvLzdYqNBU1WOhSu9BNb9f8sE2Nh4LScjkCv4,32 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb,sha256=x2uEGj8ly8Au6vONB5db3B2ZHsfzle6lcjWvcBsrm60,32 +onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb,sha256=amAMMN54fzkJ_ZeJCBvf51xwrKnoHs4i0fM0iR16ypY,56 +onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx,sha256=hoZnLZ7StTm1yaZw2TzgB8VpMU9tdOM7SxARij8z1lY,7746 +onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb,sha256=UvIhWzUBbIXBelrU1HHHHr7b9JFAqIGvD3-A8CPr63A,2560015 +onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb,sha256=-1WPY6f7jpGTyYED8nmGHDidFx7eq14NTYKlkmgk1eo,1896974 +onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx,sha256=V_1XB3M_HnRzMi0ZljeB0xj0LIzvIgQcMLk9BOSs6G4,617 +onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb,sha256=RFf6T5yV2ccdEeDEpKOX1Qka6Zw0JT5E3A45ct0zJRc,493 +onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb,sha256=3er0H-Tbr76YIcTT70mwgbc48b9QoMxTJKTJgge5uuM,4333 +onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx,sha256=YLXCr5sIVod9gw7LO0QDJbuW-6wZWOLgripbCUCncKU,95 +onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb,sha256=EN1seuuM_1UBJFjXoz6xlX1FBepf8N0B5m7BTkWM8VU,56 +onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx,sha256=666oqdVmUbi6BFTyna0eHkclropUVJtqv6E8-TqjmtA,120 +onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb,sha256=wUt1WI2-KKlMOggC9wS59vZF8F_ROACdI3s7gmotw_U,104 +onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx,sha256=J1ty6t8ZzwyUhIz8R4zmc60rSqUa0_Jkt-0TWLluKm8,165 +onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb,sha256=hy5YLPPZ35Pu3PoQQVqGsxFpEvOOcTe127tUCiOf-yQ,12 +onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb,sha256=26QXjAPnTsE3QpqJjcP-PkSFVR-8imYTPkQwy9qdEpM,10 +onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx,sha256=RJnaYng4GaBOlE3io3sHHOCxOQHwRI_FJkBvXbZxVoc,119 +onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb,sha256=ofgAi6Cf8rn6vfsF7b8ZilqUiLtsn-griER2UzhkGpg,56 +onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb,sha256=piy6G5PPC3qlXr-0V6zHG0zvgArltR30tPVGS9lVraM,56 +onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx,sha256=p7r_3V7RvgQx3OZFYYHkk20ocZF3KItd1P90Hxh-Fig,160 +onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb,sha256=aa_kAzlLZ3rm3CnRm9P7BhZKM5HFUJAKZWcpJqjTKhY,64012 +onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb,sha256=OguwhkdioYE3ge7me1NGCI81QPh1pYjmx5LdqJ01da4,30732 +onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx,sha256=Prwpo5VZNFPFoDnkSmRDXzMGetPh_WBwE4tA6YyTEy8,119 +onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb,sha256=ofgAi6Cf8rn6vfsF7b8ZilqUiLtsn-griER2UzhkGpg,56 +onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb,sha256=knO2XL2hje6BCvnjC7KMAGC4NNmTsKHdt-92jS9I5cw,56 +onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx,sha256=vVO-SkTN9zcSOzdiDP7A7UxH6NUELPcnvesQ2DcG_bg,214 +onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb,sha256=F8HIxuMvLzdYqNBU1WOhSu9BNb9f8sE2Nh4LScjkCv4,32 +onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb,sha256=wReWT7hu1wvpzVbdy4OQ3RLHmIGleWudjXtNzQxN3z8,56 +onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb,sha256=6plZuSG8XBXIZx869mo4CIt_vk1_YamfsKNeqCCxh7s,40 +onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx,sha256=SFxmoMG1q9-D0Do1Hwdh6GuapE6CF4fUvFFFzL_aVGU,181 +onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb,sha256=K70twgRARvUdaJmFeW6B-5p-XPeOnSI7UHikMCqGo5w,40 +onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb,sha256=g_q2_Vasu0pHakl1XkqeGqZ3mxXiykg-tDWqx8_VQz0,40 +onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx,sha256=gXaZExe5rB9enuGhiokjEQIIa490pEoFFgKxoOEpSqA,159 +onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb,sha256=sPny-rLD9VzG1Qr1U03fcwqyvUHMgTJv1DCMw2uIOEo,44 +onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb,sha256=5J6xbmPIT527VCLp7VgEL6KPIMEKKkrSvtwXOH2WWmo,120 +onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx,sha256=Rhj1CwdUkGkdEadRYZBdl53hs-EvIPiSJVA5mTy04Os,209 +onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb,sha256=noOfxW6AHam2Av3f5rnGXx__oo2mqzch042fpYDSuVI,24 +onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb,sha256=tWqHSLbKRaikVQUxqOSUIYscqNyoXdiiiMdpyYowlHw,24 +onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx,sha256=0KrJH05LAsL-_L77wY67rTYcKl7O4C3YC7oTvPEHrTU,157 +onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb,sha256=L_NDecbs6B53f9DH3kVRb5Jg733mbzz1qLJi6ayQUSM,20 +onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb,sha256=L_NDecbs6B53f9DH3kVRb5Jg733mbzz1qLJi6ayQUSM,20 +onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx,sha256=M7XNkUGAfZ5E2nkFjWW_7SXvK9UHb3JScOaCix8QuyE,143 +onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb,sha256=LQt-jviNzkk-G9vloxDlOGCy8KSCW7U63NTBwgns_D8,108 +onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb,sha256=XEN7AbFAM3Z4_8ItjckmF1DOvmIaQzPHLRWunkBESEM,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx,sha256=O1IEJavHoDIP8kdZY1MemfLfvEabPS21oZ5woHqUWkA,144 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb,sha256=0GRusgT6llp9L4xRar3Wsx135lkRheHdk_yLjqPz6Z4,42 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx,sha256=8acUiZ_yB2CvOmhE2V-LMPvKC35XfS-_B-jKPt7d3vo,148 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb,sha256=JT45FKL7fQp93nScOLNH5XVzpe5_LSd0JERoEk-ZbhQ,44 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx,sha256=bUlOp9MQkbBdQJeZkj1agt-NtW6cKQtTatKD8OU_p98,143 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb,sha256=Utlni28fX3BXWdVXDcuLt0cu_ulgHjp_rgur3_lQyzY,42 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx,sha256=L62_cXaEa-Cykw8LVM7XvGaKRbIdrBK4iamTWxh8OBg,147 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb,sha256=5MvToMGwW6pFTiCLuFJPxxkfYbFAg9-kwFeauYw4Mhc,44 +onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx,sha256=RQJOZuNAEdwW6PlCklxKlGhtZ22mF8kCpou8FAIlWyU,183 +onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb,sha256=-YlOKC1jEG5kWC86OwzjnWKFlazgBGUPbrz4wuOGNZc,2317 +onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx,sha256=mIr4O3Jeff3HjNcLPtRgdNo8sqy3ij_EmRwtk0-_Lik,262 +onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb,sha256=PeeWjZl6s614QawpKlTzaa2M_qDKkuO8BBaz-qfk8ss,16 +onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb,sha256=fcp9lp_a0UFVqmJQjOurs65k3IERx-brNnyQREIxAN8,205 +onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx,sha256=3mqKXDt5KwBID5o11HDtMyoILtWR14_9oPGtONyDuaw,112 +onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb,sha256=O8PmJpISXR22yQA__IfBMa9X11Npm8Gf8PA2ayZiBF8,108 +onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb,sha256=gd_7TvsfK6wzJF1ctWcoUAr7_EAii8eAr1Aw08qArU8,108 +onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx,sha256=c-mj8KfwvSG6yoCZCL1RWVPC4YEsFq9m9H7UQ5_Yec8,96 +onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb,sha256=lE4aKW3dubbAlB4rcDUcltWXIISr4HeAN1LWnjcGlw8,56 +onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb,sha256=p3YSFtZwHoUIHrJqk7eOMcA7za5NaV97uor3259xh6I,56 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx,sha256=TcukI5SQ2YCJEtjb6C-9S1Tpg93BRWVhmUJcLvQGyBk,291 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb,sha256=e1b3DFL0AWrzfrgYCD2Z_tmqUGzqz1XEfvLGynXik8Q,81934 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb,sha256=bqx1z2aK2tKWTHyU3O3EFn--0qeCgqvkwfZkm19C1WQ,81934 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx,sha256=Y5HmWP09sqQ8D87KKCuNzacDAFTXvT9d2qrT1UQqCFs,188 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb,sha256=g4F_BI1dL9Zw7KRNa82h7qrc2ihraPzolEMraSI3Pq4,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb,sha256=RSc1IkqRdFLMBmDEQ7JzmC62gTBmianfJ-_9l05ev3E,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb,sha256=FmQxo2Hd_d2lkwKCgTubHR74fIGqSDeryUre8Zz2XbA,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb,sha256=3d2sF1KRdRHfCmRz_gE6aeW3U3FXdj6a5iJZ16GbqPE,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb,sha256=27DWRsqnvZq9m_3dBy-aOw_WF16XB0wQRmQTg3YFsqc,10 +onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb,sha256=YgmWdPXZb_anXNeasbA2AZ5vpd5tKBADxsOuwSBk6WM,10 +onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx,sha256=XT7TK6OPv6q7O3b3898MF0l2-r7_Y1qFG8C8TCGsM5s,108 +onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb,sha256=26QXjAPnTsE3QpqJjcP-PkSFVR-8imYTPkQwy9qdEpM,10 +onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb,sha256=hy5YLPPZ35Pu3PoQQVqGsxFpEvOOcTe127tUCiOf-yQ,12 +onnx/backend/test/data/real/test_bvlc_alexnet/data.json,sha256=gTz09RnRuoLoForPp-zduDCJNxfXByr-o62-4QpH7QQ,123 +onnx/backend/test/data/real/test_densenet121/data.json,sha256=K_awJig_u8V8iXzzvMGyKUB3tIfu-jv0NmknR4-10Es,121 +onnx/backend/test/data/real/test_inception_v1/data.json,sha256=ZWFpowuWI8N5Yy1aKLNhvNnXzNo5kmhpfandv4IMtiY,123 +onnx/backend/test/data/real/test_inception_v2/data.json,sha256=CyDIFBbTrRTiiuW9LVvLso_HtMLIbenVBR2qazMz6Ww,123 +onnx/backend/test/data/real/test_resnet50/data.json,sha256=4GWkjjl4-uCahU2h7NiwKZt33Expj2Pjk14N9tjuwSE,115 +onnx/backend/test/data/real/test_shufflenet/data.json,sha256=j-qHhpjQOfm6VTRw9joMZet2z1bt-7ziAhGUhtuoXag,119 +onnx/backend/test/data/real/test_squeezenet/data.json,sha256=Wc_Fxf5HPmehmoYP4UNckip3_Kk783zoO7U2xKecNH8,119 +onnx/backend/test/data/real/test_vgg19/data.json,sha256=zazHTUwGDFkcpUPTP95t_XZj5Xjozd40C19otzyuQo4,109 +onnx/backend/test/data/real/test_zfnet512/data.json,sha256=-uRgfrHvF6uF_KdVb01ehe6KexyoTLGZwKKkeJAY6hM,115 +onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx,sha256=RjVogwevJIx-F_NCRrB78u3wz8J43liwi_4VXZ5zT3M,132 +onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb,sha256=-kFoNUTrPOdcUABEXtz8Y0JvTYyaQKDWNoIlhldRde0,29 +onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb,sha256=Ory0VuIbWoxQQlFNuvfHKxsStsXUx98DHtV1L-0l_8E,25 +onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx,sha256=8vMBfHTTsakvEYYAHRix0Rw5UlLLX2YLH_LHIauQ_dI,132 +onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb,sha256=jtEjGRaQMY2aXanx5tzKSV1aQZqCMTz_eAe-NASuXvI,29 +onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb,sha256=Nfr-Y4hHMCx7RZd6zuGthvWOnTqq6B02AeKOTcNUibA,49 +onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx,sha256=i2W7OvivVljkRuYyr7qgTJhoeMJ-DZaYTOYcE5ErhoM,132 +onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb,sha256=90Jk8uu8W-Zk-IKoYDY1M9ynDidapdOgGlDsn-Nhzs0,37 +onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb,sha256=f3h1_JMnmSfaS5ve3NZ68hxYs9q56syzQIrZwBG4Yyc,121 +onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx,sha256=-LCt6hxsHX6zj7BhYIcFVieavb3xJEOVhgysNc7Q_IM,136 +onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb,sha256=FeacT0JWpRN8J4-0SXL6u5IFq8rqpzNiTg5j5-U39oU,25 +onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb,sha256=TzuTXPf2kofUisXxxsPIjs9kGduOx7kUKo0GK6M0c1k,45 +onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb,sha256=-54z-uncN2E4Xp6GCo0JFdJ0Nvjgzlhr812uvk0Yrng,340 +onnx/backend/test/data/simple/test_gradient_of_add/model.onnx,sha256=hqxKd-FKyhCxjveUJXYk7AXEXvZHy0aKG0gf6AzYz78,264 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb,sha256=01kqGBPZb3rDpPA9T56CvZXs2yaYshAUG4N9Dnl25Mw,11 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb,sha256=fA_vLSZfxRw0E8uijMUP0AjksThofW6HfWZmZV2a59Y,11 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb,sha256=MoopEq7YvmlIiWp-ULnZQ7cgYLyeTTxqO1eqVNn9KQg,11 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb,sha256=Yo4qcMojcGk2JZPSRpcKSY_BWkbKcZoRuC-nT5OlCZM,15 +onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb,sha256=1xx1amq9P1-dPK30tNpnEdNn-SduOremceOw8uW8C3k,15 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx,sha256=WNxpfuoymu3Q1SkrssVQABq55ea3GoCcGWxi7aSMHJc,297 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb,sha256=01kqGBPZb3rDpPA9T56CvZXs2yaYshAUG4N9Dnl25Mw,11 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb,sha256=fA_vLSZfxRw0E8uijMUP0AjksThofW6HfWZmZV2a59Y,11 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb,sha256=k_SlcYexZAOt4fP6X2ghd-7chiUMXOoyvCJveI3MTWc,11 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb,sha256=ZIUr0lNQxoOvyIvdFjkKNk_x10J0_El2BKhC1VO5Cqs,15 +onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb,sha256=nXyZvmlusCjPtriTAgchwXnlwHF4hAOFbPqA8wzz1Pk,15 +onnx/backend/test/data/simple/test_sequence_model1/model.onnx,sha256=5xFFoohE76wt8FmPC5aobMCnys9ZAbNtZXwJ1yB1zhk,371 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb,sha256=acWUJJJkjaegHyWZXk1TzmUv7Pj2A6Fj4Kau-LD68wQ,61 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb,sha256=8jc-ymVjyW4wPnnIHhZ5_BKaWy8WOsqrAa_mbJrRnaI,158 +onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb,sha256=7mBt-bM7EukBGQzUvqoyxL934b2LrCkDx_I3-PAaWZY,63 +onnx/backend/test/data/simple/test_sequence_model2/model.onnx,sha256=KZzZBGV-tDv_bkWo2KOjixr8YKbHXS_ornwssdPPpjY,322 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb,sha256=0VfhqZDCxkMww3kF8CHMsdPQ2ae6_3HHrWGfUUUhcxs,111 +onnx/backend/test/data/simple/test_sequence_model3/model.onnx,sha256=J9qvj7WaYXTfJJWbwlaOZq7uCSY1emnWv8Ot4bVzVmg,437 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb,sha256=0VfhqZDCxkMww3kF8CHMsdPQ2ae6_3HHrWGfUUUhcxs,111 +onnx/backend/test/data/simple/test_sequence_model4/model.onnx,sha256=1dZ8RAqL2C4M5qt2anAFL0XkW4q73_krGrOB-vR0IeA,219 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb,sha256=xn5AGPzsNiwU7zvOGMww3GK0K6mjZFeyctuICJDD_jk,304 +onnx/backend/test/data/simple/test_sequence_model5/model.onnx,sha256=1YqWf-J8logBWGMQl9wYHslyJeozA19o3ULV3gFrIeU,251 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb,sha256=QYuDQFaYJk_vZOlJvOrFihGNRwYhQIvxW59i_dDFavA,109 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb,sha256=6yIT4GU0ai5jfrrMWxDYlnRCzdydqQHvj9AmzXn0aqg,109 +onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb,sha256=M0bT0Bi-MmK76q7g_NGHZBGtBqCIRkOEHbZwQxOMS4M,306 +onnx/backend/test/data/simple/test_sequence_model6/model.onnx,sha256=JANoYkvy3KHwu0OQp7_JOebk2uyywXnF1kOhAh8v-A8,156 +onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb,sha256=HBHYia7bIMIEe4U5fWCsXOb5Tf7kriOjoNOib0tkUpo,109 +onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb,sha256=WQhbsdsmsmPRHbpqfZ2MiS0DAKfdf-5atRiJ3PQSa8I,17 +onnx/backend/test/data/simple/test_sequence_model7/model.onnx,sha256=8W0ICmPH4I-RbyPg1sUAqS8g80VjI3b1w6KwX8LSthI,209 +onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb,sha256=iDb2BEF6r1s_Ivm2lami2Cd5mumrAH-iCufdqTWZtVg,206 +onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb,sha256=hRDk49zUKK-zx6kVhCyPbUW8GAbH2oHne4UBEZ-abPk,109 +onnx/backend/test/data/simple/test_sequence_model8/model.onnx,sha256=uRG-4PlDM24-SF0xEMigmVnRe_eTopTh5iPwAmRJngA,157 +onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb,sha256=MnclcMUBN86XdRdCIhDbiw8iXBNVY9m2zmyFUnlMLM8,9 +onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb,sha256=7EJgBev8JC7V0Rw_gwYv6p__Wn6ntHoisPgOXmLl680,38 +onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb,sha256=XQxLMlrcsgBaXyWLm5m5QW1Ph1e1xB8VoLsTnp-G9TI,17 +onnx/backend/test/data/simple/test_shrink/model.onnx,sha256=w20edVDLuFYRyg_mTFTeX28fDIvf5Eu2DkfmX0nVGzA,115 +onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb,sha256=b6eG0JoSaNfFZ9uN6DHuVlebG4hyn5rm9o2xzU2w0-Y,29 +onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb,sha256=AbQplXJ5FVu2LaNzGC0t3G9EZhZUCsd-_fnyXRD9T2I,29 +onnx/backend/test/data/simple/test_sign_model/model.onnx,sha256=x-DuU3N-mIY90B4uRxuhogKFVZq8nHXxJrFs5i-fDKQ,90 +onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb,sha256=OYoPx6Ht6FXdfpszUznfOHcHY34rscU83vgklJlGV_A,37 +onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb,sha256=CeKwUlQI9tHyyzENPyq43v-DgnaQhzqRFwnITipA7SY,37 +onnx/backend/test/data/simple/test_single_relu_model/model.onnx,sha256=81t2jgdqDN2px9zzoPPsu4STlrL3Ff1ELHcFx9H7Rzs,98 +onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb,sha256=z3PIwDv5elbsTylVjEIm6kzqZADwyn7wXFOKazkGPDo,19 +onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb,sha256=o_KNVxD7Z64gu7M_8ZB2SD7cbjBQg7ZcTid0oZk_lcA,19 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx,sha256=YEJ4VUhWCA58OTuF7rc5CYazSwyDvm_hdNZhSJRSOsE,185 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx,sha256=chr1nCThp6Y4V52zC2WrTWUJ0GZJIJKCOJQTB6qruiA,153 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb,sha256=_-mGRZ7G9I9iAx2P9lMk3aHUawP2XKjO9hn2fpR6tpY,37 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx,sha256=mTkMdQL9kKyFg-wXrRGcGZjp_JkEwLZB-Wv4bTteV2Y,185 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb,sha256=esXLitVtK2jXZ1_Lr-WQo0JzyzURptvL5Nk19vQXSr8,45 +onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb,sha256=7Zk-IeCaqHCfs5Z1zqHp5ERKMABu8eMRVVYNTMLdFc4,37 +onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx,sha256=7rQjPSYfgK49i9NXSP1wZbZjsKKaHQcuyaZXlfxblJA,185 +onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb,sha256=XGok6pzumeWYmW61YcE2gO49FZP4HhO5L7VQiaofooQ,23 +onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb,sha256=fve41mqTI11I7kUof7Bey6Rtk7Sv23j8xV9xaJLPzQ0,9 +onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx,sha256=oA_EVTNecnOU1ep5n9OYERU5iqhaEXY7JhmSQE6ycDs,167 +onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb,sha256=5_crR6dG0l6PE3Zf0m0C1WePv2dsKuUUSeSBHD4-fx8,65 +onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb,sha256=etP-R5bCcemRt-RrzQK7MPjXOQwqbEBeZCcYma1Jb7M,49 +onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx,sha256=bVmnHtYfTVDT2Dvx84KyrtEWEatTU3SfnlPGXDSGhGw,128 +onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb,sha256=uBHq4M-aleAVs_ZnyQty-Yz85ya7wK6Dp7RjXk0bUZw,24 +onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb,sha256=NhjGWjPVxmkR0f35ghfx6YQm3Is2Eue9LWCC-NaQqQY,24 +onnx/backend/test/loader/__init__.py,sha256=60y9Fm-H2ydMEAB_FYsp5laLLDjX9V7He_3sEYfBg14,1869 +onnx/backend/test/loader/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/report/__init__.py,sha256=Ua3s3YmvUusUnffIyct0GnwIqFcMP_AsV5aIe1A4rLs,1261 +onnx/backend/test/report/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/report/__pycache__/base.cpython-39.pyc,, +onnx/backend/test/report/__pycache__/coverage.cpython-39.pyc,, +onnx/backend/test/report/base.py,sha256=npe6vog194R-rbyVje3cIUerSkLoFzDaq5xexAGqbDk,119 +onnx/backend/test/report/coverage.py,sha256=vorh5oeahN-pJ5AtJv8Dy8ELqPkXYNP5Tf8Al74LuyE,11279 +onnx/backend/test/runner/__init__.py,sha256=AQ6GjGtnpzu4E_6BPlteda2hglIm6H6TAonc-M6lG_8,20102 +onnx/backend/test/runner/__pycache__/__init__.cpython-39.pyc,, +onnx/backend/test/runner/__pycache__/item.cpython-39.pyc,, +onnx/backend/test/runner/item.py,sha256=PEJjl6K3Z-bga8IMHN3alKcweygjAMzZhSa1ChKF6C8,429 +onnx/backend/test/stat_coverage.py,sha256=66c96IztGeLDfGbCH4Gzf7hvAqhgCjpRZXIpVFDtwZg,11758 +onnx/bin/__init__.py,sha256=HiuD-U6YHJwWikkemKJqBq-35U8KJ9LDdAwdisi7OlQ,85 +onnx/bin/__pycache__/__init__.cpython-39.pyc,, +onnx/bin/__pycache__/checker.cpython-39.pyc,, +onnx/bin/checker.py,sha256=h4tAK3SaViHUdt8nBpookLAqVNSgIHhn2jL_GeHM7m0,684 +onnx/checker.cc,sha256=XKelEv-aUcTMUdvXtqnbhOBLvy7PbIzeR2mKYyIjyDA,39857 +onnx/checker.h,sha256=1LpyxDCShpr0gJn-SBCw1ZJSa2JO-uY8c-n2CXU3C60,5483 +onnx/checker.py,sha256=o3oMpytMLp6ks7hrOZPMv-6nYd2ZVEGVXIY0IihFTHk,4296 +onnx/common/array_ref.h,sha256=xKutW9caNcjbG1fFELgqMSR1v15K74nLCoowjgYuluo,5849 +onnx/common/assertions.cc,sha256=x7BNDrBnDfelXzM6SFtk2UhiLHKnYvivLt1-v5Qg4mo,972 +onnx/common/assertions.h,sha256=CbNWCOu-dHXeHXSyAPIKyZUSUfw73RPy8SYmBqvsq58,3114 +onnx/common/common.h,sha256=fiOGowyN8T1axZd2-4TkXjW-cYN6Id3-zWZFCNU2eqQ,1018 +onnx/common/constants.h,sha256=P8ck-EFN4FzZFsf4CI43aSCx_jGOK0a1K5lDfNO05f0,1152 +onnx/common/file_utils.h,sha256=JZYTnq-DAOThLXR1GMaGz1WrEYINkslkpYvPWxsL6dQ,870 +onnx/common/graph_node_list.h,sha256=UcjP2oIutYfyXGmX_mFXb_hnCb8BDyNfyvbMINsonec,5570 +onnx/common/interned_strings.cc,sha256=118StiVeP-fg4Ww_ozWXhkJfv-aVSUAwWDjWU43OPn0,2108 +onnx/common/interned_strings.h,sha256=M4mER2KdHibNimj3P6pfmON4bm9TnIbeLfJ-l3C2Q0k,8321 +onnx/common/ir.h,sha256=TforjSAq5aAXQ4H-ZqjvliuNF4pR4qKSX7ay5NgKjXE,44095 +onnx/common/ir_pb_converter.cc,sha256=4D0GV7yKiyciaOFEo--wMUWs22o3S0sOH-uN-tzQdUg,24849 +onnx/common/ir_pb_converter.h,sha256=Fmpl9Z0EvcGLDuTfg5uq0olLWPKS8YbIxArXS2fYhzk,1316 +onnx/common/model_helpers.cc,sha256=4xqgRAWp6b5LFG_vykOWTd2s9Vclm8T1oV7EUc4_PF4,987 +onnx/common/model_helpers.h,sha256=ImJ1NRzJWa12om8rM3EJA6FeF8bmuNdajYQlqGoaZ60,669 +onnx/common/path.cc,sha256=uPJBMR4KFfC0CZWhkdCXGaqEEZ2Mo5x0VqJ4IDvaoZA,1796 +onnx/common/path.h,sha256=3ouzTnw3liyaF79RZqIGZqqisrngocdrVnhnj6cvoVg,1481 +onnx/common/platform_helpers.h,sha256=H3UvCS4bM9Zkw_KyzIfhdN-IfdyGmtMsF00lywj9pxw,355 +onnx/common/status.cc,sha256=LzAeVUK5TtcS6jYWzHMKFsRHiG6lno4fzcFZf-auzUo,1977 +onnx/common/status.h,sha256=z_EANpdWSItQ_3TYWJx8ooeCH6ErqXuOJSHa8MUr0gQ,1988 +onnx/common/stl_backports.h,sha256=n3H4xJCT_yaZ7qTDv5db5MSnHO6u3Y7pN6Cvqwhv7oE,1852 +onnx/common/tensor.h,sha256=CU25OnYGfsafVzoU_OyHhuAmXFb_xYz1UH80ucrn0Ek,7639 +onnx/common/version.h,sha256=WErb-MuDByR1ajfNdnp6XfX3ElFBYm4g5WmbpKTRW8Y,308 +onnx/compose.py,sha256=YvxDPvgKJ_vI3EuWtGYw-ijMBWWVdAEa2s4l415qD5g,27091 +onnx/cpp2py_export.cc,sha256=gaTEpeFlnbmMHsQbtqpEwSR6QvQhfS-K_-RleI_soZA,28865 +onnx/defs/__init__.py,sha256=0j-yQa5VQarcANEy8_54vp943fIanHqDF7Ifn4JdfRo,1559 +onnx/defs/__pycache__/__init__.cpython-39.pyc,, +onnx/defs/__pycache__/gen_doc.cpython-39.pyc,, +onnx/defs/__pycache__/gen_shape_inference_information.cpython-39.pyc,, +onnx/defs/attr_proto_util.cc,sha256=0TvGjJi6SWeAdXz1MyRZ9rD8hokAlevWX3_xDnUiWCw,3618 +onnx/defs/attr_proto_util.h,sha256=Je5NjjP9yq9cLEPowBxjvU1ujWvc0nvQ9jhEK0UyKtk,1903 +onnx/defs/controlflow/defs.cc,sha256=Cg8dZd6Zxdy11gVopJbcn39OXpYzQ9lp35WzKkaCHRU,20663 +onnx/defs/controlflow/old.cc,sha256=Rab_qVPh9oPoNMtCumRtGC7-RUUQRpK0Z0NUkC5kCr0,108643 +onnx/defs/controlflow/utils.cc,sha256=Dj2grkWv9FTn_FvvGOgSShG6gk73zlmHlyKHCzSnujU,13827 +onnx/defs/controlflow/utils.h,sha256=hKi0ykWyv002RfV8mFqdBMWtjDX9Yh3HlLcjqr22RoI,449 +onnx/defs/data_propagators.h,sha256=S5u7SPxvuxkZ876_09kh4R55CbOtokLa6ZmcXv2kgPE,2399 +onnx/defs/data_type_utils.cc,sha256=daLojGk4s6-Eo5U0kHBr7-qo5hoPFdGgrvlKdjKG1TY,14404 +onnx/defs/data_type_utils.h,sha256=3cdfGae4jU5TzFjgDBQeTXJz6MH4Y6jHU9owc9TfVGo,2527 +onnx/defs/function.cc,sha256=2UYibvZLDEiteZHqqRed0Y7GYfshkNE2sAtTmwDvXmg,5696 +onnx/defs/function.h,sha256=GC56kA2CHhsRB2zY_XgXBJaLUoIZH_EBqL6UxYhsG6k,6271 +onnx/defs/gen_doc.py,sha256=4e-I-KVaWeVEoRZT7f07Yc3PhrLygPl42txQjCiFC70,16697 +onnx/defs/gen_shape_inference_information.py,sha256=iRXGJKziAu_Rrwd7emFMyWaU0PrPz9f3SJc7JhDzF9o,870 +onnx/defs/generator/defs.cc,sha256=e9_dQR-BVXvt9lLgj9y_xwdjmXLh9QHnKrhtV3UDESo,32574 +onnx/defs/generator/old.cc,sha256=whEYb_6peUSYuKjeR21AUIneEiLEQsPYs0232QkIbqk,18307 +onnx/defs/logical/defs.cc,sha256=Tbj__KPHpdhBAk2cPAhPHdJtPrWvlGkCifJtgnGGmFc,12166 +onnx/defs/logical/old.cc,sha256=3mcunnOuj4d2RAG-bjRwqJU8Eeg1qGE9OFLFOeicHUY,10334 +onnx/defs/math/defs.cc,sha256=phSgOEUt1uNCkSaUQiIDBdTrkm3IE_Y6p72uM9KphL0,141097 +onnx/defs/math/old.cc,sha256=MGD47msIgPq6yrfVEQvM4-5G1q7IjmIqLPSKwbNsGqI,123100 +onnx/defs/math/utils.cc,sha256=x_thhosN6pfMq7uFQb6xTxIPF3SAox18K4evgUZ_vmE,2548 +onnx/defs/math/utils.h,sha256=0zIBQPsTvdorXWGbneKDGA0S3lnJO_BYMztKI-bi3Do,284 +onnx/defs/nn/defs.cc,sha256=ICaJ0yhLITpE38TQmV5ECsM2FHvPSSFiQtFBSTPn-4I,128786 +onnx/defs/nn/old.cc,sha256=DInJUK8f1E35J8lZsst0Q1OqwwGmj7Cwp17Yoz0IUu8,101172 +onnx/defs/object_detection/defs.cc,sha256=NFx0lp7MeLvz6xLIPUZGcnp8YJ0f7ZcxSJPlLU_uLN4,9521 +onnx/defs/object_detection/old.cc,sha256=LymW809vY8V3iPTuWE9gxw1jZnS_yBfQEg9Gqn9dORI,8331 +onnx/defs/operator_sets.h,sha256=FkvcjpgxIBRKrk8o3HVMEnAjw1c4UJ93UmToASORc2A,72735 +onnx/defs/operator_sets_ml.h,sha256=c-1YSzDKZVvpUcY1l4lrkV0F4BfSkdqa1s_unoGcXXo,4158 +onnx/defs/operator_sets_preview.h,sha256=Gc9l-kttvpW1B7X3YburU91E52vgUFJiAINZCigspNY,1273 +onnx/defs/operator_sets_training.h,sha256=l_dkwNQpwzQ7VyXOrmgE6O5oSWRSoEhwn0YT2ToAiXI,518 +onnx/defs/optional/defs.cc,sha256=-84f_WpTqyJlRZs3a8aGSMJ_ugII4xdF_khMJzCg0HM,6670 +onnx/defs/optional/old.cc,sha256=48xOHR6HCTm4OH4zqpsH0phDET16ao2uxCKwLMkGb-8,3499 +onnx/defs/parser.cc,sha256=b_yMEvGC0cG36HzXH2Vd1oZG_JfBrNTNyvuu4U9BW-4,21609 +onnx/defs/parser.h,sha256=H0AFTk-8aN1HrEZaWR40esm97CIXs-jKJWDMi0Qg3qU,12815 +onnx/defs/printer.cc,sha256=gUgPdgIhwujaItecL3sxLVOsB4sPQIz1H0TDh7ljKyg,13086 +onnx/defs/printer.h,sha256=hYrZ0RLxUrIstuTiPBQ5NFk3Bc3kARBweyeQ_AjU4_Y,1418 +onnx/defs/quantization/defs.cc,sha256=UNaupumMzUE4UzCFjONbKouHvG9hhDCsQQxgoBytRTE,10249 +onnx/defs/quantization/old.cc,sha256=k4n9acGfkuwqSkSXtCYOBK5V8S5BVCId77O_mlEdhEU,9192 +onnx/defs/reduction/defs.cc,sha256=LOFU8if4-wVq9McFY3TxgKONJGeCtxRTAQG68JEcsrU,6491 +onnx/defs/reduction/old.cc,sha256=aDqA2QNB-sFLoF1z40BD373v86ql3vFnO2uMDGhs24g,18795 +onnx/defs/reduction/utils.cc,sha256=5yDj4vQdjTPOFjGA32s8seWHZcLzSWwvz9S8hbatLQQ,5941 +onnx/defs/reduction/utils.h,sha256=EGV95K8H2mJeX_5w3WzJgg-YFvx_HLhwk5nwZs5DwoE,488 +onnx/defs/rnn/defs.cc,sha256=oHWuTnER8fXzvcmd1zf61oXDIZaNo7je6wy_sqfnOFI,20092 +onnx/defs/rnn/old.cc,sha256=HnFsXxbQIzmRR965HRB2X5vQVjpOWHNEPkpmcKkJiY0,40210 +onnx/defs/schema.cc,sha256=3-MDooLN_2DOlO4KB7cMUUUP6DANyXl07Gg3LiNMsjs,44980 +onnx/defs/schema.h,sha256=bLh2fmI54eq-sOgCajtV9VIF0Yws-ubDeJZrHoUQ2es,57340 +onnx/defs/sequence/defs.cc,sha256=GEvu9WSeLnLdGaKKUWjkre3wNHOire-TBsVc430c2jA,34822 +onnx/defs/shape_inference.cc,sha256=cXNSoCEYmh-827FNZnF0gspjMUiGDsrFOLVIxnR5ngE,20679 +onnx/defs/shape_inference.h,sha256=0er0J55oZAII_Tk70z-JYol-zf8opjCEJqNZd_ewMxM,34221 +onnx/defs/tensor/defs.cc,sha256=13fDJaNeTLbi0zRfJm0lhoE-AZ2g7rZ3jMlmctWaxJY,153173 +onnx/defs/tensor/old.cc,sha256=ZuT--QIQnKSMnJtv8fI1x1Jk6cVhvWIsg_am-UIW7J4,226536 +onnx/defs/tensor/utils.cc,sha256=GRMucL09m-4qqE9TNrpoOX3UUqCFGPIO-33jVnKNo1E,17140 +onnx/defs/tensor/utils.h,sha256=kJTe1cLJ0tFTo_m3XRFYzpEtwfOk5v9j6DyIxdAqZYY,1582 +onnx/defs/tensor_proto_util.cc,sha256=AjoTFrgWRiiLnG8VGRUIpKfNr3_eNImmhaWH1mzhZq0,11902 +onnx/defs/tensor_proto_util.h,sha256=AJk0l1_zHmPBZV0kp5GzoRD0haH3OiPQD3fWGROb2SM,400 +onnx/defs/tensor_util.cc,sha256=4n30UVgslw45-Hw6oFa-ZTlNHAp51ESN6nljcKc1zcc,3433 +onnx/defs/tensor_util.h,sha256=VZMm5A28gKp2VGWj0FHT5tmC2Y9Q3f79RWyicJ0g1VM,239 +onnx/defs/traditionalml/defs.cc,sha256=iUE0rTMsh8fG1vJzL2jK-g3AYxQRbocTyL5rwLq30gg,55671 +onnx/defs/traditionalml/old.cc,sha256=sQaZC1kXfqYGDyM12Xh7U5eTkU9jCWQhv5l7sqUm4rc,12188 +onnx/defs/training/defs.cc,sha256=ZDZ1WXuIteTaUQCjAZwTEyLGCxLqx-8aHTYDc-Cs-Ok,28507 +onnx/examples/Protobufs.ipynb,sha256=0vXONqk9KHdtfL6KCx7M4AsSRsfTvb3ph1_6bIGTw8M,17145 +onnx/examples/check_model.ipynb,sha256=CJYoNKdNWhhDS2UgV8sF7xj2-rgHThcq5eXnWs1cc9Y,3181 +onnx/examples/load_model.ipynb,sha256=59wi1FCDc1FvWAuTNAyvc-4P11nGBWRNzfJVuUC3L7I,2760 +onnx/examples/make_model.ipynb,sha256=ZvrmkD75KHH45APIBzxe5KiKbLB_6o2oZtZ8xARya-4,4779 +onnx/examples/np_array_tensorproto.ipynb,sha256=UrQ1TtKNi-othxDDv0lnnUXkZiuANvI9E0L6RnKXrJI,3551 +onnx/examples/resources/single_relu.onnx,sha256=neaOn0TxnNKKVpwmU-NGkqs-ymFIvIhShJsNDXYH1-Y,96 +onnx/examples/resources/single_relu_new.onnx,sha256=neaOn0TxnNKKVpwmU-NGkqs-ymFIvIhShJsNDXYH1-Y,96 +onnx/examples/resources/tensor.pb,sha256=0vnUFSss9h9blzSL_DfsH_wcCpCJhI7P4qAhNNbZZG8,56 +onnx/examples/resources/two_transposes.onnx,sha256=Bu8bW3Dr-Wy1sMJbDQvObVxG8ZjSpTdEVY7ddov5V2w,162 +onnx/examples/save_model.ipynb,sha256=6v-R0scU5-0kQ3goHu-C_XM2_ZT-85Gr8oPq72k_OOM,1245 +onnx/examples/shape_inference.ipynb,sha256=bwcC-aJyS4Xw8MII22tSQ7SlSGDl01xMLHsDpqd_q2E,2931 +onnx/external_data_helper.py,sha256=R1YkqV9F9k3D2qQLhvvZcg-KXX2fY8-HLEUZa2WUEFk,11828 +onnx/frontend/__init__.py,sha256=HiuD-U6YHJwWikkemKJqBq-35U8KJ9LDdAwdisi7OlQ,85 +onnx/frontend/__pycache__/__init__.cpython-39.pyc,, +onnx/gen_proto.py,sha256=yjD-uRzrRurVuEmHtZ3jfNTouuUOGhHbCFG6i5XL2uk,8876 +onnx/helper.py,sha256=23eLCQjo7iH1t2vDUecIJ_CJTzn9SaIdH-iPwLEHZ80,50514 +onnx/hub.py,sha256=qr1LEZcPBqKuIFIThHa0ALJcgJridM5f5EjgCsQGj9U,17810 +onnx/mapping.py,sha256=cyi6ysjNP4U0OIcirQb6YJ-mBbtYsejRbasBDfSuSPE,8086 +onnx/numpy_helper.py,sha256=oe7iezcOMMNiUgPwBbcm3ugU_e0E1_wKQ2DHTxQHSCg,21990 +onnx/onnx-data.in.proto,sha256=STpWDwjabT1X2CjbIIMYVzmKWLwNInoYMI6MsDnJPsc,5251 +onnx/onnx-data.proto,sha256=mZGa9_OSSCfR8u8d7KD1vpX6MmCA4lV9a-oqcL2njUQ,5337 +onnx/onnx-data_pb.h,sha256=NueEKiWvYvrBCihvlr7FOwAFxPyUQUOsTALHctAmqNk,167 +onnx/onnx-ml.proto,sha256=lDIB5RkPONM0GN79SmfNrQypka7H0IT3g9PP2gOmWYw,36817 +onnx/onnx-operators-ml.proto,sha256=B6G5p_TJFmnAc-82clXeo3zHZH4RtAaXKkaK4htKWUA,5439 +onnx/onnx-operators.in.proto,sha256=gbHdotozdGsY3fI40d8FNpXV68Nz4pCO4h1WeWX2gEc,5353 +onnx/onnx-operators.proto,sha256=JQbdYTnvJhfQrFk82zzzEKpokcOUujZ4QBKqvSJNBLU,5436 +onnx/onnx-operators_pb.h,sha256=vlw2jzH5sZfKNzs6x4f34-riKuXPy9PjXbo8ZvOx068,202 +onnx/onnx.in.proto,sha256=YGhWXc7eJbzj42A8f4d-oA7O3124s2WPPzaX4Q0x8oE,36748 +onnx/onnx.proto,sha256=8JWKFuM8tMbfX5b7c5cwYstPnk04Zg2uumYErzhIUCc,36338 +onnx/onnx_cpp2py_export.cp39-win_amd64.pyd,sha256=e_njLXU2LT56X60BVYN038dnALqu5Tw7e59c6UXlCmQ,2516480 +onnx/onnx_data_pb.py,sha256=Czjgcf0pv2Vk_mBsch2sG4bYkzRpNG1efzhhdEilN8I,94 +onnx/onnx_data_pb2.py,sha256=YuJmAGmOGE_ClfmD9Gbbc1qn9_FzOMDH61e7ay9t5xw,2894 +onnx/onnx_data_pb2.pyi,sha256=VTSip9Evt2RqdKpntIo6G9LVASJVfc6zJ-yy-T4kW_o,4682 +onnx/onnx_ml_pb2.py,sha256=LyTllqN8E-VIIiI55EAiwS8IZHtnnAK_9zn9fSRJVFY,11930 +onnx/onnx_ml_pb2.pyi,sha256=jSJZuiVDdEcwJ5D-2eesXy-wChUSns2lE-CiB4RR500,22461 +onnx/onnx_operators_ml_pb2.py,sha256=zUUf3B_H9GJfeZT1HwEH3UXHzWslztq2KZlk4kPylLQ,1797 +onnx/onnx_operators_ml_pb2.pyi,sha256=c5e2qnUu2bw3QH1wH3d1eMTjbhGEk5U1kWzFJvtJ7TA,2188 +onnx/onnx_operators_pb.py,sha256=N5fEPo3jXHFuJNbzTBpJHa_T83-11btCP0H9ArOT5VM,102 +onnx/onnx_pb.h,sha256=aZFGVarVX9rxiPUDO0hMzUiElfrh156hXW2IAKws6eQ,1771 +onnx/onnx_pb.py,sha256=4gbKZBELN10Wshbbg5OWsC2RSgZJn4IJiAz5XX4Hqcs,92 +onnx/parser.py,sha256=8cbbtnTgYkrOH-4YTQpE5x1MqoMtL8Zy1jUcgvVQbfE,1929 +onnx/printer.py,sha256=wOX0eB5wT5ZeQIh4j74SHmoRIewyiz81rKqO7VvqQM8,646 +onnx/proto_utils.h,sha256=j1wwJejkaerAlF0E_H-yif4-pWCIJwu4iY7dqZbpeN8,2239 +onnx/py.typed,sha256=9UMKvtXY_BzLXM9JXn_eKOwmwSH_rAJMvoGJfxOW7g0,42 +onnx/py_utils.h,sha256=dF_ORW0rN9QaWj1wWpfHkPwcV_o7mpH9vOnWI_bcOvs,566 +onnx/reference/__init__.py,sha256=PWJ5F1FuCJyMTieREILfweaDvtRv717qlVYyStOTl7I,154 +onnx/reference/__pycache__/__init__.cpython-39.pyc,, +onnx/reference/__pycache__/custom_element_types.cpython-39.pyc,, +onnx/reference/__pycache__/op_run.cpython-39.pyc,, +onnx/reference/__pycache__/reference_evaluator.cpython-39.pyc,, +onnx/reference/custom_element_types.py,sha256=n79c-qtXWuSX170g084-N5vBLki2CFTjkd_4d9BM_rE,433 +onnx/reference/op_run.py,sha256=yZvExM1b8citG15rX3-7SKqXxjVk7_B7RJGdVu1N-6s,23906 +onnx/reference/ops/__init__.py,sha256=N0lZ39DhOhaf2XWnit3DV3YM3ed_E90qXx8EhKMD_eo,181 +onnx/reference/ops/__pycache__/__init__.cpython-39.pyc,, +onnx/reference/ops/__pycache__/_helpers.cpython-39.pyc,, +onnx/reference/ops/__pycache__/_op.cpython-39.pyc,, +onnx/reference/ops/__pycache__/_op_common_indices.cpython-39.pyc,, +onnx/reference/ops/__pycache__/_op_common_pool.cpython-39.pyc,, +onnx/reference/ops/__pycache__/_op_common_random.cpython-39.pyc,, +onnx/reference/ops/__pycache__/_op_common_window.cpython-39.pyc,, +onnx/reference/ops/__pycache__/_op_list.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_abs.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_acos.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_acosh.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_add.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_and.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_argmax.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_argmin.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_asin.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_asinh.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_atan.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_atanh.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_attribute_has_value.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_average_pool.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_batch_normalization.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_bernoulli.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_bitshift.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_bitwise_and.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_bitwise_not.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_bitwise_or.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_bitwise_xor.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_blackman_window.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_cast.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_cast_like.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_ceil.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_celu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_center_crop_pad.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_clip.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_col2im.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_compress.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_concat.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_concat_from_sequence.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_constant.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_constant_of_shape.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_conv.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_conv_integer.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_conv_transpose.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_cos.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_cosh.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_cum_sum.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_deform_conv.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_depth_to_space.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_dequantize_linear.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_det.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_dft.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_div.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_dropout.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_dynamic_quantize_linear.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_einsum.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_elu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_equal.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_erf.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_exp.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_expand.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_eyelike.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_flatten.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_floor.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_gather.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_gather_elements.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_gathernd.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_gemm.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_global_average_pool.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_global_max_pool.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_greater.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_greater_or_equal.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_grid_sample.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_gru.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_hamming_window.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_hann_window.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_hard_sigmoid.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_hardmax.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_identity.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_if.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_instance_normalization.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_isinf.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_isnan.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_layer_normalization.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_leaky_relu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_less.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_less_or_equal.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_log.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_log_softmax.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_loop.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_lp_normalization.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_lp_pool.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_lrn.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_lstm.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_matmul.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_matmul_integer.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_max.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_max_pool.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_max_unpool.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_mean.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_mel_weight_matrix.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_min.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_mod.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_mul.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_neg.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_negative_log_likelihood_loss.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_non_max_suppression.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_non_zero.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_not.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_one_hot.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_optional.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_optional_get_element.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_optional_has_element.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_or.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_pad.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_pow.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_prelu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_qlinear_conv.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_qlinear_matmul.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_quantize_linear.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_random_normal.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_random_normal_like.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_random_uniform.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_random_uniform_like.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_range.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reciprocal.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_l1.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_l2.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_log_sum.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_log_sum_exp.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_max.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_mean.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_min.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_prod.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_sum.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reduce_sum_square.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_relu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reshape.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_resize.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_reverse_sequence.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_rnn.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_roi_align.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_round.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_scan.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_scatter_elements.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_scatternd.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_selu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sequence_at.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sequence_construct.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sequence_empty.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sequence_erase.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sequence_insert.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sequence_length.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sequence_map.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_shape.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_shrink.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sigmoid.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sign.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sin.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sinh.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_size.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_slice.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_softmax.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_softmax_cross_entropy_loss.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_softplus.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_softsign.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_space_to_depth.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_split.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_split_to_sequence.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sqrt.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_squeeze.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_stft.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_string_normalizer.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sub.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_sum.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_tan.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_tanh.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_tfidf_vectorizer.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_thresholded_relu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_tile.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_topk.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_transpose.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_trilu.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_unique.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_unsqueeze.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_upsample.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_where.cpython-39.pyc,, +onnx/reference/ops/__pycache__/op_xor.cpython-39.pyc,, +onnx/reference/ops/_helpers.py,sha256=cm_0eO78YHqGNQ9eSAZFaQ5okX8tBwH5z6T7dDh16ho,1932 +onnx/reference/ops/_op.py,sha256=Gy3TcGqeKmUmL12Ps7aPLnSzyUr7Jr1-tN-maJafEQ0,6726 +onnx/reference/ops/_op_common_indices.py,sha256=3HOqDAE7Yv-wneBnPlPERy3Br-SKh1tcc9wSwORE1bk,794 +onnx/reference/ops/_op_common_pool.py,sha256=BWf3sExqbS0f1hxwguL7gV3rND5unjqxSjKY4TPLsfY,10917 +onnx/reference/ops/_op_common_random.py,sha256=dKTUbLygFIyVjEeqm7H3IxYRD3Io_XWy4P-NIkoc_vw,1958 +onnx/reference/ops/_op_common_window.py,sha256=F7HbetbBw4bepiVoMnp6wngXdeUq8HvkauZwCCTafoI,744 +onnx/reference/ops/_op_list.py,sha256=8XaUWREmA1coFWnPaVS3uSTHf4Ib30p-5uM7oZ2VfBY,16772 +onnx/reference/ops/aionnx_preview_training/__init__.py,sha256=Vv1EvRHyahq2Ek321j_33sykP0zOPQC60ppauA78t68,246 +onnx/reference/ops/aionnx_preview_training/__pycache__/__init__.cpython-39.pyc,, +onnx/reference/ops/aionnx_preview_training/__pycache__/_op_list.cpython-39.pyc,, +onnx/reference/ops/aionnx_preview_training/__pycache__/_op_run_training.cpython-39.pyc,, +onnx/reference/ops/aionnx_preview_training/__pycache__/op_adagrad.cpython-39.pyc,, +onnx/reference/ops/aionnx_preview_training/__pycache__/op_adam.cpython-39.pyc,, +onnx/reference/ops/aionnx_preview_training/__pycache__/op_momentum.cpython-39.pyc,, +onnx/reference/ops/aionnx_preview_training/_op_list.py,sha256=JnRpcMW5ffA8MLDTo5o_2Yc_A1czZ-DqVzehKXVOOqE,3217 +onnx/reference/ops/aionnx_preview_training/_op_run_training.py,sha256=ZLVZPe3LTBURARBgi-SUH7117hZkIrMWYPPlnZL9kHA,235 +onnx/reference/ops/aionnx_preview_training/op_adagrad.py,sha256=QdXph3CzEFbaFUJ_MLoPG1OQypMzdDRdx3s-gc_hFL8,1935 +onnx/reference/ops/aionnx_preview_training/op_adam.py,sha256=R0OdeKqA21t5aGevJpjaSb_kpa2uKFOspHNB0YTMh7A,3068 +onnx/reference/ops/aionnx_preview_training/op_momentum.py,sha256=Obg36Vq7vHcmmWl7RzRDo7tBpcW_kLRxT2VfIbHzBc4,2551 +onnx/reference/ops/aionnxml/__init__.py,sha256=Krif8jwGG9xxjLsi61ITcTYghzNiRuOcOKbvh5CZnic,99 +onnx/reference/ops/aionnxml/__pycache__/__init__.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/_common_classifier.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/_op_list.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/_op_run_aionnxml.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_array_feature_extractor.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_binarizer.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_dict_vectorizer.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_feature_vectorizer.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_imputer.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_label_encoder.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_linear_classifier.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_linear_regressor.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_normalizer.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_one_hot_encoder.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_scaler.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_svm_classifier.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_svm_helper.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_svm_regressor.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_tree_ensemble_classifier.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_tree_ensemble_helper.cpython-39.pyc,, +onnx/reference/ops/aionnxml/__pycache__/op_tree_ensemble_regressor.cpython-39.pyc,, +onnx/reference/ops/aionnxml/_common_classifier.py,sha256=yeO-QrrN4cgPjbN5b2mKjvPoeLwvgU86op2fTXc94sI,2080 +onnx/reference/ops/aionnxml/_op_list.py,sha256=ZnLhMiax_4jEg_xg3gTwEE0hMzoxcpsh2Y7hUvj8wGI,4271 +onnx/reference/ops/aionnxml/_op_run_aionnxml.py,sha256=jlBy0sGLy4pK1FrqkPF7I_-NIUto0X7Ua_FF5zmg-YM,176 +onnx/reference/ops/aionnxml/op_array_feature_extractor.py,sha256=RX0Lblen8gxcQZ_Toy9jELcnIG3x564WxkTf4p_pBUY,1729 +onnx/reference/ops/aionnxml/op_binarizer.py,sha256=LjgRwVocftgfiFn-eEEREg1Evh06FyX82Swgny2_sWQ,430 +onnx/reference/ops/aionnxml/op_dict_vectorizer.py,sha256=E7CLS3RFr3wH5LYx7nTQtsApvOkGwTNOQGeAl2dvPE8,1971 +onnx/reference/ops/aionnxml/op_feature_vectorizer.py,sha256=71_96N2RPQQsh6FK6bK-c58CDb2bbq579vftxZnMAWI,989 +onnx/reference/ops/aionnxml/op_imputer.py,sha256=MFZZkcc65rYiQP_Cs7IzEBY1QTihnrgx_Ags2I-gOgA,1638 +onnx/reference/ops/aionnxml/op_label_encoder.py,sha256=h8Z-xZn1DTj7NqXAt31C5D06r2YHr-t0jHLjUU22zdY,1647 +onnx/reference/ops/aionnxml/op_linear_classifier.py,sha256=knnO7V5iu3bN9NRzK5pWd9-Y_2Ut8xwcADoKRwGr3Wk,3770 +onnx/reference/ops/aionnxml/op_linear_regressor.py,sha256=CGTLHF4I_XJizC4tZ06pan_GqTUnEGXOQ9AKka_WLSE,906 +onnx/reference/ops/aionnxml/op_normalizer.py,sha256=eFu7vnvL3t0f5068fH9L4QS9i1hnXxBLlTQx5_2T1K4,1252 +onnx/reference/ops/aionnxml/op_one_hot_encoder.py,sha256=vfm6BcmbFa0ymuM5WeGy6sOzxRwFTBz17cnwQp4bFkE,2031 +onnx/reference/ops/aionnxml/op_scaler.py,sha256=B32o_FLy3fF7L7TySl_T167Z_3BnoLYxs-4IzrK-M_Y,367 +onnx/reference/ops/aionnxml/op_svm_classifier.py,sha256=09n_8UEfMVCiX1Y8RGygvXrnecWztX3XwFa9lIcgMEI,12086 +onnx/reference/ops/aionnxml/op_svm_helper.py,sha256=4jGG4Y4u4LboWZpjwvXs48CsnlrGnd-2yEqsTvXVTj4,3491 +onnx/reference/ops/aionnxml/op_svm_regressor.py,sha256=wHWrsdFc9i-eYJz2FSsU-phHe1yJ6iesSMKGcqaBGjU,1359 +onnx/reference/ops/aionnxml/op_tree_ensemble_classifier.py,sha256=WnE1qYUILBEOqqqfNauMMRGzKQY5jpN2cRs9KjaLiTQ,5104 +onnx/reference/ops/aionnxml/op_tree_ensemble_helper.py,sha256=3bV2XFLpmQfOpM1BI_SuypkJIadANmhBXpbFXbtLm88,3900 +onnx/reference/ops/aionnxml/op_tree_ensemble_regressor.py,sha256=iwh_k3UBmInjeQjzD33aYrbSxOKWNnXotW2jMI9v4PE,4187 +onnx/reference/ops/experimental/__init__.py,sha256=Opi9ZO3rW-jDNMT0gvU50IAF9HhVPkzQfiokOwTT2Dg,149 +onnx/reference/ops/experimental/__pycache__/__init__.cpython-39.pyc,, +onnx/reference/ops/experimental/__pycache__/_op_list.cpython-39.pyc,, +onnx/reference/ops/experimental/__pycache__/_op_run_experimental.cpython-39.pyc,, +onnx/reference/ops/experimental/__pycache__/op_im2col.cpython-39.pyc,, +onnx/reference/ops/experimental/_op_list.py,sha256=A9SnR4CH6krv8u_ClAqNlmxiWmVfU0Zn-41MbXDFJVI,3075 +onnx/reference/ops/experimental/_op_run_experimental.py,sha256=heaQ1iEj4NjjqlhIsw0qOM0kI5bmbzE1pRMg9OZ5vtE,228 +onnx/reference/ops/experimental/op_im2col.py,sha256=HWwFlTiB5FSXjsg4YxJtaLKKI7eAkV_lUHAfZJGo8eU,729 +onnx/reference/ops/op_abs.py,sha256=RMaJjwro88OhEAmBtVM7kzH9lsW5kFsISsE4LcFocJE,288 +onnx/reference/ops/op_acos.py,sha256=VaBfzo5EYBGHYhQ7ysfCg42zhcTJin0SQPNP1eK5xS4,287 +onnx/reference/ops/op_acosh.py,sha256=09j30LuAaed0l7OerkqyXt_rR47fxrD6zJjj-pqF6IY,289 +onnx/reference/ops/op_add.py,sha256=dLNm5fto036w-V60r3EOJPLcXi62U-_FrIJWBpDhHVQ,356 +onnx/reference/ops/op_and.py,sha256=ht28Jw5J69LNxaCflNlGRemry20K3Xso-PG81gaH3F4,293 +onnx/reference/ops/op_argmax.py,sha256=KRn18OOk6Ric9hAKnB9MOzeHkgmccOUCZOaSROuaeX0,1293 +onnx/reference/ops/op_argmin.py,sha256=Do-5mzr5dBq8Fck72K6zZ9ZG_5kBBA47fUJaGl4zrqA,1293 +onnx/reference/ops/op_asin.py,sha256=T8pG3oAl4h27VinoWNkMMkxBZG-iDJcD0vIjBDB1HmU,287 +onnx/reference/ops/op_asinh.py,sha256=LQA9pI4Pgehqb_Mch8gdcJj5DnlCPucXewYlyzXym4I,289 +onnx/reference/ops/op_atan.py,sha256=uvsakiDFaW9d8XhJAaetou6DQpmOBzF7vdbNKzWWIhM,287 +onnx/reference/ops/op_atanh.py,sha256=B8Uo-jYh5y4SMWP9u7J1wjgOnHehdBb4SV_FWO7XqMY,289 +onnx/reference/ops/op_attribute_has_value.py,sha256=ll_TdYy6r4qXBxY_djkY0B5F-yuayf1eQktCQIdB9Sk,916 +onnx/reference/ops/op_average_pool.py,sha256=tPPXr4ymMQ3ozTFTzww906fB6gPsVP78QZQG8YfOCfo,2522 +onnx/reference/ops/op_batch_normalization.py,sha256=g8GmCrSAESHfXlrjjVSeRFL05TWN4LUirzKaVGdWG-4,3102 +onnx/reference/ops/op_bernoulli.py,sha256=W5M22nfzWSDPYq8zk1b3Ynu0ri6O--pXYXrB70YWhFE,598 +onnx/reference/ops/op_bitshift.py,sha256=cQ2yo12FDMRhv_d0NOupAjyVrRhhtR1zmVmFjY9Cv3g,639 +onnx/reference/ops/op_bitwise_and.py,sha256=BerMaubRLZ6ZHHYe6n_XJhDwCoL0_DqqLizffXA5VTM,300 +onnx/reference/ops/op_bitwise_not.py,sha256=G3S-yLKJHsBddFY0gHacQVDn3eJdVGZnCVQRiLfzKiI,276 +onnx/reference/ops/op_bitwise_or.py,sha256=XiT5UK6Nxm7zJd3dqll2VI1QAYhfoUyMHYbGa2_w_xw,298 +onnx/reference/ops/op_bitwise_xor.py,sha256=ON-Dz-2l0usNMBPEAF-0yYj1ybsdigefPEFj-pmbATI,300 +onnx/reference/ops/op_blackman_window.py,sha256=x24l_CIplEC64bs9MDboAASvcPpjWcOFa2_s427d_Y0,963 +onnx/reference/ops/op_cast.py,sha256=nKKAFQuVHaQcq5lBYeO6OgKNwLjWuCt0NdoiHRuent4,3821 +onnx/reference/ops/op_cast_like.py,sha256=c62q7FPij-XXM8mq--6apNj_WAaYosXp8qhnTHIgvB0,1299 +onnx/reference/ops/op_ceil.py,sha256=tMp9SW1dWE3njtEwVerdo1rGLSWcq1POzxAfECL1VXE,285 +onnx/reference/ops/op_celu.py,sha256=S4drXuaVh8V6_EQxfPGN2GLj7cJs_PdguZVlEZruuic,538 +onnx/reference/ops/op_center_crop_pad.py,sha256=F3y7uF5jXKiobdF1LhVVXkbE2eMoRT9_5GvXs_1ox6w,1742 +onnx/reference/ops/op_clip.py,sha256=h6eTGu4icgzryMosTh7QdwrBzwoECFSfFc50NPHtdak,914 +onnx/reference/ops/op_col2im.py,sha256=o0KrlcQqAvyWyKbxsQAgNhQLF3pYzqVOJVX2PX5xI7o,8255 +onnx/reference/ops/op_compress.py,sha256=lPICBbu5-ruoXzBJrLWqMu_gONi_Zjl9oQtaTsi-knc,336 +onnx/reference/ops/op_concat.py,sha256=L-ctYt3kKgdSU7iomKrZL42RDPjDETRf5lEe2FtARkk,757 +onnx/reference/ops/op_concat_from_sequence.py,sha256=3aVGP1uwSRxsKZ986NTtV8PMGE5qmIEr3CpajLz7pzg,788 +onnx/reference/ops/op_constant.py,sha256=aYFn4dqOPMhDCT91hjX67BGYNm5fZEJBxOyNrpZAJrQ,5381 +onnx/reference/ops/op_constant_of_shape.py,sha256=MZnhYWA6l8oDRogMk4oBtG7zo8BUQsANtfS-qgf0veA,1444 +onnx/reference/ops/op_conv.py,sha256=iaTuu_T0a9KAkIE95mdwJ5W4Xw-qse4yhInXJnG2p2U,19333 +onnx/reference/ops/op_conv_integer.py,sha256=aoOtf4pKdy327m-tOdvVBQzZGAe3Z4jm0QaPi7T959Q,1432 +onnx/reference/ops/op_conv_transpose.py,sha256=FZimSJXinqWIynzL39hidrp4FQcSiTNr_JkagFCpzwo,4213 +onnx/reference/ops/op_cos.py,sha256=qUkIWdHTBSiXbTRBsnL9Ohuwm4XIWmF3iG-HSAWuRck,283 +onnx/reference/ops/op_cosh.py,sha256=e9nBKmSI6Iyc88oCJRVBovIb-PNt-FI2SWDvrm7YVXY,285 +onnx/reference/ops/op_cum_sum.py,sha256=wFPDbH1_VnxTksHaqF9CEe_ZBd4JDyMXBLjIGqP4210,1721 +onnx/reference/ops/op_deform_conv.py,sha256=CZzLhF761glo6ap4CUNKLQvJXG4PFFdhCbjPWW9OKiU,6483 +onnx/reference/ops/op_depth_to_space.py,sha256=m-MHMxT5LItYGtlfPl1ABij36lkCSHyD3UW_ErgRvFM,1349 +onnx/reference/ops/op_dequantize_linear.py,sha256=LSjvf6plnOKvc9NpJ-CQlhs3Pq15U9PeeICyd-pl5dg,3226 +onnx/reference/ops/op_det.py,sha256=Ogq4-SVH67q3moI_YVTKzxN_iBmU0uqRVhYW0O9l0oU,273 +onnx/reference/ops/op_dft.py,sha256=xz9oIv_w5FiWyly2lrunxhkF6CmNcmO58df58VOoKgk,3717 +onnx/reference/ops/op_div.py,sha256=UZk0DjbM49z5I_IZgfZPo4_R6A7-_53jJK9eobRRRoA,556 +onnx/reference/ops/op_dropout.py,sha256=iNUpPMsve5Y91voXR74TbjXIOg-LfsXx-ImPATuj1zU,1966 +onnx/reference/ops/op_dynamic_quantize_linear.py,sha256=2n8I8uHHwwI2GCNEHQfSwBaINXrkfa74wxUq9cF8nxs,1013 +onnx/reference/ops/op_einsum.py,sha256=U5DhLy9vAmupKwhFit_TSFGHPm__8qO90tI0qM9_p6w,668 +onnx/reference/ops/op_elu.py,sha256=yWAdEKE4LzePZrOMeQI9d-ncQr5EHItXb8jjlg0sI0o,398 +onnx/reference/ops/op_equal.py,sha256=TdivH6RHsQT46VnDndW6ib69uxoRl2ojY99p78aAlWU,309 +onnx/reference/ops/op_erf.py,sha256=1sbuMfnk5-89XgB4hieVEH65JKFael0sOh095iZJuWo,492 +onnx/reference/ops/op_exp.py,sha256=Jhy78psn7e4xcobBXgTd4nfcbNQUXChis02LcQ5EriM,299 +onnx/reference/ops/op_expand.py,sha256=R_XLCuXlJX_m-XWlg9KEC6HsGvig_N26lqWhEZGah_o,492 +onnx/reference/ops/op_eyelike.py,sha256=fh_tnFlyD6YQm8HUGaxBQYwlvV2zyf32uFaHi15f57s,1011 +onnx/reference/ops/op_flatten.py,sha256=JE-12PDqurakjITq7SvrImTX22sLLzzaQfBclJ_WupA,472 +onnx/reference/ops/op_floor.py,sha256=OS0Iks2Abnqik6oLcC5ZDAF05Mq8SoqyfUOr1ggXQOQ,287 +onnx/reference/ops/op_gather.py,sha256=z9wig1rJnC4kuSDzgzstL36GY7_tnydUpZ-mjyQlmAI,733 +onnx/reference/ops/op_gather_elements.py,sha256=nfmaacqpu9pG3k-F_bcWKt3ZspVCMIf105eKPqarv-g,1629 +onnx/reference/ops/op_gathernd.py,sha256=XiG-tqbk4uNirApOffqWmVMHgDkE9zMfElGv2iqNbNc,2100 +onnx/reference/ops/op_gemm.py,sha256=fIgZEC2zdJWf-0IwOQBq_QsR52ESLzxq2BxFHWkcd5Y,2024 +onnx/reference/ops/op_global_average_pool.py,sha256=Ig3jdqg15Owv9HmBo5jC2AmK6cwlM4FnoG8MHQAcmD4,529 +onnx/reference/ops/op_global_max_pool.py,sha256=B6wWZHwpYMtNkorHcqpqAipMeZegFO_koZAUYyQeCX0,566 +onnx/reference/ops/op_greater.py,sha256=tZmtOQC7DtOi61IbSLd-6-t6UeM0twRgGGugMl7pDbA,313 +onnx/reference/ops/op_greater_or_equal.py,sha256=oze4LHdiYisw157zSS1-dNnwVzhsyAXigV-PhS2DRo8,326 +onnx/reference/ops/op_grid_sample.py,sha256=hh8AhNrN0xpkT1aHXelfUnpvRgubPr3LuGg5L_VxLBU,8265 +onnx/reference/ops/op_gru.py,sha256=Sgkte6Z8J08P4JzvP-ALYILBGYEd91XIg0Wy129f760,4281 +onnx/reference/ops/op_hamming_window.py,sha256=d1uMJNn1GnvJ7gyFFviEb68o8H4BJ2AeTWTPaJXNrEE,838 +onnx/reference/ops/op_hann_window.py,sha256=Q5ggSqXWunkW9GL1pXYGQDvirrq1xYX5G_QgMYX6rfM,714 +onnx/reference/ops/op_hard_sigmoid.py,sha256=wtqHR894axus7AYPQMdZbh9i29PX-PBdzIRKmlxn-pI,469 +onnx/reference/ops/op_hardmax.py,sha256=peufHO7NbSJvzUs5RZJyxRozPLx_8ffPu7gz047CmAg,551 +onnx/reference/ops/op_identity.py,sha256=fT8AMOFvvNQw_tomb6klaMeQ9vDH42gzuviYLhQvbLo,316 +onnx/reference/ops/op_if.py,sha256=I-Wp1DK6_e2w51muDRBxMEc-z3uVaqUgnoa1biXOp4U,3120 +onnx/reference/ops/op_instance_normalization.py,sha256=du64vqsvMQ-SjfVyRLHy4-n3vJJtifbhyWphxUcTW-E,684 +onnx/reference/ops/op_isinf.py,sha256=M7f4BBsoG2HLaD7OdMB3-5Cdg_Ek4LiC6VyRAjDbbNE,593 +onnx/reference/ops/op_isnan.py,sha256=psXPl9bwQDUiTTSSHIFxzauO6vZ-wz7tLJz0MLCEsaM,287 +onnx/reference/ops/op_layer_normalization.py,sha256=AuN-X2deHC-idqqxWJi7-BwJRAVyNCxPCorzPJrHGIc,2732 +onnx/reference/ops/op_leaky_relu.py,sha256=zTvjWJaEk04yr41k3MshDQcQKwNUAk65MbtoqtZnoMU,570 +onnx/reference/ops/op_less.py,sha256=a1LJZbpkd0bbUrWMBYZvrF6xzsSOA-8VTXJ5VGFwVOQ,307 +onnx/reference/ops/op_less_or_equal.py,sha256=ciejrunLh7Hgjjs4gH_OgME44sfv3_tn7O1gQdkMy-c,320 +onnx/reference/ops/op_log.py,sha256=vrz6erC5PK_fIv-Byft0ypUCA4_OgJxEjKNoz4wLw04,299 +onnx/reference/ops/op_log_softmax.py,sha256=YdKNQRgDDEBoRgVfkd3oRP952gGxk1M6FHfKjCl0PpU,341 +onnx/reference/ops/op_loop.py,sha256=MU_McWEiv5MrdoDx8FhbPyS7D82_tSOk69-LEdS-T68,3702 +onnx/reference/ops/op_lp_normalization.py,sha256=cl37NAXg9vWTbtJM6xYcryK6aB7UhiJXc6eEqDZeMzs,562 +onnx/reference/ops/op_lp_pool.py,sha256=Gua9mKTRlpzmjkzITZYfZ8hJqex7qlut7DBOHFVXWYc,1257 +onnx/reference/ops/op_lrn.py,sha256=p2_dQva2_MkKpYK1AGaqDZyhIdEUZnBmWj8fuPMzpig,929 +onnx/reference/ops/op_lstm.py,sha256=ncCW5shwRbR3lu6JTF_FZ1EaN-Z_ML2TwsUMP_0yyYw,4959 +onnx/reference/ops/op_matmul.py,sha256=F_wZCQNYBvEwUNlNn2RG5ga9t6hilX0k_Tb_-9klLdM,696 +onnx/reference/ops/op_matmul_integer.py,sha256=O0lr9sHlT4U-q2NSzAP2h8rmud0RQj5Vx2oDET9ZZyI,527 +onnx/reference/ops/op_max.py,sha256=-g_ATHZ5vxVbZUJ0ZWP77gKWFsAGuN73nULbNIBkBnc,775 +onnx/reference/ops/op_max_pool.py,sha256=-AFmir3OB2nRKnYPC4ca1Bq_i6or6hXhdyvRPEHL2wk,14914 +onnx/reference/ops/op_max_unpool.py,sha256=IfRt6JjXwiBNn4tBXMSKleURJ8lc-Ehnv_Y_3dnGOFY,1910 +onnx/reference/ops/op_mean.py,sha256=QUnDoKxqdg_I7QPi_9g9k1SkHCdpC9fwCZq5YLufFOE,359 +onnx/reference/ops/op_mel_weight_matrix.py,sha256=sQGsXJM_2g5Qwt3nVUhjXXu9vnubXfgKAyleQMJTHbo,2431 +onnx/reference/ops/op_min.py,sha256=AVjEXQQLCRZIFcE211gKhE3QwAa5rcoZVp4gRC8D1d4,775 +onnx/reference/ops/op_mod.py,sha256=kpXqADvYpdpUMLfUwfoiQw7xbaZ0gAITu5ORaJGKzCg,537 +onnx/reference/ops/op_mul.py,sha256=Z6tvdyXTjxMQX8c8YO_oy3Xsvj-AT8Qp6H975Kl5hww,361 +onnx/reference/ops/op_neg.py,sha256=qVttf5Jmy3_hS2YBJqgCQVP2L3zlIye9lP3Eb9WvNig,288 +onnx/reference/ops/op_negative_log_likelihood_loss.py,sha256=gZ-SgjpCDitsfdoYeusR1o2P4M4T0MQDTECm4EbSYfE,3011 +onnx/reference/ops/op_non_max_suppression.py,sha256=v1cgKO8hz1t2stR1l9D7-fsuPIPrw1AmczpxIJOEAIQ,9719 +onnx/reference/ops/op_non_zero.py,sha256=-oK7UAI2pcKd73sXE_fl-Iz_cyJsW3K45RLhD3dMP18,374 +onnx/reference/ops/op_not.py,sha256=E85wsn-iJP0kpnPTbQc-fQyIXS5DnHFXNllR5SZvSKo,285 +onnx/reference/ops/op_one_hot.py,sha256=ujRgT4iYswBr6mdHxAe4m2e-mKq6ETea8LhfhiGBaEM,992 +onnx/reference/ops/op_optional.py,sha256=FBufFgt38F8EANnMewnaC6-kitFlERnchHdfMkMsrRU,590 +onnx/reference/ops/op_optional_get_element.py,sha256=EoE4XAWspv7IJeMxzXQm-fkp3Qm1u3GsdwlzjPn8vFc,350 +onnx/reference/ops/op_optional_has_element.py,sha256=3_i4TBrylrZGUwmrky6W5harhCAKGR9n4SzQonppSq8,300 +onnx/reference/ops/op_or.py,sha256=60_hYlbiLpbQ81aa9MpT9HeV5Qh_fW6KoGuvezEPXRU,291 +onnx/reference/ops/op_pad.py,sha256=pe5i_N2rT5ya64Txn7T8B6K2IMQ2wxk95ROy8sjIXCg,2155 +onnx/reference/ops/op_pow.py,sha256=Pci4NvRa7JwVMDBm-7jbhRaVSqQ3tNr_4MVPHkgUy7w,415 +onnx/reference/ops/op_prelu.py,sha256=vfIxX6NZpFt1_yexVlP6tr7lcoi2rge-GGxx0FiQucM,1216 +onnx/reference/ops/op_qlinear_conv.py,sha256=qFYJnedEtGkiJrbi0w7mkbew6QfU5dEosdL3JbA_pgg,1825 +onnx/reference/ops/op_qlinear_matmul.py,sha256=lpPR924JafLs4QiViOJP2ORljISLdCcDXEwuLngqi4k,831 +onnx/reference/ops/op_quantize_linear.py,sha256=DLwKAVXEoLvAm9_h8xdXjQsikrFGB6Wc7yBw7Wz6PHk,5010 +onnx/reference/ops/op_random_normal.py,sha256=jMqiu2G8GE_iCxT433fA9q3TI_Y73y-ITHqnHvd2eio,587 +onnx/reference/ops/op_random_normal_like.py,sha256=oUWEYZmqGbZZDg8ozTptA5300G_S118jqhuvR4dTBBI,690 +onnx/reference/ops/op_random_uniform.py,sha256=akoak70BC1oSyHNZHI1FSbH6iSBDt0WIRVb9LFZcNBw,576 +onnx/reference/ops/op_random_uniform_like.py,sha256=FkB6XQcUuWRYJUCV1aCuIyVUZDIB7zghrbAr-A7rAuA,692 +onnx/reference/ops/op_range.py,sha256=WDHNUnaD_hU4yDpHAl3lFTUVFilvknrjlKJgDn_rVGU,328 +onnx/reference/ops/op_reciprocal.py,sha256=-A6upOcu0ECxd3vIPpe2IW5K4UJ9cscglHUGalErotk,361 +onnx/reference/ops/op_reduce_l1.py,sha256=9CmdZZxrFHGlg2xyzv6U4uorU2SiCWt_CvMDhXvRK98,1296 +onnx/reference/ops/op_reduce_l2.py,sha256=iKcBnhn9zgFyP380qApOkrDH8j1ld40iEVqj2-4STPg,1320 +onnx/reference/ops/op_reduce_log_sum.py,sha256=iHLMVrF8bR3LRhp_J6quA_L572goQliKedq7_Zp1YXU,1048 +onnx/reference/ops/op_reduce_log_sum_exp.py,sha256=jHuh224qvcEvch1N_VdWqWSX8bT0UYsqKD-dVJYo3VE,1261 +onnx/reference/ops/op_reduce_max.py,sha256=Z-xYw29qvw7f1t-_OrORd2d2shpJShBFR4AHnLCzVAA,1222 +onnx/reference/ops/op_reduce_mean.py,sha256=DLtxayhzpKyqiBmlsGMxaUYUhpd9M4rBTYq6D8QLOic,1476 +onnx/reference/ops/op_reduce_min.py,sha256=t1VgNlKjL4lnFGCwZeWkRKV92n9cmJSCdKpnR0lEgAs,1270 +onnx/reference/ops/op_reduce_prod.py,sha256=_CXRVe_ctr7K4Kx47UPFUxZCXYCQ-aw_LXhpMgnkteo,1223 +onnx/reference/ops/op_reduce_sum.py,sha256=5VD_9evDrAS631g4TN0jPvJrt5IjXJgrz3ySFEpSN4M,1406 +onnx/reference/ops/op_reduce_sum_square.py,sha256=zzYQLvcC08pvhRpRVUPXgy9V4kPGAZocCAWigwioO8w,1234 +onnx/reference/ops/op_relu.py,sha256=94iiA-NPbU4EBzcW_vp3v6J2FrwliAQB4SaJNf1BK4U,307 +onnx/reference/ops/op_reshape.py,sha256=nnu3lVAU-P1VGC5-rmJUGGtkkExZ5UAeU9qWvLgAt_4,1202 +onnx/reference/ops/op_resize.py,sha256=R11eCoGIroQCxEkHVHGOs1pcgPNQr2emKbG0YgY3jME,16109 +onnx/reference/ops/op_reverse_sequence.py,sha256=CL-vfBu9gxAwMCMcdwzvSJtOQ42z1KE4aFDycDCETls,802 +onnx/reference/ops/op_rnn.py,sha256=phriH74qBuioWF8GiiknW5x9UT4cUatWh3xGsvgVyhM,5117 +onnx/reference/ops/op_roi_align.py,sha256=fruTFh2wUz2CSXv1ZCB4MhKQ6W99Z44k2M3JEvIAv_E,11764 +onnx/reference/ops/op_round.py,sha256=b4hdeAyPUf6Mskn6tqJ4E6eN6nnHjctVYtkfSqOy9hI,303 +onnx/reference/ops/op_scan.py,sha256=VHR4G32Obi9XmF5ucCpi1fOS4-FV3lw6sxE5ypeK8Kw,5458 +onnx/reference/ops/op_scatter_elements.py,sha256=Eg9PKv3Q-4E1LSePEvYBYzyq4q80Byv7LGeFaYmb7XM,4861 +onnx/reference/ops/op_scatternd.py,sha256=FKYmonxC0byKZPyS1N28secxU0J1KIBLUFZklZgf2is,992 +onnx/reference/ops/op_selu.py,sha256=XVsE1x1ISj6Om37shvgQcbwYrzN-MwesOzltMFoqPHM,377 +onnx/reference/ops/op_sequence_at.py,sha256=ZBN0DorosFWRuaCZM-nsPZf6iwkzCCrYUDr3XeqmY5s,261 +onnx/reference/ops/op_sequence_construct.py,sha256=pB_UbhN27EugT_4RWl04VAvYUh_a5bfv7Sb02KZjP58,263 +onnx/reference/ops/op_sequence_empty.py,sha256=rxz1zzTqDiWXYI0b2PLnUtRsg9Stuxy0Pw_ZcUsuIoo,262 +onnx/reference/ops/op_sequence_erase.py,sha256=0ki4XGQr8ayWSa-960gpLujhyW63y1AfVwy6bvUz5zY,391 +onnx/reference/ops/op_sequence_insert.py,sha256=ki0az8TXsV3HXwxexWKRGPSyzO_5ePEiXX6h68MBDsE,1885 +onnx/reference/ops/op_sequence_length.py,sha256=SdRzAY2pzQWS4PcVUT0-2-4lUHuGtIKHueIf97_FPXI,499 +onnx/reference/ops/op_sequence_map.py,sha256=Hs6BO-vxgnSqBR7amY82X9VJSQEt5J8fO-fky7Ns7ls,1259 +onnx/reference/ops/op_shape.py,sha256=LnTp3txKVDqiCXA7ioDbta3J4WA0F-00MdOHrQJfbb0,1190 +onnx/reference/ops/op_shrink.py,sha256=qCJvCjeTXZLW9U1fQSty-wHPBPzh1bd5JeLxpQRD92Y,460 +onnx/reference/ops/op_sigmoid.py,sha256=ZrGR5RNnUnY6OE6fr7GWohNlPHuWMaRZJHVhK58po8Q,732 +onnx/reference/ops/op_sign.py,sha256=sMt4dcpkAIpfNqWaLBmcRm9pbWeFQMC4jwERb9P-D1A,285 +onnx/reference/ops/op_sin.py,sha256=f5xkuq1uFCb4AMSuK3VxrN-UeSkQ4JwLbkr9RBe6Oac,283 +onnx/reference/ops/op_sinh.py,sha256=MCp99pn-yFQhPwIsm_xqsR_MVUgV9-WYr9L6e_IWWKE,285 +onnx/reference/ops/op_size.py,sha256=USMqX0WnEjrmw_VHkmBRCoH_NQfC9HiT__wjZcjTigA,296 +onnx/reference/ops/op_slice.py,sha256=8hE3_SYXTNhM7ilr6JgsVy6E9OFwWXXSdJn-kkxPXt8,2487 +onnx/reference/ops/op_softmax.py,sha256=WaQXbQlFKhChPO4pX44IfDXNX_w_rHO_Ncg8ODXK5tk,504 +onnx/reference/ops/op_softmax_cross_entropy_loss.py,sha256=rDvdTAn26Z1pPf1lVWvTE_WhCJPYbNGpW96B4pbq7Tw,3099 +onnx/reference/ops/op_softplus.py,sha256=l4iu75p-x0pmvAb7Mct613X3R_w8QLlGYhC940oHtCM,371 +onnx/reference/ops/op_softsign.py,sha256=f65xgvFDuQ4_YPNrIwF0MY5i_b9YWkoBsf9Fq5CETWo,361 +onnx/reference/ops/op_space_to_depth.py,sha256=eExCsD4tkz_cm9eNOlpovisKqC6kRfTId_wxxgLdEdg,921 +onnx/reference/ops/op_split.py,sha256=DVYXVxkRwi-f2gesXnABhEGhJbYDLpTLrLgVPfu1jwQ,1703 +onnx/reference/ops/op_split_to_sequence.py,sha256=IPxQoBLuTpV0wb3IAVaA4GqTsQMUxh8cVCQBjVlthj4,1580 +onnx/reference/ops/op_sqrt.py,sha256=dNIwwsyWR3USqJlR8ga9zzLS2NLYvh_MkdX2P2p4tpA,426 +onnx/reference/ops/op_squeeze.py,sha256=4paRUTm-uaGxik_NJd1ICy7l7HfmxJABC3UWgIZ0lLc,1247 +onnx/reference/ops/op_stft.py,sha256=Re3IwoWDR3egKHaB1XrDPB31uHT2Pb_GrL2j4E_uIaI,5769 +onnx/reference/ops/op_string_normalizer.py,sha256=9k3_paegtAE4s1EPVYIuI52KknHobf0eAxrOlnaivUk,5148 +onnx/reference/ops/op_sub.py,sha256=9FXDz4pAk-Iil6rrI4_N8r282xHIAbB_kdu8boyRe2Q,361 +onnx/reference/ops/op_sum.py,sha256=T7FeAX0S3kRallY6VBUi9p6CTB6QWpauBNR_ig9nTgU,270 +onnx/reference/ops/op_tan.py,sha256=fe1sNleqm1xDA3GQKRV5gC1dVQJ3AyRSHePg897NG4U,283 +onnx/reference/ops/op_tanh.py,sha256=b-Kl5gUVwyfsmTrODwudynD1UJlOuhUIryYkHueyJw4,285 +onnx/reference/ops/op_tfidf_vectorizer.py,sha256=_GlajfS2ubGMxWQkqJ0mz0h9X8SQL553DpVwJqR4T4g,13087 +onnx/reference/ops/op_thresholded_relu.py,sha256=mfOPxLqcqQDeJ52U5lmG38VquIjtZPM8WN_jIqh_3PQ,408 +onnx/reference/ops/op_tile.py,sha256=InfSXUgsV9p7fwP7nzlY2xuKjTIxlNLESIFel2ZSD6I,286 +onnx/reference/ops/op_topk.py,sha256=oSQ9EVt_EVllwcsx82yfjeo8Odf7oc__Drmh2kfAjhQ,5027 +onnx/reference/ops/op_transpose.py,sha256=ZIjtVzwVwNAnRoD1NjfaZqrQ4bwqlYsrXqb-kqrqcBA,617 +onnx/reference/ops/op_trilu.py,sha256=zY45Czws6uydm1OGkCPW104Br27PER_3ld8oHDi1P4c,420 +onnx/reference/ops/op_unique.py,sha256=HO0bZ5V5dDuyfztWEQaxkhsJMvsE3Q6H0TICSPh1YdQ,1681 +onnx/reference/ops/op_unsqueeze.py,sha256=qbzVnQEaHduUWwoTIE2WbSJ-LowYrqC0jcxlNwtbCd8,1711 +onnx/reference/ops/op_upsample.py,sha256=Z5azRfI60neI33j297bEJ3QXn-_fbGYHkAzHHbS3yfc,639 +onnx/reference/ops/op_where.py,sha256=N0sF9rkoutlnuqG9-3uh40UkFgCLtcjGoP0ITAM_krc,616 +onnx/reference/ops/op_xor.py,sha256=NTh2vdpmDq3U8VD3yl0FjtyHffyAR4_r8iyuNEVX44U,293 +onnx/reference/reference_evaluator.py,sha256=zbQ4LIpZ-tFskO5yg8rCvyOeV0iXORcA1-URhy5cDdg,19896 +onnx/shape_inference.py,sha256=6wfhzCc87kWYJkKMm-F_n_kF5LmRHv5MIdVUNxBDUp0,5800 +onnx/shape_inference/implementation.cc,sha256=ip8G4FgPCyitIoKroi5iJRLvdqxCS6r4DX9tJJKk0rw,40450 +onnx/shape_inference/implementation.h,sha256=UDIX6yZcGfTevbRNvHPjUnBGUpdKi50csdFhyJCH8Qo,19164 +onnx/string_utils.h,sha256=jAFGm8XyB3PwvijH-0Cni_83gu1rfXQ7v16OGyPeuMU,1337 +onnx/test/cpp/common_path_test.cc,sha256=ETu5bppPwKEpo4hAbvwM5O3T_gs67SQcvIoBlnhLqaI,2368 +onnx/test/cpp/data_propagation_test.cc,sha256=bF_pmQjNpCaN2AtS7kwjCaPLf0AWTcP4upz0XVNolIs,13161 +onnx/test/cpp/function_context_test.cc,sha256=yETG3czyQ_E-QcdvyXSOGznP3DtF3VKz8mP4jP1wt70,10881 +onnx/test/cpp/function_get_test.cc,sha256=VM4FKEjuEv2TTvGGnZp-esiELxPbC43KbaPAqL6iuTo,1487 +onnx/test/cpp/function_verify_test.cc,sha256=WlyXYeidGSownudL4vZ9uf8cJ0RKsKVU5y8fLWZGvFE,21032 +onnx/test/cpp/op_reg_test.cc,sha256=GgeDlCqWpN52DE_iPt6_xHf4W6iQSKkIlMT6WFo9YrI,939 +onnx/test/cpp/parser_test.cc,sha256=2xeDkl6r5auOM5OLhRyhcOFku9_W42GeJv4Feckuy8M,15178 +onnx/test/cpp/schema_registration_test.cc,sha256=QpclLH8Dzg2n9qe0oAwMfbd_T6EvaOwrxDXQbVGAhok,1371 +onnx/test/cpp/shape_inference_test.cc,sha256=z-cWfQkmjpjzJ9PhlJHEUfPsYjd495y3eIgfQHEn0Rc,18574 +onnx/test/cpp/test_main.cc,sha256=FqzAYyZh3Rzue93PamGHgK9SUuWQusQBlMekwDl_MRo,330 +onnx/tools/__init__.py,sha256=HiuD-U6YHJwWikkemKJqBq-35U8KJ9LDdAwdisi7OlQ,85 +onnx/tools/__pycache__/__init__.cpython-39.pyc,, +onnx/tools/__pycache__/net_drawer.cpython-39.pyc,, +onnx/tools/__pycache__/replace_constants.cpython-39.pyc,, +onnx/tools/__pycache__/update_model_dims.cpython-39.pyc,, +onnx/tools/net_drawer.py,sha256=D1CjUu2SqPr9M5YuFWRknQGczHcXY6wJF5B1TP_72G8,5055 +onnx/tools/replace_constants.py,sha256=6LqM-aK7UHdguWnbE10G6fak-9frMq5zkbNbcuDL8CI,15301 +onnx/tools/update_model_dims.py,sha256=CZCp6nDmi2B-hhnhIYgwP0oNXhmcl5kVuT9Fk6w5Q1I,3534 +onnx/utils.py,sha256=0ZtYHabNyO5BiI29kZxyuGtH7cKscUBh3JkSXjgo4Ec,8593 +onnx/version.py,sha256=P5mypqsC6aZAsPIwuIvrVT2Mi6-BAI9P-qVnC5kWOMM,134 +onnx/version_converter.py,sha256=60yaNBq22A19B-4C3oDT9FcZgSGAv2-yaygofdPgaos,6806 +onnx/version_converter/BaseConverter.h,sha256=8iK9tAmQ7B0aafnuvR7pwYNWDWsNDp_-q2nZyc5zuM0,3804 +onnx/version_converter/adapters/adapter.h,sha256=wkt0i_bIf1jNzYqsWVgIdQakHWc9Gm_U4JX37q0eB4M,1838 +onnx/version_converter/adapters/axes_attribute_to_input.h,sha256=hOA1OrbmnFhlKy7dmXTC9qtIGU6vZBo-q0efnrxoLFU,1290 +onnx/version_converter/adapters/axes_input_to_attribute.h,sha256=6MJWPpKtC55wMcdM4Lr6TYSWA-lI3xdNQXtrVRHtYhc,2480 +onnx/version_converter/adapters/batch_normalization_13_14.h,sha256=qsYoHjKC7uk58KjUdX_txMJJMTm2BJaXaUaRLesKqB8,898 +onnx/version_converter/adapters/broadcast_backward_compatibility.h,sha256=dBl8w0jnDYpR_nXwN5FdXCbqKkV6SyjmA0QjgNOkPWU,2154 +onnx/version_converter/adapters/broadcast_forward_compatibility.h,sha256=fex9-XyF7vUVGrQritIPR5krFrDpBovhTqRYiTaDKLA,3278 +onnx/version_converter/adapters/cast_9_8.h,sha256=ppFPKdg8B_-pSN-bHXaxLKb6m9sOOrOBu_4FQHtRdas,880 +onnx/version_converter/adapters/clip_10_11.h,sha256=It5SLMLpgIM0mIxTQzd7e53qnnCF7sezZmWMVnYN0dA,1537 +onnx/version_converter/adapters/compatible.h,sha256=UPZ6GTCJr_Azxhzh9u7JvGDDlUw3v8LWpplaIxdjqiw,688 +onnx/version_converter/adapters/dropout_11_12.h,sha256=4q1LR-9WnArBvrJHcxwMZ37gkm4e8nEV-NaMFzpI1Z8,1155 +onnx/version_converter/adapters/extend_supported_types.h,sha256=ibQWayzb0mDAd1rBpjon0At5gs__2ID9FCIr5C_qKgo,3864 +onnx/version_converter/adapters/gemm_6_7.h,sha256=T3NNShynHYcQFpKDaJ2Xm4Wb-kdJTAZy-4YBXFe3TvE,1661 +onnx/version_converter/adapters/gemm_7_6.h,sha256=NWlhlKyLcdNDPTAvrTHjldelWhD-JLPWwI9nyc80x5A,1864 +onnx/version_converter/adapters/maxpool_8_7.h,sha256=4iWixoV_JRVq7jasBdRvC5rd9q1q-aS4auLDy4XFTHE,955 +onnx/version_converter/adapters/no_previous_version.h,sha256=zboIafOlBOxSdiePJX2BfCpdsjc45RfBAHPYtmbVlvE,796 +onnx/version_converter/adapters/pad_10_11.h,sha256=aTq4ZVB9_nZzKk9mNgsTjiQlsbpnEWr4SH-OmgXDU_U,1658 +onnx/version_converter/adapters/remove_consumed_inputs.h,sha256=VmQ5o5nyOqMHkYSN8zbM0B7zho-sZU0iQ3AnHkxz20k,756 +onnx/version_converter/adapters/reshape_4_5.h,sha256=qhwl3q90SNHAF7Jvd9mpy97OPPTtthMt1IMANQNE_IE,1380 +onnx/version_converter/adapters/reshape_5_4.h,sha256=DywCci1pLoxGygU2mPhI3V7lYvlIGKOvyjKUE5NQnxY,2559 +onnx/version_converter/adapters/resize_10_11.h,sha256=xQmyW6J0N2SygS9DAXdCYfDI3B3W5-kOELSNlo_TH1U,1262 +onnx/version_converter/adapters/scan_8_9.h,sha256=HEikFtgraX12G7U8iDSKkvb1lysre650zVDy-tgBrWA,1763 +onnx/version_converter/adapters/scan_9_8.h,sha256=jGfEgPAWoAk6IukLc6-AVOL9hnp2IXUw2KbWmqFjSe0,2927 +onnx/version_converter/adapters/scatter_10_11.h,sha256=6I555MxnuWSUuHU5OXaAEGRoPUAoBX2T80PN-W02FUY,1198 +onnx/version_converter/adapters/slice_9_10.h,sha256=HLNYB65VhlKLruEcaoBhUzlF20-4bOizm7lvHPhyaGY,1452 +onnx/version_converter/adapters/softmax_12_13.h,sha256=0HaiF6Cw3YOUwxKTpzEvJPsEVqMcG8nWA2QUrTN4Zkk,2824 +onnx/version_converter/adapters/split_12_13.h,sha256=SWjzS0ElYTIOaiuGAB7U-qOC9k3uhtkGp_nI0gUrywo,1202 +onnx/version_converter/adapters/split_13_12.h,sha256=z-UoAoxBetwNjYcZyw12tMKeJk__E0B9joorfyUGmew,2401 +onnx/version_converter/adapters/split_17_18.h,sha256=QGgns2NleFQBV_ggc9aYEiaVlxT913F63fx8Q-AHPpY,1026 +onnx/version_converter/adapters/sum_8_7.h,sha256=LwkFUXvimpBg63T8MOA2ojDTyNZDGyIlLot0mIUW8x8,1084 +onnx/version_converter/adapters/topk_9_10.h,sha256=NysYF_yqnHZChZNS2x7SyWnVEWMnQ1c4-fNwN-bFYoY,1009 +onnx/version_converter/adapters/transformers.h,sha256=m10yd4ibduGet3xvgoFSY9CyTnuH5C7ZuNifCnSjXiM,2162 +onnx/version_converter/adapters/type_restriction.h,sha256=gLTDW1hjGWXIAqXWhqY_MheeJuWXgsX1piVTkXaT1qs,1604 +onnx/version_converter/adapters/upsample_6_7.h,sha256=Phdv1ZhfbEfm5BbpLfqVbXLCuaHGnJMGGXtQzmZddXw,1494 +onnx/version_converter/adapters/upsample_8_9.h,sha256=RCwEpg3JAi38B0ALtB20G6uJd4nwi1Is9WwGrXoJ4fE,1294 +onnx/version_converter/adapters/upsample_9_10.h,sha256=-JF74gb4EK683MK8-CEJjZTLXb_pOIE0pO39LyuSIiI,1074 +onnx/version_converter/adapters/upsample_9_8.h,sha256=0NuYGD4O5wH7brBccYtgVnKS51RFwoEmlgUhBMn4Sns,2539 +onnx/version_converter/convert.cc,sha256=zjtaGaFECwYOWI7LKkhmZLAPYDdMR_VfrANQxhG-xP4,5580 +onnx/version_converter/convert.h,sha256=yYDfUGPdmGjcNCu0XAIrUCsp3qQqDtoqL5y_uCYeG_w,37730 +onnx/version_converter/helper.cc,sha256=PvgbXTsJ7iD3bdl4cCetcuXl1qy9J8SR1PcxyJh2AfU,2806 +onnx/version_converter/helper.h,sha256=koPC0J3GQWD4HoiTs4B0PlC-1ftRDTZpuAABXln_MGg,757 diff --git a/runtime/Lib/site-packages/onnx-1.14.0.dist-info/WHEEL b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..d5ae687e23d0112bda36fe6af4e8353bddd09a8d --- /dev/null +++ b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.40.0) +Root-Is-Purelib: false +Tag: cp39-cp39-win_amd64 + diff --git a/runtime/Lib/site-packages/onnx-1.14.0.dist-info/entry_points.txt b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..106d559616ad472eb3e7ecefef21e34fce2f4fb2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/entry_points.txt @@ -0,0 +1,5 @@ +[console_scripts] +backend-test-tools = onnx.backend.test.cmd_tools:main +check-model = onnx.bin.checker:check_model +check-node = onnx.bin.checker:check_node + diff --git a/runtime/Lib/site-packages/onnx-1.14.0.dist-info/top_level.txt b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..b20b937c09b8aa4d88413538c56c80739b73b041 --- /dev/null +++ b/runtime/Lib/site-packages/onnx-1.14.0.dist-info/top_level.txt @@ -0,0 +1 @@ +onnx diff --git a/runtime/Lib/site-packages/onnx/__init__.py b/runtime/Lib/site-packages/onnx/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c89f62fdc88f476be4ffcfb17cbbf16bdbb1ceb2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/__init__.py @@ -0,0 +1,297 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +# isort:skip_file +import os +import typing +from typing import Union, IO, Optional, TypeVar, Any + +import google.protobuf.message + +from onnx.onnx_cpp2py_export import ONNX_ML +from onnx.external_data_helper import ( + load_external_data_for_model, + write_external_data_tensors, + convert_model_to_external_data, +) +from onnx.onnx_pb import ( + AttributeProto, + EXPERIMENTAL, + FunctionProto, + GraphProto, + IR_VERSION, + IR_VERSION_2017_10_10, + IR_VERSION_2017_10_30, + IR_VERSION_2017_11_3, + IR_VERSION_2019_1_22, + IR_VERSION_2019_3_18, + IR_VERSION_2019_9_19, + IR_VERSION_2020_5_8, + IR_VERSION_2021_7_30, + ModelProto, + NodeProto, + OperatorSetIdProto, + OperatorStatus, + STABLE, + SparseTensorProto, + StringStringEntryProto, + TensorAnnotation, + TensorProto, + TensorShapeProto, + TrainingInfoProto, + TypeProto, + ValueInfoProto, + Version, +) +from onnx.onnx_operators_pb import OperatorProto, OperatorSetProto +from onnx.onnx_data_pb import MapProto, OptionalProto, SequenceProto +from onnx.version import version as __version__ + +# Import common subpackages so they're available when you 'import onnx' +from onnx import ( + checker, + compose, + defs, + gen_proto, + helper, + hub, + mapping, + numpy_helper, + parser, + printer, + shape_inference, + utils, + version_converter, +) + + +def _load_bytes(f: Union[IO[bytes], str]) -> bytes: + if hasattr(f, "read") and callable(typing.cast(IO[bytes], f).read): + content = typing.cast(IO[bytes], f).read() + else: + with open(typing.cast(str, f), "rb") as readable: + content = readable.read() + return content + + +def _save_bytes(content: bytes, f: Union[IO[bytes], str]) -> None: + if hasattr(f, "write") and callable(typing.cast(IO[bytes], f).write): + typing.cast(IO[bytes], f).write(content) + else: + with open(typing.cast(str, f), "wb") as writable: + writable.write(content) + + +def _get_file_path(f: Union[IO[bytes], str]) -> Optional[str]: + if isinstance(f, str): + return os.path.abspath(f) + if hasattr(f, "name"): + return os.path.abspath(f.name) + return None + + +def _serialize(proto: Union[bytes, google.protobuf.message.Message]) -> bytes: + """Serialize a in-memory proto to bytes. + + Args: + proto: An in-memory proto, such as a ModelProto, TensorProto, etc + + Returns: + Serialized proto in bytes. + """ + if isinstance(proto, bytes): + return proto + if hasattr(proto, "SerializeToString") and callable(proto.SerializeToString): + try: + result = proto.SerializeToString() + except ValueError as e: + if proto.ByteSize() >= checker.MAXIMUM_PROTOBUF: + raise ValueError( + "The proto size is larger than the 2 GB limit. " + "Please use save_as_external_data to save tensors separately from the model file." + ) from e + raise + return result # type: ignore + raise TypeError( + f"No SerializeToString method is detected. Neither proto is a str.\ntype is {type(proto)}" + ) + + +_Proto = TypeVar("_Proto", bound=google.protobuf.message.Message) + + +def _deserialize(s: bytes, proto: _Proto) -> _Proto: + """Parse bytes into a in-memory proto. + + Args: + s: bytes containing serialized proto + proto: a in-memory proto object + + Returns: + The proto instance filled in by `s`. + + Raises: + TypeError: if `proto` is not a protobuf message. + """ + if not isinstance(s, bytes): + raise TypeError(f"Parameter 's' must be bytes, but got type: {type(s)}") + + if not (hasattr(proto, "ParseFromString") and callable(proto.ParseFromString)): + raise TypeError(f"No ParseFromString method is detected. Type is {type(proto)}") + + decoded = typing.cast(Optional[int], proto.ParseFromString(s)) + if decoded is not None and decoded != len(s): + raise google.protobuf.message.DecodeError( + f"Protobuf decoding consumed too few bytes: {decoded} out of {len(s)}" + ) + return proto + + +def load_model( + f: Union[IO[bytes], str], + format: Optional[Any] = None, # pylint: disable=redefined-builtin + load_external_data: bool = True, +) -> ModelProto: + """Loads a serialized ModelProto into memory. + + Args: + f: can be a file-like object (has "read" function) or a string containing a file name + format: for future use + load_external_data: Whether to load the external data. + Set to True if the data is under the same directory of the model. + If not, users need to call :func:`load_external_data_for_model` + with directory to load external data from. + + Returns: + Loaded in-memory ModelProto. + """ + s = _load_bytes(f) + model = load_model_from_string(s, format=format) + + if load_external_data: + model_filepath = _get_file_path(f) + if model_filepath: + base_dir = os.path.dirname(model_filepath) + load_external_data_for_model(model, base_dir) + + return model + + +def load_tensor( + f: Union[IO[bytes], str], + format: Optional[Any] = None, # pylint: disable=redefined-builtin +) -> TensorProto: + """Loads a serialized TensorProto into memory. + + Args: + f: can be a file-like object (has "read" function) or a string containing a file name + format: for future use + + Returns: + Loaded in-memory TensorProto. + """ + s = _load_bytes(f) + return load_tensor_from_string(s, format=format) + + +def load_model_from_string( + s: bytes, + format: Optional[Any] = None, # pylint: disable=redefined-builtin +) -> ModelProto: + """Loads a binary string (bytes) that contains serialized ModelProto. + + Args: + s: a string, which contains serialized ModelProto + format: for future use + + Returns: + Loaded in-memory ModelProto. + """ + del format # Unused + return _deserialize(s, ModelProto()) + + +def load_tensor_from_string( + s: bytes, + format: Optional[Any] = None, # pylint: disable=redefined-builtin +) -> TensorProto: + """Loads a binary string (bytes) that contains serialized TensorProto. + + Args: + s: a string, which contains serialized TensorProto + format: for future use + + Returns: + Loaded in-memory TensorProto. + """ + del format # Unused + return _deserialize(s, TensorProto()) + + +def save_model( + proto: Union[ModelProto, bytes], + f: Union[IO[bytes], str], + format: Optional[Any] = None, # pylint: disable=redefined-builtin + save_as_external_data: bool = False, + all_tensors_to_one_file: bool = True, + location: Optional[str] = None, + size_threshold: int = 1024, + convert_attribute: bool = False, +) -> None: + """ + Saves the ModelProto to the specified path and optionally, serialize tensors with raw data as external data before saving. + + Args: + proto: should be a in-memory ModelProto + f: can be a file-like object (has "write" function) or a string containing a file name format for future use + save_as_external_data: If true, save tensors to external file(s). + all_tensors_to_one_file: Effective only if save_as_external_data is True. + If true, save all tensors to one external file specified by location. + If false, save each tensor to a file named with the tensor name. + location: Effective only if save_as_external_data is true. + Specify the external file that all tensors to save to. + If not specified, will use the model name. + size_threshold: Effective only if save_as_external_data is True. + Threshold for size of data. Only when tensor's data is >= the size_threshold it will be converted + to external data. To convert every tensor with raw data to external data set size_threshold=0. + convert_attribute: Effective only if save_as_external_data is True. + If true, convert all tensors to external data + If false, convert only non-attribute tensors to external data + """ + del format # Unused + + if isinstance(proto, bytes): + proto = _deserialize(proto, ModelProto()) + + if save_as_external_data: + convert_model_to_external_data( + proto, all_tensors_to_one_file, location, size_threshold, convert_attribute + ) + + model_filepath = _get_file_path(f) + if model_filepath: + basepath = os.path.dirname(model_filepath) + proto = write_external_data_tensors(proto, basepath) + + serialized = _serialize(proto) + _save_bytes(serialized, f) + + +def save_tensor(proto: TensorProto, f: Union[IO[bytes], str]) -> None: + """ + Saves the TensorProto to the specified path. + + Args: + proto: should be a in-memory TensorProto + f: can be a file-like object (has "write" function) or a string containing a file name + format: for future use + """ + serialized = _serialize(proto) + _save_bytes(serialized, f) + + +# For backward compatibility +load = load_model +load_from_string = load_model_from_string +save = save_model diff --git a/runtime/Lib/site-packages/onnx/backend/__init__.py b/runtime/Lib/site-packages/onnx/backend/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..de8e3a385434d6c541b8b544342983b60f8eb0c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/runtime/Lib/site-packages/onnx/backend/base.py b/runtime/Lib/site-packages/onnx/backend/base.py new file mode 100644 index 0000000000000000000000000000000000000000..51567ab042b1498a861138da02ea79f63ec3296f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/base.py @@ -0,0 +1,138 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +# pylint: disable=W0613 + +from collections import namedtuple +from typing import Any, Dict, NewType, Optional, Sequence, Tuple, Type + +import numpy + +import onnx.checker +import onnx.onnx_cpp2py_export.checker as c_checker +from onnx import IR_VERSION, ModelProto, NodeProto + + +class DeviceType: + """ + Describes device type. + """ + + _Type = NewType("_Type", int) + CPU: _Type = _Type(0) + CUDA: _Type = _Type(1) + + +class Device: + """ + Describes device type and device id + syntax: device_type:device_id(optional) + example: 'CPU', 'CUDA', 'CUDA:1' + """ + + def __init__(self, device: str) -> None: + options = device.split(":") + self.type = getattr(DeviceType, options[0]) + self.device_id = 0 + if len(options) > 1: + self.device_id = int(options[1]) + + +def namedtupledict( + typename: str, field_names: Sequence[str], *args: Any, **kwargs: Any +) -> Type[Tuple[Any, ...]]: + field_names_map = {n: i for i, n in enumerate(field_names)} + # Some output names are invalid python identifier, e.g. "0" + kwargs.setdefault("rename", True) + data = namedtuple(typename, field_names, *args, **kwargs) # type: ignore + + def getitem(self: Any, key: Any) -> Any: + if isinstance(key, str): + key = field_names_map[key] + return super(type(self), self).__getitem__(key) # type: ignore + + data.__getitem__ = getitem # type: ignore[assignment] + return data + + +class BackendRep: + """ + BackendRep is the handle that a Backend returns after preparing to execute + a model repeatedly. Users will then pass inputs to the run function of + BackendRep to retrieve the corresponding results. + """ + + def run(self, inputs: Any, **kwargs: Any) -> Tuple[Any, ...]: + """Abstract function.""" + return (None,) + + +class Backend: + """ + Backend is the entity that will take an ONNX model with inputs, + perform a computation, and then return the output. + + For one-off execution, users can use run_node and run_model to obtain results quickly. + + For repeated execution, users should use prepare, in which the Backend + does all of the preparation work for executing the model repeatedly + (e.g., loading initializers), and returns a BackendRep handle. + """ + + @classmethod + def is_compatible( + cls, model: ModelProto, device: str = "CPU", **kwargs: Any + ) -> bool: + # Return whether the model is compatible with the backend. + return True + + @classmethod + def prepare( + cls, model: ModelProto, device: str = "CPU", **kwargs: Any + ) -> Optional[BackendRep]: + # TODO Remove Optional from return type + onnx.checker.check_model(model) + return None + + @classmethod + def run_model( + cls, model: ModelProto, inputs: Any, device: str = "CPU", **kwargs: Any + ) -> Tuple[Any, ...]: + backend = cls.prepare(model, device, **kwargs) + assert backend is not None + return backend.run(inputs) + + @classmethod + def run_node( + cls, + node: NodeProto, + inputs: Any, + device: str = "CPU", + outputs_info: Optional[Sequence[Tuple[numpy.dtype, Tuple[int, ...]]]] = None, + **kwargs: Dict[str, Any], + ) -> Optional[Tuple[Any, ...]]: + """Simple run one operator and return the results. + Args: + outputs_info: a list of tuples, which contains the element type and + shape of each output. First element of the tuple is the dtype, and + the second element is the shape. More use case can be found in + https://github.com/onnx/onnx/blob/main/onnx/backend/test/runner/__init__.py + """ + # TODO Remove Optional from return type + if "opset_version" in kwargs: + special_context = c_checker.CheckerContext() + special_context.ir_version = IR_VERSION + special_context.opset_imports = {"": kwargs["opset_version"]} # type: ignore + onnx.checker.check_node(node, special_context) + else: + onnx.checker.check_node(node) + + return None + + @classmethod + def supports_device(cls, device: str) -> bool: + """ + Checks whether the backend is compiled with particular device support. + In particular it's used in the testing suite. + """ + return True diff --git a/runtime/Lib/site-packages/onnx/backend/sample/__init__.py b/runtime/Lib/site-packages/onnx/backend/sample/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1772a77dcab736dd48287b71f55345158068c13f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/sample/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 diff --git a/runtime/Lib/site-packages/onnx/backend/sample/ops/__init__.py b/runtime/Lib/site-packages/onnx/backend/sample/ops/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c89d36b33941bcdd413e84243b5ccabaf78d1b7c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/sample/ops/__init__.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import importlib +import inspect +import pkgutil +import sys +from types import ModuleType +from typing import Dict + + +def collect_sample_implementations() -> Dict[str, str]: + dict_: Dict[str, str] = {} + _recursive_scan(sys.modules[__name__], dict_) + return dict_ + + +def _recursive_scan(package: ModuleType, dict_: Dict[str, str]) -> None: + pkg_dir = package.__path__ # type: ignore + module_location = package.__name__ + for _module_loader, name, ispkg in pkgutil.iter_modules(pkg_dir): # type: ignore + module_name = f"{module_location}.{name}" # Module/package + module = importlib.import_module(module_name) + dict_[name] = inspect.getsource(module) + if ispkg: + _recursive_scan(module, dict_) diff --git a/runtime/Lib/site-packages/onnx/backend/sample/ops/abs.py b/runtime/Lib/site-packages/onnx/backend/sample/ops/abs.py new file mode 100644 index 0000000000000000000000000000000000000000..236a5d3bff362de4ba388a8ca8d19446a0d1d3fa --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/sample/ops/abs.py @@ -0,0 +1,7 @@ +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + + +def abs(input: np.ndarray) -> np.ndarray: + return np.abs(input) # type: ignore[no-any-return] diff --git a/runtime/Lib/site-packages/onnx/backend/test/__init__.py b/runtime/Lib/site-packages/onnx/backend/test/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f03ed7c0d43a08cb5f2ebd6472e525d63d383110 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +__all__ = ["BackendTest"] +# for backward compatibility +from onnx.backend.test.runner import Runner as BackendTest diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/__init__.py b/runtime/Lib/site-packages/onnx/backend/test/case/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8df46538838e81bf61dcd847365c269879e775a7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import sys +from typing import Dict, List, Tuple + +from onnx.backend.test.case.base import Snippets +from onnx.backend.test.case.utils import import_recursive + + +def collect_snippets() -> Dict[str, List[Tuple[str, str]]]: + import_recursive(sys.modules[__name__]) + return Snippets diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/base.py b/runtime/Lib/site-packages/onnx/backend/test/case/base.py new file mode 100644 index 0000000000000000000000000000000000000000..fd9b0413a76c0f375e9ca052edd24a5810d7e145 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/base.py @@ -0,0 +1,46 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import inspect +from collections import defaultdict +from textwrap import dedent +from typing import Any, Dict, List, Tuple, Type + +import numpy as np + + +def process_snippet(op_name: str, name: str, export: Any) -> Tuple[str, str]: + snippet_name = name[len("export_") :] or op_name.lower() + source_code = dedent(inspect.getsource(export)) + # remove the function signature line + lines = source_code.splitlines() + assert lines[0] == "@staticmethod" + assert lines[1].startswith("def export") + return snippet_name, dedent("\n".join(lines[2:])) + + +Snippets: Dict[str, List[Tuple[str, str]]] = defaultdict(list) + + +class _Exporter(type): + exports: Dict[str, List[Tuple[str, str]]] = defaultdict(list) + + def __init__( + cls, name: str, bases: Tuple[Type[Any], ...], dct: Dict[str, Any] + ) -> None: + for k, v in dct.items(): + if k.startswith("export"): + if not isinstance(v, staticmethod): + raise ValueError("Only staticmethods could be named as export.*") + export = getattr(cls, k) + Snippets[name].append(process_snippet(name, k, export)) + # export functions should call expect and so populate + # TestCases + np.random.seed(seed=0) + export() + super().__init__(name, bases, dct) + + +class Base(metaclass=_Exporter): + pass diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/__init__.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..94e702277a1446f897e152ab9b679ab26758ace8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/__init__.py @@ -0,0 +1,78 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import sys +from typing import List, Optional, Sequence + +import numpy as np + +from onnx import ModelProto +from onnx.backend.test.case.test_case import TestCase +from onnx.backend.test.case.utils import import_recursive + +_SimpleModelTestCases = [] + + +def expect( + model: ModelProto, + inputs: Sequence[np.ndarray], + outputs: Sequence[np.ndarray], + name: Optional[str] = None, +) -> None: + name = name or model.graph.name + _SimpleModelTestCases.append( + TestCase( + name=name, + model_name=model.graph.name, + url=None, + model_dir=None, + model=model, + data_sets=[(inputs, outputs)], + kind="simple", + rtol=1e-3, + atol=1e-7, + ) + ) + + +# BASE_URL = "https://download.onnxruntime.ai/onnx/models" +BASE_URL = "onnx/backend/test/data/light/light_%s.onnx" + + +def collect_testcases() -> List[TestCase]: + """Collect model test cases defined in python/numpy code.""" + + real_model_testcases = [] + + model_tests = [ + ("test_bvlc_alexnet", "bvlc_alexnet", 1e-3, 1e-7), + ("test_densenet121", "densenet121", 2e-3, 1e-7), + ("test_inception_v1", "inception_v1", 1e-3, 1e-7), + ("test_inception_v2", "inception_v2", 1e-3, 1e-7), + ("test_resnet50", "resnet50", 1e-3, 1e-7), + ("test_shufflenet", "shufflenet", 1e-3, 1e-7), + ("test_squeezenet", "squeezenet", 1e-3, 1e-7), + ("test_vgg19", "vgg19", 1e-3, 1e-7), + ("test_zfnet512", "zfnet512", 1e-3, 1e-7), + ] + + for test_name, model_name, rtol, atol in model_tests: + url = BASE_URL % model_name + real_model_testcases.append( + TestCase( + name=test_name, + model_name=model_name, + url=url, + model_dir=None, + model=None, + data_sets=None, + kind="real", + rtol=rtol, + atol=atol, + ) + ) + + import_recursive(sys.modules[__name__]) + + return real_model_testcases + _SimpleModelTestCases diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/expand.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/expand.py new file mode 100644 index 0000000000000000000000000000000000000000..3fe3ae7cb3a4bee3995dbde8e414e2655562d1b0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/expand.py @@ -0,0 +1,88 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +from typing import Sequence + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class ExpandDynamicShape(Base): + @staticmethod + def export() -> None: + def make_graph( + node: onnx.helper.NodeProto, + input_shape: Sequence[int], + shape_shape: Sequence[int], + output_shape: Sequence[int], + ) -> onnx.helper.GraphProto: + graph = onnx.helper.make_graph( + nodes=[node], + name="Expand", + inputs=[ + onnx.helper.make_tensor_value_info( + "X", onnx.TensorProto.FLOAT, input_shape + ), + onnx.helper.make_tensor_value_info( + "shape", onnx.TensorProto.INT64, shape_shape + ), + ], + outputs=[ + onnx.helper.make_tensor_value_info( + "Y", onnx.TensorProto.FLOAT, output_shape + ) + ], + ) + return graph + + node = onnx.helper.make_node("Expand", ["X", "shape"], ["Y"], name="test") + input_shape = [1, 3, 1] + x = np.ones(input_shape, dtype=np.float32) + + # 1st testcase + shape = np.array([3, 1], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model1") + + # 2nd testcase + shape = np.array([1, 3], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model2") + + # 3rd testcase + shape = np.array([3, 1, 3], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model3") + + # 4th testcase + shape = np.array([3, 3, 1, 3], dtype=np.int64) + y = x * np.ones(shape, dtype=np.float32) + graph = make_graph(node, input_shape, shape.shape, y.shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model4") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/gradient.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..b104c917ddd1591c7365b9a079f144293cf8eca5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/gradient.py @@ -0,0 +1,109 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN, ONNX_DOMAIN + + +class Gradient(Base): + @staticmethod + def export_gradient_scalar_add() -> None: + add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add") + gradient_node = onnx.helper.make_node( + "Gradient", + ["a", "b"], + ["dc_da", "dc_db"], + name="my_gradient", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + xs=["a", "b"], + y="c", + ) + + a = np.array(1.0).astype(np.float32) + b = np.array(2.0).astype(np.float32) + c = a + b + # dc / da = d(a+b) / da = 1 + dc_da = np.array(1).astype(np.float32) + # db / db = d(a+b) / db = 1 + dc_db = np.array(1).astype(np.float32) + + graph = onnx.helper.make_graph( + nodes=[add_node, gradient_node], + name="GradientOfAdd", + inputs=[ + onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []), + ], + outputs=[ + onnx.helper.make_tensor_value_info("c", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dc_da", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dc_db", onnx.TensorProto.FLOAT, []), + ], + ) + opsets = [ + onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12), + onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1), + ] + model = onnx.helper.make_model_gen_version( + graph, producer_name="backend-test", opset_imports=opsets + ) + expect( + model, inputs=[a, b], outputs=[c, dc_da, dc_db], name="test_gradient_of_add" + ) + + @staticmethod + def export_gradient_scalar_add_and_mul() -> None: + add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add") + mul_node = onnx.helper.make_node("Mul", ["c", "a"], ["d"], name="my_mul") + gradient_node = onnx.helper.make_node( + "Gradient", + ["a", "b"], + ["dd_da", "dd_db"], + name="my_gradient", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + xs=["a", "b"], + y="d", + ) + + a = np.array(1.0).astype(np.float32) + b = np.array(2.0).astype(np.float32) + c = a + b + # d = a * c = a * (a + b) + d = a * c + # dd / da = d(a*a+a*b) / da = 2 * a + b + dd_da = (2 * a + b).astype(np.float32) + # dd / db = d(a*a+a*b) / db = a + dd_db = a + + graph = onnx.helper.make_graph( + nodes=[add_node, mul_node, gradient_node], + name="GradientOfTwoOperators", + inputs=[ + onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []), + ], + outputs=[ + onnx.helper.make_tensor_value_info("d", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dd_da", onnx.TensorProto.FLOAT, []), + onnx.helper.make_tensor_value_info("dd_db", onnx.TensorProto.FLOAT, []), + ], + ) + + opsets = [ + onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12), + onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1), + ] + model = onnx.helper.make_model_gen_version( + graph, producer_name="backend-test", opset_imports=opsets + ) + expect( + model, + inputs=[a, b], + outputs=[d, dd_da, dd_db], + name="test_gradient_of_add_and_mul", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/sequence.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/sequence.py new file mode 100644 index 0000000000000000000000000000000000000000..d2cb145fb80c614667c4d410dcaf42bc417f9359 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/sequence.py @@ -0,0 +1,457 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import typing +from typing import List, Optional, Union + +import numpy as np + +import onnx +from onnx import TensorProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +def SequenceEmptyImpl() -> List[Optional[np.ndarray]]: + return [] + + +def SequenceConstructImpl(*tensors: np.ndarray) -> List[np.ndarray]: + return list(tensors) + + +def SequenceInsertImpl( + sequence: List[np.ndarray], tensor: np.ndarray, position: Optional[int] = None +) -> List[np.ndarray]: + if position is None: + position = len(sequence) + sequence.insert(position, tensor) + return sequence + + +def SequenceAtImpl(sequence: List[np.ndarray], position: int) -> np.ndarray: + return sequence[position] + + +def SequenceEraseImpl( + sequence: List[np.ndarray], position: Optional[int] = None +) -> List[Optional[np.ndarray]]: + if position is None: + position = -1 + del sequence[position] + return sequence + + +def SequenceLengthImpl(sequence: List[np.ndarray]) -> np.int64: + return np.int64(len(sequence)) + + +def SplitToSequenceImpl( + tensor: np.ndarray, + split: Optional[Union[int, List[int]]] = None, + axis: int = 0, + keepdims: int = 1, +) -> List[np.ndarray]: + dim_size = tensor.shape[axis] + if split is None: + split = 1 + split_indices = [ + i * split + 1 for i in range(dim_size) if i * split + 1 < dim_size + ] + if not keepdims: + results = np.array_split(tensor, split_indices, axis) + return [np.squeeze(res, axis) for res in results] + if np.isscalar(split): + split_indices = [i * split + 1 for i in range(dim_size) if i * split + 1 < dim_size] # type: ignore + else: + split_indices = np.cumsum(split) + 1 + return np.array_split(tensor, split_indices, axis) # type: ignore + + +def ConcatFromSequenceImpl( + sequence: List[np.ndarray], axis: int, new_axis: Optional[int] = 0 +) -> np.ndarray: + if not new_axis: + return np.concatenate(sequence, axis) + else: + return np.stack(sequence, axis) + + +class Sequence(Base): + @staticmethod + def export() -> None: + def make_graph( + nodes: List[onnx.helper.NodeProto], + input_shapes: List[Optional[typing.Sequence[Union[str, int]]]], + output_shapes: List[Optional[typing.Sequence[Union[str, int]]]], + input_names: List[str], + output_names: List[str], + input_types: List[TensorProto.DataType], + output_types: List[TensorProto.DataType], + initializers: Optional[List[TensorProto]] = None, + ) -> onnx.helper.GraphProto: + graph = onnx.helper.make_graph( + nodes=nodes, + name="Sequence", + inputs=[ + onnx.helper.make_tensor_value_info(name, input_type, input_shape) + for name, input_type, input_shape in zip( + input_names, input_types, input_shapes + ) + ], + outputs=[ + onnx.helper.make_tensor_value_info(name, output_type, output_shape) + for name, output_type, output_shape in zip( + output_names, output_types, output_shapes + ) + ], + initializer=initializers, + ) + return graph + + # 1st testcase - insert and at. + # 1. SequenceEmpty: -> [] + # 2. SequenceInsert(x): -> [x] + # 3. SequenceInsert(y): -> [x, y] + # 4. SequenceInsert(z, 1): -> [x, z, y] + # 5. SequenceAt(2): -> y + seq_empty_node = onnx.helper.make_node("SequenceEmpty", [], ["Seq_empty"]) + seq_insert_node = onnx.helper.make_node( + "SequenceInsert", ["Seq_empty", "X"], ["Seq_1"] + ) + seq_insert_node2 = onnx.helper.make_node( + "SequenceInsert", ["Seq_1", "Y"], ["Seq_2"] + ) + seq_insert_node3 = onnx.helper.make_node( + "SequenceInsert", ["Seq_2", "Z", "pos"], ["Seq_3"] + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["Seq_3", "pos_at"], ["out"]) + + x_shape = [2, 3, 4] + y_shape = [1, 3, 4] + z_shape = [3, 3, 4] + out_shape = [None, 3, 4] + + x = np.ones(x_shape, dtype=np.float32) + y = np.zeros(y_shape, dtype=np.float32) + z = np.ones(z_shape, dtype=np.float32) * 2 + pos_val = 1 + pos_at_val = 2 + + out = SequenceEmptyImpl() + out = SequenceInsertImpl(out, x) + out = SequenceInsertImpl(out, y) + out = SequenceInsertImpl(out, z, pos_val) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, y) + + pos = onnx.helper.make_tensor("pos", TensorProto.INT64, (), (pos_val,)) + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [ + seq_empty_node, + seq_insert_node, + seq_insert_node2, + seq_insert_node3, + seq_at_node, + ], + [x_shape, y_shape, z_shape, [], []], # type: ignore + [out_shape], # type: ignore + ["X", "Y", "Z", "pos", "pos_at"], + ["out"], + [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 2, # type: ignore + [onnx.TensorProto.FLOAT], + [pos, pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model1") + + # 2nd testcase - erase and at. + # 1. SequenceConstruct(x, y, z): -> [x, y, z] + # 2. SequenceErase(1): -> [x, z] + # 3. SequenceAt(1): -> z + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_erase_node = onnx.helper.make_node( + "SequenceErase", ["seq_1", "pos_erase"], ["seq_2"] + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_2", "pos_at"], ["out"]) + + tensor_shape = [2, 3, 4] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + pos_erase_val = 1 + pos_at_val = 1 + + out = SequenceConstructImpl(x, y, z) + out = SequenceEraseImpl(out, pos_erase_val) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, z) + + pos_erase = onnx.helper.make_tensor( + "pos_erase", TensorProto.INT64, (), (pos_erase_val,) + ) + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [seq_construct_node, seq_erase_node, seq_at_node], + [tensor_shape, tensor_shape, tensor_shape, [], []], # type: ignore + [tensor_shape], # type: ignore + ["X", "Y", "Z", "pos_erase", "pos_at"], + ["out"], + [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 2, # type: ignore + [onnx.TensorProto.FLOAT], + [pos_erase, pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model2") + + # 3rd testcase - erase, insert and at, with negative index value. + # 1. SequenceConstruct(x, y, z): -> [x, y, z] + # 2. SequenceErase(-3): -> [y, z] + # 3. SequenceInsert(x, -1): -> [y, x, z] + # 4. SequenceAt(-1): -> z + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_erase_node = onnx.helper.make_node( + "SequenceErase", ["seq_1", "pos_erase"], ["seq_2"] + ) + seq_insert_node = onnx.helper.make_node( + "SequenceInsert", ["seq_2", "X", "pos_insert"], ["seq_3"] + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_3", "pos_at"], ["out"]) + + tensor_shape = [2, 3, 4] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + pos_erase_val = -3 + pos_insert_val = -1 + pos_at_val = -1 + out = SequenceConstructImpl(x, y, z) + out = SequenceEraseImpl(out, pos_erase_val) + out = SequenceInsertImpl(out, x, pos_insert_val) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, z) + + pos_erase = onnx.helper.make_tensor( + "pos_erase", TensorProto.INT64, (), (pos_erase_val,) + ) + pos_insert = onnx.helper.make_tensor( + "pos_insert", TensorProto.INT64, (), (pos_insert_val,) + ) + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [seq_construct_node, seq_erase_node, seq_insert_node, seq_at_node], + [tensor_shape, tensor_shape, tensor_shape, [], [], []], # type: ignore + [tensor_shape], # type: ignore + ["X", "Y", "Z", "pos_erase", "pos_insert", "pos_at"], + ["out"], + [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 3, # type: ignore + [onnx.TensorProto.FLOAT], + [pos_erase, pos_insert, pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model3") + + # 4th testcase - concat + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_concat_node = onnx.helper.make_node( + "ConcatFromSequence", ["seq_1"], ["out"], axis=1 + ) + + tensor_shape = [2, 3, 4] + concat_out_shape = [2, None, 4] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + out = SequenceConstructImpl(x, y, z) + concat_out = ConcatFromSequenceImpl(out, 1) + + graph = make_graph( + [seq_construct_node, seq_concat_node], + [tensor_shape] * 3, # type: ignore + [concat_out_shape], # type: ignore + ["X", "Y", "Z"], + ["out"], + [onnx.TensorProto.FLOAT] * 3, # type: ignore + [onnx.TensorProto.FLOAT], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect( + model, inputs=[x, y, z], outputs=[concat_out], name="test_sequence_model4" + ) + + # 5th testcase - concat with new_axis = 1 + seq_construct_node = onnx.helper.make_node( + "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"] + ) + seq_concat_node = onnx.helper.make_node( + "ConcatFromSequence", ["seq_1"], ["out"], axis=-1, new_axis=1 + ) + + tensor_shape = [2, 3, 4] + concat_out_shape = [2, 3, 4, 3] + + x = np.ones(tensor_shape, dtype=np.float32) + y = np.zeros(tensor_shape, dtype=np.float32) + z = np.ones(tensor_shape, dtype=np.float32) * 2 + out = SequenceConstructImpl(x, y, z) + concat_out = ConcatFromSequenceImpl(out, -1, 1) + + graph = make_graph( + [seq_construct_node, seq_concat_node], + [tensor_shape] * 3, # type: ignore + [concat_out_shape], # type: ignore + ["X", "Y", "Z"], + ["out"], + [onnx.TensorProto.FLOAT] * 3, # type: ignore + [onnx.TensorProto.FLOAT], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect( + model, inputs=[x, y, z], outputs=[concat_out], name="test_sequence_model5" + ) + + # 6th testcase - split and len + seq_split_node = onnx.helper.make_node( + "SplitToSequence", ["X"], ["seq_1"], axis=-1 + ) + seq_len_node = onnx.helper.make_node("SequenceLength", ["seq_1"], ["len"]) + + tensor_shape = [2, 3, 4] + len_shape = [] # type: ignore + + x = np.ones(tensor_shape, dtype=np.float32) + out = SplitToSequenceImpl(x, axis=-1) + out = SequenceLengthImpl(out) + assert np.array_equal(out, np.int64(4)) + + graph = onnx.helper.make_graph( + nodes=[seq_split_node, seq_len_node], + name="Sequence", + inputs=[ + onnx.helper.make_tensor_value_info( + "X", onnx.TensorProto.FLOAT, tensor_shape + ) + ], + outputs=[ + onnx.helper.make_tensor_value_info( + "len", onnx.TensorProto.INT64, len_shape + ) + ], + ) # type: ignore + + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x], outputs=[out], name="test_sequence_model6") + + # 7th testcase - split with keepdims=0, and SequenceAt + seq_split_node = onnx.helper.make_node( + "SplitToSequence", ["X"], ["seq_1"], axis=0, keepdims=0 + ) + seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_1", "pos_at"], ["out"]) + + tensor_shape = [2, 3, 4] + out_shape = [3, 4] + + x = np.random.rand(*tensor_shape) + pos_at_val = 1 + out = SplitToSequenceImpl(x, axis=0, keepdims=0) + out = SequenceAtImpl(out, pos_at_val) + assert np.array_equal(out, x[pos_at_val]) + + pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,)) + + graph = make_graph( + [seq_split_node, seq_at_node], + [tensor_shape, []], # type: ignore + [out_shape], # type: ignore + ["X", "pos_at"], + ["out"], + [onnx.TensorProto.DOUBLE, onnx.TensorProto.INT64], + [onnx.TensorProto.DOUBLE], + [pos_at], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect(model, inputs=[x], outputs=[out], name="test_sequence_model7") + + # 8th testcase - split zero length + seq_split_node = onnx.helper.make_node( + "SplitToSequence", ["X", "Splits"], ["seq_1"] + ) + seq_len_node = onnx.helper.make_node("SequenceLength", ["seq_1"], ["len"]) + + tensor_shape = ["n"] # type: ignore + splits_shape = [3] # type: ignore + + x = np.array([]).astype(np.float32) + splits = np.array([0, 0, 0]).astype(np.int64) + out_len = np.int64(3) + + graph = onnx.helper.make_graph( + nodes=[seq_split_node, seq_len_node], + name="Sequence", + inputs=[ + onnx.helper.make_tensor_value_info( + "X", onnx.TensorProto.FLOAT, tensor_shape + ), # type: ignore + onnx.helper.make_tensor_value_info( + "Splits", onnx.TensorProto.INT64, splits_shape + ), + ], # type: ignore + outputs=[ + onnx.helper.make_tensor_value_info( + "len", onnx.TensorProto.INT64, len_shape + ) + ], + ) # type: ignore + + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 12)], + ) + expect( + model, inputs=[x, splits], outputs=[out_len], name="test_sequence_model8" + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/shrink.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/shrink.py new file mode 100644 index 0000000000000000000000000000000000000000..2b8016c62e0ce568c921623c40de4e8c3621542f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/shrink.py @@ -0,0 +1,41 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class ShrinkTest(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Shrink", + ["x"], + ["y"], + lambd=1.5, + bias=1.5, + ) + graph = onnx.helper.make_graph( + nodes=[node], + name="Shrink", + inputs=[ + onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [5]) + ], + outputs=[ + onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [5]) + ], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + + x = np.array([-2.0, -1.0, 0.0, 1.0, 2.0], dtype=np.float32) + y = np.array([-0.5, 0.0, 0.0, 0.0, 0.5], dtype=np.float32) + + expect(model, inputs=[x], outputs=[y], name="test_shrink") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/sign.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/sign.py new file mode 100644 index 0000000000000000000000000000000000000000..fcdb25df23a733a41b48812dc574d1dac325c44e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/sign.py @@ -0,0 +1,35 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class SingleSign(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Sign", ["x"], ["y"], name="test") + + x = np.array([-1.0, 4.5, -4.5, 3.1, 0.0, 2.4, -5.5]).astype(np.float32) + y = np.array([-1.0, 1.0, -1.0, 1.0, 0.0, 1.0, -1.0]).astype(np.float32) + + graph = onnx.helper.make_graph( + nodes=[node], + name="SingleSign", + inputs=[ + onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [7]) + ], + outputs=[ + onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [7]) + ], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + expect(model, inputs=[x], outputs=[y], name="test_sign_model") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/single-relu.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/single-relu.py new file mode 100644 index 0000000000000000000000000000000000000000..46dde75342d10cdfe9baa34780ddcaf9f0351d23 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/single-relu.py @@ -0,0 +1,35 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class SingleRelu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Relu", ["x"], ["y"], name="test") + graph = onnx.helper.make_graph( + nodes=[node], + name="SingleRelu", + inputs=[ + onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [1, 2]) + ], + outputs=[ + onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [1, 2]) + ], + ) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 9)], + ) + + x = np.random.randn(1, 2).astype(np.float32) + y = np.maximum(x, 0) + + expect(model, inputs=[x], outputs=[y], name="test_single_relu_model") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/model/stringnormalizer.py b/runtime/Lib/site-packages/onnx/backend/test/case/model/stringnormalizer.py new file mode 100644 index 0000000000000000000000000000000000000000..b58656e128e7f6f0062ee745f181f2a3a314eb7c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/model/stringnormalizer.py @@ -0,0 +1,203 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + + +from typing import Sequence + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.model import expect + + +class NormalizeStrings(Base): + @staticmethod + def export() -> None: + def make_graph( + node: onnx.helper.NodeProto, + input_shape: Sequence[int], + output_shape: Sequence[int], + ) -> onnx.helper.GraphProto: + graph = onnx.helper.make_graph( + nodes=[node], + name="StringNormalizer", + inputs=[ + onnx.helper.make_tensor_value_info( + "x", onnx.TensorProto.STRING, input_shape + ) + ], + outputs=[ + onnx.helper.make_tensor_value_info( + "y", onnx.TensorProto.STRING, output_shape + ) + ], + ) + return graph + + # 1st model_monday_casesensintive_nochangecase + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + is_case_sensitive=1, + stopwords=stopwords, + ) + + x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + y = np.array(["tuesday", "wednesday", "thursday"]).astype(object) + + graph = make_graph(node, [4], [3]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_casesensintive_nochangecase", + ) + + # 2nd model_nostopwords_nochangecase + node = onnx.helper.make_node( + "StringNormalizer", inputs=["x"], outputs=["y"], is_case_sensitive=1 + ) + + x = np.array(["monday", "tuesday"]).astype(object) + y = x + + graph = make_graph(node, [2], [2]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_nostopwords_nochangecase", + ) + + # 3rd model_monday_casesensintive_lower + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="LOWER", + is_case_sensitive=1, + stopwords=stopwords, + ) + + x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + y = np.array(["tuesday", "wednesday", "thursday"]).astype(object) + + graph = make_graph(node, [4], [3]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_casesensintive_lower", + ) + + # 4 model_monday_casesensintive_upper + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + is_case_sensitive=1, + stopwords=stopwords, + ) + + x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object) + y = np.array(["TUESDAY", "WEDNESDAY", "THURSDAY"]).astype(object) + + graph = make_graph(node, [4], [3]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_casesensintive_upper", + ) + + # 5 monday_insensintive_upper_twodim + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + stopwords=stopwords, + ) + + input_shape = [1, 6] + output_shape = [1, 4] + x = ( + np.array( + ["Monday", "tuesday", "wednesday", "Monday", "tuesday", "wednesday"] + ) + .astype(object) + .reshape(input_shape) + ) + y = ( + np.array(["TUESDAY", "WEDNESDAY", "TUESDAY", "WEDNESDAY"]) + .astype(object) + .reshape(output_shape) + ) + + graph = make_graph(node, input_shape, output_shape) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_insensintive_upper_twodim", + ) + + # 6 monday_empty_output + stopwords = ["monday"] + node = onnx.helper.make_node( + "StringNormalizer", + inputs=["x"], + outputs=["y"], + case_change_action="UPPER", + is_case_sensitive=0, + stopwords=stopwords, + ) + + x = np.array(["monday", "monday"]).astype(object) + y = np.array([""]).astype(object) + + graph = make_graph(node, [2], [1]) + model = onnx.helper.make_model_gen_version( + graph, + producer_name="backend-test", + opset_imports=[onnx.helper.make_opsetid("", 10)], + ) + expect( + model, + inputs=[x], + outputs=[y], + name="test_strnorm_model_monday_empty_output", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/abs.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/abs.py new file mode 100644 index 0000000000000000000000000000000000000000..3b5f80877862ec34b7206adf017af721c27d0467 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/abs.py @@ -0,0 +1,24 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.sample.ops.abs import abs +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Abs(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Abs", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = abs(x) + + expect(node, inputs=[x], outputs=[y], name="test_abs") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/acos.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/acos.py new file mode 100644 index 0000000000000000000000000000000000000000..31232c592be6e1a4eb76a25f4da685ca967ce354 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/acos.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Acos(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Acos", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-0.5, 0, 0.5]).astype(np.float32) + y = np.arccos(x) + expect(node, inputs=[x], outputs=[y], name="test_acos_example") + + x = np.random.rand(3, 4, 5).astype(np.float32) + y = np.arccos(x) + expect(node, inputs=[x], outputs=[y], name="test_acos") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/acosh.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/acosh.py new file mode 100644 index 0000000000000000000000000000000000000000..b0c0e2aa209d47e96541c93f71c1446b84fbb278 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/acosh.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Acosh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Acosh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([10, np.e, 1]).astype(np.float32) + y = np.arccosh(x) # expected output [2.99322295, 1.65745449, 0.] + expect(node, inputs=[x], outputs=[y], name="test_acosh_example") + + x = np.random.uniform(1.0, 10.0, (3, 4, 5)).astype(np.float32) + y = np.arccosh(x) + expect(node, inputs=[x], outputs=[y], name="test_acosh") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/adagrad.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/adagrad.py new file mode 100644 index 0000000000000000000000000000000000000000..05a203e3e7c0c4447858f2b4330096c256b45097 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/adagrad.py @@ -0,0 +1,115 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN + + +def apply_adagrad(r, t, x, g, h, norm_coefficient, epsilon, decay_factor): # type: ignore + # Compute adjusted learning-rate. + r_ = r / (1 + t * decay_factor) + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Update squared accumulated gradient. + h_new = h + g_regularized * g_regularized + # Compute ADAGRAD's gradient scaling factors + h_sqrt = np.sqrt(h_new) + epsilon + # Apply ADAGRAD update rule. + x_new = x - r_ * g_regularized / h_sqrt + return (x_new, h_new) + + +class Adagrad(Base): + @staticmethod + def export_adagrad() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + epsilon = 1e-5 + decay_factor = 0.1 + + # Create operator. + node = onnx.helper.make_node( + "Adagrad", + inputs=["R", "T", "X", "G", "H"], + outputs=["X_new", "H_new"], + norm_coefficient=norm_coefficient, + epsilon=epsilon, + decay_factor=decay_factor, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.0], dtype=np.float32) + g = np.array([-1.0], dtype=np.float32) + h = np.array([2.0], dtype=np.float32) + + # Compute expected outputs of Adagrad. + x_new, h_new = apply_adagrad( + r, t, x, g, h, norm_coefficient, epsilon, decay_factor + ) + + # Check results. + expect( + node, + inputs=[r, t, x, g, h], + outputs=[x_new, h_new], + name="test_adagrad", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_adagrad_multiple() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + epsilon = 1e-5 + decay_factor = 0.1 + + node = onnx.helper.make_node( + "Adagrad", + inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"], + outputs=["X1_new", "X2_new", "H1_new", "H2_new"], + norm_coefficient=norm_coefficient, + epsilon=epsilon, + decay_factor=decay_factor, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + + x1 = np.array([1.0], dtype=np.float32) + g1 = np.array([-1.0], dtype=np.float32) + h1 = np.array([2.0], dtype=np.float32) + + x2 = np.array([1.0, 2.0], dtype=np.float32) + g2 = np.array([-1.0, -3.0], dtype=np.float32) + h2 = np.array([4.0, 1.0], dtype=np.float32) + + # Compute expected outputs of Adagrad. + x1_new, h1_new = apply_adagrad( + r, t, x1, g1, h1, norm_coefficient, epsilon, decay_factor + ) + x2_new, h2_new = apply_adagrad( + r, t, x2, g2, h2, norm_coefficient, epsilon, decay_factor + ) + + # Check results. + expect( + node, + inputs=[r, t, x1, x2, g1, g2, h1, h2], + outputs=[x1_new, x2_new, h1_new, h2_new], + name="test_adagrad_multiple", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/adam.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/adam.py new file mode 100644 index 0000000000000000000000000000000000000000..cab3181219c57857e69cd71e9474a47e1eaede94 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/adam.py @@ -0,0 +1,131 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN + + +def apply_adam(r, t, x, g, v, h, norm_coefficient, norm_coefficient_post, alpha, beta, epsilon): # type: ignore + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Update momentum. + v_new = alpha * v + (1 - alpha) * g_regularized + # Update second-order momentum. + h_new = beta * h + (1 - beta) * (g_regularized * g_regularized) + # Compute element-wise square root. + h_sqrt = np.sqrt(h_new) + epsilon + # Adjust learning rate. + r_adjusted = None + if t > 0: + # Consider bias correction on momentums. + r_adjusted = r * np.sqrt(1 - beta**t) / (1 - alpha**t) + else: + # No bias correction on momentums. + r_adjusted = r + # Apply Adam update rule. + x_new = x - r_adjusted * (v_new / h_sqrt) + # It's possible to apply regularization in the end. + x_final = (1 - norm_coefficient_post) * x_new + return x_final, v_new, h_new + + +class Adam(Base): + @staticmethod + def export_adam() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.1 + epsilon = 1e-7 + + # Create operator. + node = onnx.helper.make_node( + "Adam", + inputs=["R", "T", "X", "G", "V", "H"], + outputs=["X_new", "V_new", "H_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + epsilon=epsilon, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.2, 2.8], dtype=np.float32) + g = np.array([-0.94, -2.5], dtype=np.float32) + v = np.array([1.7, 3.6], dtype=np.float32) + h = np.array([0.1, 0.1], dtype=np.float32) + + # Compute expected outputs of Adam. + x_new, v_new, h_new = apply_adam( + r, t, x, g, v, h, norm_coefficient, 0.0, alpha, beta, epsilon + ) + + # Check results. + expect( + node, + inputs=[r, t, x, g, v, h], + outputs=[x_new, v_new, h_new], + name="test_adam", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_adam_multiple() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.85 + epsilon = 1e-2 + + node = onnx.helper.make_node( + "Adam", + inputs=["R", "T", "X1", "X2", "G1", "G2", "V1", "V2", "H1", "H2"], + outputs=["X1_new", "X2_new", "V1_new", "V2_new", "H1_new", "H2_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + + x1 = np.array([1.0], dtype=np.float32) + g1 = np.array([-1.0], dtype=np.float32) + v1 = np.array([2.0], dtype=np.float32) + h1 = np.array([0.5], dtype=np.float32) + + x2 = np.array([1.0, 2.0], dtype=np.float32) + g2 = np.array([-1.0, -3.0], dtype=np.float32) + v2 = np.array([4.0, 1.0], dtype=np.float32) + h2 = np.array([1.0, 10.0], dtype=np.float32) + + # Compute expected outputs of Adam. + x1_new, v1_new, h1_new = apply_adam( + r, t, x1, g1, v1, h1, norm_coefficient, 0.0, alpha, beta, epsilon + ) + x2_new, v2_new, h2_new = apply_adam( + r, t, x2, g2, v2, h2, norm_coefficient, 0.0, alpha, beta, epsilon + ) + + # Check results. + expect( + node, + inputs=[r, t, x1, x2, g1, g2, v1, v2, h1, h2], + outputs=[x1_new, x2_new, v1_new, v2_new, h1_new, h2_new], + name="test_adam_multiple", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/add.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/add.py new file mode 100644 index 0000000000000000000000000000000000000000..fce9f17b17d1f6743157678c037d1e3d191c5f86 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/add.py @@ -0,0 +1,47 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Add(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Add", + inputs=["x", "y"], + outputs=["sum"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add") + + @staticmethod + def export_add_uint8() -> None: + node = onnx.helper.make_node( + "Add", + inputs=["x", "y"], + outputs=["sum"], + ) + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint8") + + @staticmethod + def export_add_broadcast() -> None: + node = onnx.helper.make_node( + "Add", + inputs=["x", "y"], + outputs=["sum"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + expect(node, inputs=[x, y], outputs=[x + y], name="test_add_bcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/__init__.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py new file mode 100644 index 0000000000000000000000000000000000000000..ce08e074581804ed65fd22a7033fa6d5cbc14218 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py @@ -0,0 +1,30 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ArrayFeatureExtractor(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "ArrayFeatureExtractor", + inputs=["x", "y"], + outputs=["z"], + domain="ai.onnx.ml", + ) + + x = np.arange(12).reshape((3, 4)).astype(np.float32) + y = np.array([0, 1], dtype=np.int64) + z = np.array([[0, 4, 8], [1, 5, 9]], dtype=np.float32).T + expect( + node, + inputs=[x, y], + outputs=[z], + name="test_ai_onnx_ml_array_feature_extractor", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py new file mode 100644 index 0000000000000000000000000000000000000000..2c8ae4f1f1b6357e6e3f3b618cb49d6ac2a9cb26 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.reference.ops.aionnxml.op_binarizer import compute_binarizer + + +class Binarizer(Base): + @staticmethod + def export() -> None: + threshold = 1.0 + node = onnx.helper.make_node( + "Binarizer", + inputs=["X"], + outputs=["Y"], + threshold=threshold, + domain="ai.onnx.ml", + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = compute_binarizer(x, threshold)[0] + + expect(node, inputs=[x], outputs=[y], name="test_ai_onnx_ml_binarizer") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/and.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/and.py new file mode 100644 index 0000000000000000000000000000000000000000..54527953457e9f2950dd551debf2a5a7edb4ffe4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/and.py @@ -0,0 +1,75 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class And(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "And", + inputs=["x", "y"], + outputs=["and"], + ) + + # 2d + x = (np.random.randn(3, 4) > 0).astype(bool) + y = (np.random.randn(3, 4) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and2d") + + # 3d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(3, 4, 5) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and3d") + + # 4d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and4d") + + @staticmethod + def export_and_broadcast() -> None: + node = onnx.helper.make_node( + "And", + inputs=["x", "y"], + outputs=["and"], + ) + + # 3d vs 1d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(5) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v1d") + + # 3d vs 2d + x = (np.random.randn(3, 4, 5) > 0).astype(bool) + y = (np.random.randn(4, 5) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v2d") + + # 4d vs 2d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v2d") + + # 4d vs 3d + x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool) + y = (np.random.randn(4, 5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v3d") + + # 4d vs 4d + x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool) + y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool) + z = np.logical_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v4d") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/argmax.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/argmax.py new file mode 100644 index 0000000000000000000000000000000000000000..dd9c69da2548e56240e19df35087b5f4f0e6087f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/argmax.py @@ -0,0 +1,255 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def argmax_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1) -> np.ndarray: + result = np.argmax(data, axis=axis) + if keepdims == 1: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +def argmax_use_numpy_select_last_index( + data: np.ndarray, axis: int = 0, keepdims: int = True +) -> np.ndarray: + data = np.flip(data, axis) + result = np.argmax(data, axis=axis) + result = data.shape[axis] - result - 1 + if keepdims: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +class ArgMax(Base): + @staticmethod + def export_no_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # result: [0, 1] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_no_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmax_no_keepdims_random" + ) + + @staticmethod + def export_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # result: [[0], [1]] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmax_keepdims_example" + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmax_keepdims_random" + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], keepdims=keepdims + ) + + # result: [[1, 1]] + result = argmax_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmax_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_random", + ) + + @staticmethod + def export_negative_axis_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # result: [[0], [1]] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmax_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_random", + ) + + @staticmethod + def export_no_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [1, 1] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_no_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_no_keepdims_random_select_last_index", + ) + + @staticmethod + def export_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [1]] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_keepdims_random_select_last_index", + ) + + @staticmethod + def export_default_axes_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + keepdims=keepdims, + select_last_index=True, + ) + + # result: [[1, 1]] + result = argmax_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmax_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_default_axis_random_select_last_index", + ) + + @staticmethod + def export_negative_axis_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMax", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [1]] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmax_negative_axis_keepdims_random_select_last_index", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/argmin.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/argmin.py new file mode 100644 index 0000000000000000000000000000000000000000..385f19d36ba9aa7f98a1c5a0aa24fb55c24d1d12 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/argmin.py @@ -0,0 +1,255 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def argmin_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1) -> np.ndarray: + result = np.argmin(data, axis=axis) + if keepdims == 1: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +def argmin_use_numpy_select_last_index( + data: np.ndarray, axis: int = 0, keepdims: int = True +) -> np.ndarray: + data = np.flip(data, axis) + result = np.argmin(data, axis=axis) + result = data.shape[axis] - result - 1 + if keepdims: + result = np.expand_dims(result, axis) + return result.astype(np.int64) + + +class ArgMin(Base): + @staticmethod + def export_no_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # The content of result is : [[1, 0]] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_no_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmin_no_keepdims_random" + ) + + @staticmethod + def export_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # The content of result is : [[1], [0]] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmin_keepdims_example" + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, inputs=[data], outputs=[result], name="test_argmin_keepdims_random" + ) + + @staticmethod + def export_default_axes_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], keepdims=keepdims + ) + + # The content of result is : [[0], [0]] + result = argmin_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmin_use_numpy(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_random", + ) + + @staticmethod + def export_negative_axis_keepdims() -> None: + data = np.array([[2, 1], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims + ) + # The content of result is : [[1], [0]] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_example", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmin_use_numpy(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_random", + ) + + @staticmethod + def export_no_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 0 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1, 0]] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_no_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 4] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_no_keepdims_random_select_last_index", + ) + + @staticmethod + def export_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = 1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [0]] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 1, 4] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_keepdims_random_select_last_index", + ) + + @staticmethod + def export_default_axes_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + keepdims=keepdims, + select_last_index=True, + ) + + # result: [[0, 0]] + result = argmin_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [1, 3, 4] + result = argmin_use_numpy_select_last_index(data, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_default_axis_random_select_last_index", + ) + + @staticmethod + def export_negative_axis_keepdims_select_last_index() -> None: + data = np.array([[2, 2], [3, 10]], dtype=np.float32) + axis = -1 + keepdims = 1 + node = onnx.helper.make_node( + "ArgMin", + inputs=["data"], + outputs=["result"], + axis=axis, + keepdims=keepdims, + select_last_index=True, + ) + # result: [[1], [0]] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_example_select_last_index", + ) + + data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32) + # result's shape: [2, 3, 1] + result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims) + expect( + node, + inputs=[data], + outputs=[result], + name="test_argmin_negative_axis_keepdims_random_select_last_index", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/asin.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/asin.py new file mode 100644 index 0000000000000000000000000000000000000000..e648b483efa56b8f8ae5b21052c64ed95256e6c9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/asin.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Asin(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Asin", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-0.5, 0, 0.5]).astype(np.float32) + y = np.arcsin(x) + expect(node, inputs=[x], outputs=[y], name="test_asin_example") + + x = np.random.rand(3, 4, 5).astype(np.float32) + y = np.arcsin(x) + expect(node, inputs=[x], outputs=[y], name="test_asin") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/asinh.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/asinh.py new file mode 100644 index 0000000000000000000000000000000000000000..8ef9f9020fda74c22789293f909f87c545908779 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/asinh.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Asinh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Asinh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.arcsinh(x) # expected output [-0.88137358, 0., 0.88137358] + expect(node, inputs=[x], outputs=[y], name="test_asinh_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.arcsinh(x) + expect(node, inputs=[x], outputs=[y], name="test_asinh") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/atan.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/atan.py new file mode 100644 index 0000000000000000000000000000000000000000..c66822369d2c9b8fd3519d6dd2c64998f28676e7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/atan.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Atan(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Atan", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.arctan(x) + expect(node, inputs=[x], outputs=[y], name="test_atan_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.arctan(x) + expect(node, inputs=[x], outputs=[y], name="test_atan") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/atanh.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/atanh.py new file mode 100644 index 0000000000000000000000000000000000000000..3e2ca827b11b9a6ad54a4b1ce698bb8814ef5a0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/atanh.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Atanh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Atanh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-0.5, 0, 0.5]).astype(np.float32) + y = np.arctanh(x) # expected output [-0.54930615, 0., 0.54930615] + expect(node, inputs=[x], outputs=[y], name="test_atanh_example") + + x = np.random.uniform(0.0, 1.0, (3, 4, 5)).astype(np.float32) + y = np.arctanh(x) + expect(node, inputs=[x], outputs=[y], name="test_atanh") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/averagepool.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/averagepool.py new file mode 100644 index 0000000000000000000000000000000000000000..42e6d35d2a6c0826b683776610f61f977f9a4a77 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/averagepool.py @@ -0,0 +1,496 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.backend.test.case.node.pool_op_common import ( + get_output_shape, + get_pad_shape, + pool, +) + + +class AveragePool(Base): + @staticmethod + def export_averagepool_2d_precomputed_pads() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [7, 7.5, 8, 8.5, 9], + [9.5, 10, 10.5, 11, 11.5], + [12, 12.5, 13, 13.5, 14], + [14.5, 15, 15.5, 16, 16.5], + [17, 17.5, 18, 18.5, 19], + ] + ] + ] + ).astype(np.float32) + + expect( + node, inputs=[x], outputs=[y], name="test_averagepool_2d_precomputed_pads" + ) + + @staticmethod + def export_averagepool_2d_precomputed_pads_count_include_pad() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + count_include_pad=1, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [2.5200, 3.6000, 4.8000, 4.0800, 3.2400], + [4.5600, 6.4000, 8.4000, 7.0400, 5.5200], + [7.2000, 10.0000, 13.0000, 10.8000, 8.4000], + [6.9600, 9.6000, 12.4000, 10.2400, 7.9200], + [6.1200, 8.4000, 10.8000, 8.8800, 6.8400], + ] + ] + ] + ).astype(np.float32) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_precomputed_pads_count_include_pad", + ) + + @staticmethod + def export_averagepool_2d_precomputed_strides() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[4, 6], [14, 16]]]]).astype(np.float32) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_precomputed_strides", + ) + + @staticmethod + def export_averagepool_2d_precomputed_same_upper() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 3, 3] + pad_shape: [2, 2] -> [1, 1, 1, 1] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[4, 5.5, 7], [11.5, 13, 14.5], [19, 20.5, 22]]]]).astype( + np.float32 + ) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_precomputed_same_upper", + ) + + @staticmethod + def export_averagepool_1d_default() -> None: + """ + input_shape: [1, 3, 32] + output_shape: [1, 3, 31] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2], + ) + x = np.random.randn(1, 3, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = [2] + strides = [1] + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, [0], "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_1d_default") + + @staticmethod + def export_averagepool_2d_default() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 31, 31] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_default") + + @staticmethod + def export_averagepool_3d_default() -> None: + """ + input_shape: [1, 3, 32, 32, 32] + output_shape: [1, 3, 31, 31, 31] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + ) + x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = [2, 2, 2] + strides = [1, 1, 1] + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, [0, 0, 0], "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_3d_default") + + @staticmethod + def export_averagepool_2d_same_upper() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [0, 1, 0, 1] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("SAME_UPPER", x_shape[2:], kernel_shape, strides) + pad_shape = get_pad_shape( + "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_top = pad_shape[0] // 2 + pad_bottom = pad_shape[0] - pad_top + pad_left = pad_shape[1] // 2 + pad_right = pad_shape[1] - pad_left + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + y = pool(padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_upper") + + @staticmethod + def export_averagepool_2d_same_lower() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [1, 0, 1, 0] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_LOWER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("SAME_LOWER", x_shape[2:], kernel_shape, strides) + pad_shape = get_pad_shape( + "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_bottom = pad_shape[0] // 2 + pad_top = pad_shape[0] - pad_bottom + pad_right = pad_shape[1] // 2 + pad_left = pad_shape[1] - pad_right + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + y = pool(padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_lower") + + @staticmethod + def export_averagepool_2d_pads() -> None: + """ + input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = 2 + pad_top = 2 + pad_right = 2 + pad_left = 2 + pad_shape = [pad_top + pad_bottom, pad_left + pad_right] + out_shape = get_output_shape( + "VALID", np.add(x_shape[2:], pad_shape), kernel_shape, strides + ) + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + y = pool(padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_pads") + + @staticmethod + def export_averagepool_2d_pads_count_include_pad() -> None: + """ + input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + count_include_pad=1, + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = 2 + pad_top = 2 + pad_right = 2 + pad_left = 2 + pad_shape = [pad_top + pad_bottom, pad_left + pad_right] + out_shape = get_output_shape( + "VALID", np.add(x_shape[2:], pad_shape), kernel_shape, strides + ) + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=0, + ) + y = pool( + padded, + x_shape, + kernel_shape, + strides, + out_shape, + pad_shape, + "AVG", + count_include_pad=1, + ) + + expect( + node, + inputs=[x], + outputs=[y], + name="test_averagepool_2d_pads_count_include_pad", + ) + + @staticmethod + def export_averagepool_2d_strides() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 10, 10] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + strides=[3, 3], + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (5, 5) + strides = (3, 3) + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "AVG") + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_strides") + + @staticmethod + def export_averagepool_2d_ceil() -> None: + """ + input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + ceil_mode=True, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[6, 7.5], [12, 13.5]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_ceil") + + @staticmethod + def export_averagepool_2d_dilations() -> None: + """ + input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "AveragePool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[1, 1], + dilations=[2, 2], + ceil_mode=True, + ) + + # input shape: [1, 1, 4, 4] + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + + y = np.array([[[[6, 7], [10, 11]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_dilations") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/batchnorm.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/batchnorm.py new file mode 100644 index 0000000000000000000000000000000000000000..439ece136fd526b3b2484cacc9024c53211da013 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/batchnorm.py @@ -0,0 +1,136 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def _batchnorm_test_mode(x, s, bias, mean, var, epsilon=1e-5): # type: ignore + dims_x = len(x.shape) + dim_ones = (1,) * (dims_x - 2) + s = s.reshape(-1, *dim_ones) + bias = bias.reshape(-1, *dim_ones) + mean = mean.reshape(-1, *dim_ones) + var = var.reshape(-1, *dim_ones) + return s * (x - mean) / np.sqrt(var + epsilon) + bias + + +def _batchnorm_training_mode(x, s, bias, mean, var, momentum=0.9, epsilon=1e-5): # type: ignore + axis = tuple(np.delete(np.arange(len(x.shape)), 1)) + saved_mean = x.mean(axis=axis) + saved_var = x.var(axis=axis) + output_mean = mean * momentum + saved_mean * (1 - momentum) + output_var = var * momentum + saved_var * (1 - momentum) + y = _batchnorm_test_mode(x, s, bias, saved_mean, saved_var, epsilon=epsilon) + return y.astype(np.float32), output_mean, output_var + + +class BatchNormalization(Base): + @staticmethod + def export() -> None: + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + y = _batchnorm_test_mode(x, s, bias, mean, var).astype(np.float32) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y"], + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y], + name="test_batchnorm_example", + ) + + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + epsilon = 1e-2 + y = _batchnorm_test_mode(x, s, bias, mean, var, epsilon).astype(np.float32) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y"], + epsilon=epsilon, + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y], + name="test_batchnorm_epsilon", + ) + + @staticmethod + def export_train() -> None: + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + # using np.bool(1) while generating test data with "'bool' object has no attribute 'dtype'" + # working around by using np.byte(1).astype(bool) + training_mode = 1 + y, output_mean, output_var = _batchnorm_training_mode(x, s, bias, mean, var) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y", "output_mean", "output_var"], + training_mode=training_mode, + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y, output_mean, output_var], + name="test_batchnorm_example_training_mode", + ) + + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + mean = np.random.randn(3).astype(np.float32) + var = np.random.rand(3).astype(np.float32) + training_mode = 1 + momentum = 0.9 + epsilon = 1e-2 + y, output_mean, output_var = _batchnorm_training_mode( + x, s, bias, mean, var, momentum, epsilon + ) + + node = onnx.helper.make_node( + "BatchNormalization", + inputs=["x", "s", "bias", "mean", "var"], + outputs=["y", "output_mean", "output_var"], + epsilon=epsilon, + training_mode=training_mode, + ) + + # output size: (2, 3, 4, 5) + expect( + node, + inputs=[x, s, bias, mean, var], + outputs=[y, output_mean, output_var], + name="test_batchnorm_epsilon_training_mode", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/bernoulli.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/bernoulli.py new file mode 100644 index 0000000000000000000000000000000000000000..e54094c2d76689ed70ab4c749148fe5d9faed80d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/bernoulli.py @@ -0,0 +1,58 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def bernoulli_reference_implementation(x, dtype): # type: ignore + # binomial n = 1 equal bernoulli + # This example and test-case is for informational purpose. The generator operator is + # non-deterministic and may not produce the same values in different implementations + # even if a seed is specified. + return np.random.binomial(1, p=x).astype(dtype) + + +class Bernoulli(Base): + @staticmethod + def export_bernoulli_without_dtype() -> None: + node = onnx.helper.make_node( + "Bernoulli", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.uniform(0.0, 1.0, 10).astype(float) + y = bernoulli_reference_implementation(x, float) + expect(node, inputs=[x], outputs=[y], name="test_bernoulli") + + @staticmethod + def export_bernoulli_with_dtype() -> None: + node = onnx.helper.make_node( + "Bernoulli", + inputs=["x"], + outputs=["y"], + dtype=onnx.TensorProto.DOUBLE, + ) + + x = np.random.uniform(0.0, 1.0, 10).astype(np.float32) + y = bernoulli_reference_implementation(x, float) + expect(node, inputs=[x], outputs=[y], name="test_bernoulli_double") + + @staticmethod + def export_bernoulli_with_seed() -> None: + seed = float(0) + node = onnx.helper.make_node( + "Bernoulli", + inputs=["x"], + outputs=["y"], + seed=seed, + ) + + x = np.random.uniform(0.0, 1.0, 10).astype(np.float32) + y = bernoulli_reference_implementation(x, np.float32) + expect(node, inputs=[x], outputs=[y], name="test_bernoulli_seed") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/bitshift.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitshift.py new file mode 100644 index 0000000000000000000000000000000000000000..f2b4c976c510ab40150af322db2ba960bb79dbc9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitshift.py @@ -0,0 +1,99 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class BitShift(Base): + @staticmethod + def export_right_unit8() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint8) + y = np.array([1, 2, 3]).astype(np.uint8) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint8") + + @staticmethod + def export_right_unit16() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint16) + y = np.array([1, 2, 3]).astype(np.uint16) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint16") + + @staticmethod + def export_right_unit32() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint32) + y = np.array([1, 2, 3]).astype(np.uint32) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint32") + + @staticmethod + def export_right_unit64() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT" + ) + + x = np.array([16, 4, 1]).astype(np.uint64) + y = np.array([1, 2, 3]).astype(np.uint64) + z = x >> y # expected output [8, 1, 0] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint64") + + @staticmethod + def export_left_unit8() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint8) + y = np.array([1, 2, 3]).astype(np.uint8) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint8") + + @staticmethod + def export_left_unit16() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint16) + y = np.array([1, 2, 3]).astype(np.uint16) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint16") + + @staticmethod + def export_left_unit32() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint32) + y = np.array([1, 2, 3]).astype(np.uint32) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint32") + + @staticmethod + def export_left_unit64() -> None: + node = onnx.helper.make_node( + "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT" + ) + + x = np.array([16, 4, 1]).astype(np.uint64) + y = np.array([1, 2, 3]).astype(np.uint64) + z = x << y # expected output [32, 16, 8] + expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint64") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwiseand.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwiseand.py new file mode 100644 index 0000000000000000000000000000000000000000..ef6a1bb283f4572cc455489b0d29ba2df4571940 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwiseand.py @@ -0,0 +1,54 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np # type: ignore + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseAnd(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseAnd", + inputs=["x", "y"], + outputs=["bitwiseand"], + ) + + # 2d + x = create_random_int((3, 4), np.int32) + y = create_random_int((3, 4), np.int32) + z = np.bitwise_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i32_2d") + + # 3d + x = create_random_int((3, 4, 5), np.int16) + y = create_random_int((3, 4, 5), np.int16) + z = np.bitwise_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i16_3d") + + @staticmethod + def export_bitwiseand_broadcast() -> None: + node = onnx.helper.make_node( + "BitwiseAnd", + inputs=["x", "y"], + outputs=["bitwiseand"], + ) + + # 3d vs 1d + x = create_random_int((3, 4, 5), np.uint64) + y = create_random_int((5,), np.uint64) + z = np.bitwise_and(x, y) + expect( + node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui64_bcast_3v1d" + ) + + # 4d vs 3d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = create_random_int((4, 5, 6), np.uint8) + z = np.bitwise_and(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui8_bcast_4v3d") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwisenot.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwisenot.py new file mode 100644 index 0000000000000000000000000000000000000000..e20bfc14f72e76284c2d9175ca6a0d9da884d69c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwisenot.py @@ -0,0 +1,35 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np # type: ignore + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseNot(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseNot", + inputs=["x"], + outputs=["bitwise_not"], + ) + + # 2d + x = create_random_int((3, 4), np.int32) + y = np.bitwise_not(x) + expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_2d") + + # 3d + x = create_random_int((3, 4, 5), np.uint16) + y = np.bitwise_not(x) + expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_3d") + + # 4d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = np.bitwise_not(x) + expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_4d") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwiseor.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwiseor.py new file mode 100644 index 0000000000000000000000000000000000000000..55afc5420ecd44940853eb7f54b3079eddb6f3c4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwiseor.py @@ -0,0 +1,51 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np # type: ignore + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseOr(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseOr", + inputs=["x", "y"], + outputs=["bitwiseor"], + ) + # 2d + x = create_random_int((3, 4), np.int32) + y = create_random_int((3, 4), np.int32) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i32_2d") + + # 4d + x = create_random_int((3, 4, 5, 6), np.int8) + y = create_random_int((3, 4, 5, 6), np.int8) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i16_4d") + + @staticmethod + def export_bitwiseor_broadcast() -> None: + node = onnx.helper.make_node( + "BitwiseOr", + inputs=["x", "y"], + outputs=["bitwiseor"], + ) + + # 3d vs 1d + x = create_random_int((3, 4, 5), np.uint64) + y = create_random_int((5,), np.uint64) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui64_bcast_3v1d") + + # 4d vs 3d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = create_random_int((4, 5, 6), np.uint8) + z = np.bitwise_or(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui8_bcast_4v3d") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwisexor.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwisexor.py new file mode 100644 index 0000000000000000000000000000000000000000..84f9b239b3500d986fe27a58d7be382d99239d38 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/bitwisexor.py @@ -0,0 +1,54 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np # type: ignore + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.numpy_helper import create_random_int + + +class BitwiseXor(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "BitwiseXor", + inputs=["x", "y"], + outputs=["bitwisexor"], + ) + + # 2d + x = create_random_int((3, 4), np.int32) + y = create_random_int((3, 4), np.int32) + z = np.bitwise_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i32_2d") + + # 3d + x = create_random_int((3, 4, 5), np.int16) + y = create_random_int((3, 4, 5), np.int16) + z = np.bitwise_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i16_3d") + + @staticmethod + def export_bitwiseor_broadcast() -> None: + node = onnx.helper.make_node( + "BitwiseXor", + inputs=["x", "y"], + outputs=["bitwisexor"], + ) + + # 3d vs 1d + x = create_random_int((3, 4, 5), np.uint64) + y = create_random_int((5,), np.uint64) + z = np.bitwise_xor(x, y) + expect( + node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui64_bcast_3v1d" + ) + + # 4d vs 3d + x = create_random_int((3, 4, 5, 6), np.uint8) + y = create_random_int((4, 5, 6), np.uint8) + z = np.bitwise_xor(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui8_bcast_4v3d") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/blackmanwindow.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/blackmanwindow.py new file mode 100644 index 0000000000000000000000000000000000000000..01bc90de0b5d71746989d3df5e273cebc37a9204 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/blackmanwindow.py @@ -0,0 +1,45 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class BlackmanWindow(Base): + @staticmethod + def export() -> None: + # Test periodic window + node = onnx.helper.make_node( + "BlackmanWindow", + inputs=["x"], + outputs=["y"], + ) + size = np.int32(10) + a0 = 0.42 + a1 = -0.5 + a2 = 0.08 + y = a0 + y += a1 * np.cos(2 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / size) + y += a2 * np.cos(4 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / size) + expect(node, inputs=[size], outputs=[y], name="test_blackmanwindow") + + # Test symmetric window + node = onnx.helper.make_node( + "BlackmanWindow", inputs=["x"], outputs=["y"], periodic=0 + ) + size = np.int32(10) + a0 = 0.42 + a1 = -0.5 + a2 = 0.08 + y = a0 + y += a1 * np.cos( + 2 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + y += a2 * np.cos( + 4 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + expect(node, inputs=[size], outputs=[y], name="test_blackmanwindow_symmetric") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/cast.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/cast.py new file mode 100644 index 0000000000000000000000000000000000000000..a255e8fead2f56ad6f49da82cc84919bb3063fc4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/cast.py @@ -0,0 +1,354 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import sys + +import numpy as np + +import onnx +from onnx import TensorProto, helper +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import ( + float32_to_float8e4m3, + float32_to_float8e5m2, + make_tensor, + tensor_dtype_to_field, +) +from onnx.numpy_helper import float8e4m3_to_float32, float8e5m2_to_float32 + + +class Cast(Base): + @staticmethod + def export() -> None: + shape = (3, 4) + test_cases = [ + ("FLOAT", "FLOAT16"), + ("FLOAT", "DOUBLE"), + ("FLOAT16", "FLOAT"), + ("FLOAT16", "DOUBLE"), + ("DOUBLE", "FLOAT"), + ("DOUBLE", "FLOAT16"), + ("FLOAT", "STRING"), + ("STRING", "FLOAT"), + ("FLOAT", "BFLOAT16"), + ("BFLOAT16", "FLOAT"), + ("FLOAT", "FLOAT8E4M3FN"), + ("FLOAT16", "FLOAT8E4M3FN"), + ("FLOAT", "FLOAT8E4M3FNUZ"), + ("FLOAT16", "FLOAT8E4M3FNUZ"), + ("FLOAT8E4M3FN", "FLOAT"), + ("FLOAT8E4M3FN", "FLOAT16"), + ("FLOAT8E4M3FNUZ", "FLOAT"), + ("FLOAT8E4M3FNUZ", "FLOAT16"), + ("FLOAT", "FLOAT8E5M2"), + ("FLOAT16", "FLOAT8E5M2"), + ("FLOAT", "FLOAT8E5M2FNUZ"), + ("FLOAT16", "FLOAT8E5M2FNUZ"), + ("FLOAT8E5M2", "FLOAT"), + ("FLOAT8E5M2", "FLOAT16"), + ("FLOAT8E5M2FNUZ", "FLOAT"), + ("FLOAT8E5M2FNUZ", "FLOAT16"), + ] + + vect_float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3) + vect_float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2) + f8_types = ("FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ") + + for from_type, to_type in test_cases: + input_type_proto = None + output_type_proto = None + if from_type == "BFLOAT16" or to_type == "BFLOAT16": + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ) + little_endisan = sys.byteorder == "little" + np_uint16_view = np_fp32.view(dtype=np.uint16) + np_bfp16 = ( + np_uint16_view[1::2] if little_endisan else np_uint16_view[0::2] + ) + if to_type == "BFLOAT16": + assert from_type == "FLOAT" + input = np_fp32.reshape([3, 4]) + output = np_bfp16.reshape([3, 4]) + input_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.FLOAT), input.shape + ) + output_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.BFLOAT16), output.shape + ) + else: + assert to_type == "FLOAT" + input = np_bfp16.reshape([3, 4]) + # convert bfloat to FLOAT + np_fp32_zeros = np.zeros((len(np_bfp16) * 2,), dtype=np.uint16) + if little_endisan: + np_fp32_zeros[1::2] = np_bfp16 + else: + np_fp32_zeros[0::2] = np_bfp16 + np_fp32_from_bfloat = np_fp32_zeros.view(dtype=np.float32) + output = np_fp32_from_bfloat.reshape([3, 4]) + input_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.BFLOAT16), input.shape + ) + output_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.FLOAT), output.shape + ) + elif from_type in f8_types or to_type in f8_types: + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.7229038", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ) + + if from_type == "FLOAT": + input_values = np_fp32 + input = make_tensor( + "x", TensorProto.FLOAT, [3, 4], np_fp32.tolist() + ) + elif from_type == "FLOAT16": + input_values = np_fp32.astype(np.float16).astype(np.float32) + input = make_tensor( + "x", TensorProto.FLOAT16, [3, 4], input_values.tolist() + ) + elif from_type == "FLOAT8E4M3FN": + input_values = float8e4m3_to_float32( + vect_float32_to_float8e4m3(np_fp32) + ) + input = make_tensor( + "x", TensorProto.FLOAT8E4M3FN, [3, 4], input_values.tolist() + ) + elif from_type == "FLOAT8E4M3FNUZ": + input_values = float8e4m3_to_float32( + vect_float32_to_float8e4m3(np_fp32, uz=True), uz=True + ) + input = make_tensor( + "x", TensorProto.FLOAT8E4M3FNUZ, [3, 4], input_values.tolist() + ) + elif from_type == "FLOAT8E5M2": + input_values = float8e5m2_to_float32( + vect_float32_to_float8e5m2(np_fp32) + ) + input = make_tensor( + "x", TensorProto.FLOAT8E5M2, [3, 4], input_values.tolist() + ) + elif from_type == "FLOAT8E5M2FNUZ": + input_values = float8e5m2_to_float32( + vect_float32_to_float8e5m2(np_fp32, fn=True, uz=True), + fn=True, + uz=True, + ) + input = make_tensor( + "x", TensorProto.FLOAT8E5M2FNUZ, [3, 4], input_values.tolist() + ) + else: + raise ValueError( + "Conversion from {from_type} to {to_type} is not tested." + ) + + if to_type == "FLOAT8E4M3FN": + expected = float8e4m3_to_float32( + vect_float32_to_float8e4m3(input_values) + ) + elif to_type == "FLOAT8E4M3FNUZ": + expected = float8e4m3_to_float32( + vect_float32_to_float8e4m3(input_values, uz=True), uz=True + ) + elif to_type == "FLOAT8E5M2": + expected = float8e5m2_to_float32( + vect_float32_to_float8e5m2(input_values) + ) + elif to_type == "FLOAT8E5M2FNUZ": + expected = float8e5m2_to_float32( + vect_float32_to_float8e5m2(input_values, fn=True, uz=True), + fn=True, + uz=True, + ) + elif to_type == "FLOAT16": + expected = input_values.astype(np.float16).astype(np.float32) + elif to_type == "FLOAT": + expected = input_values + else: + raise ValueError( + "Conversion from {from_type} to {to_type} is not tested." + ) + expected_tensor = make_tensor( + "x", getattr(TensorProto, to_type), [3, 4], expected.tolist() + ) + output = expected_tensor + + elif from_type != "STRING": + input = np.random.random_sample(shape).astype( + helper.tensor_dtype_to_np_dtype(getattr(TensorProto, from_type)) + ) + if to_type == "STRING": + # Converting input to str, then give it object dtype for generating script + ss = [] + for i in input.flatten(): + s = str(i).encode("utf-8") + su = s.decode("utf-8") + ss.append(su) + + output = np.array(ss).astype(object).reshape([3, 4]) + else: + output = input.astype( + helper.tensor_dtype_to_np_dtype(getattr(TensorProto, to_type)) + ) + else: + input = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.dtype(object), + ).reshape([3, 4]) + output = input.astype( + helper.tensor_dtype_to_np_dtype(getattr(TensorProto, to_type)) + ) + node = onnx.helper.make_node( + "Cast", + inputs=["input"], + outputs=["output"], + to=getattr(TensorProto, to_type), + ) + if input_type_proto and output_type_proto: + expect( + node, + inputs=[input], + outputs=[output], + name="test_cast_" + from_type + "_to_" + to_type, + input_type_protos=[input_type_proto], + output_type_protos=[output_type_proto], + ) + else: + expect( + node, + inputs=[input], + outputs=[output], + name="test_cast_" + from_type + "_to_" + to_type, + ) + + @staticmethod + def export_saturate_false() -> None: + test_cases = [ + ("FLOAT", "FLOAT8E4M3FN"), + ("FLOAT16", "FLOAT8E4M3FN"), + ("FLOAT", "FLOAT8E4M3FNUZ"), + ("FLOAT16", "FLOAT8E4M3FNUZ"), + ("FLOAT", "FLOAT8E5M2"), + ("FLOAT16", "FLOAT8E5M2"), + ("FLOAT", "FLOAT8E5M2FNUZ"), + ("FLOAT16", "FLOAT8E5M2FNUZ"), + ] + vect_float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3) + vect_float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2) + + for from_type, to_type in test_cases: + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.7229038", + "1000000", + "1e-7", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ) + + if from_type == "FLOAT": + input_values = np_fp32 + input = make_tensor("x", TensorProto.FLOAT, [3, 4], np_fp32.tolist()) + elif from_type == "FLOAT16": + input_values = np_fp32.astype(np.float16).astype(np.float32) + input = make_tensor( + "x", TensorProto.FLOAT16, [3, 4], input_values.tolist() + ) + else: + raise ValueError( + "Conversion from {from_type} to {to_type} is not tested." + ) + + if to_type == "FLOAT8E4M3FN": + expected = vect_float32_to_float8e4m3(input_values, saturate=False) + elif to_type == "FLOAT8E4M3FNUZ": + expected = vect_float32_to_float8e4m3( + input_values, uz=True, saturate=False + ) + elif to_type == "FLOAT8E5M2": + expected = vect_float32_to_float8e5m2(input_values, saturate=False) + elif to_type == "FLOAT8E5M2FNUZ": + expected = vect_float32_to_float8e5m2( + input_values, fn=True, uz=True, saturate=False + ) + else: + raise ValueError( + "Conversion from {from_type} to {to_type} is not tested." + ) + + ivals = bytes([int(i) for i in expected]) + tensor = TensorProto() + tensor.data_type = getattr(TensorProto, to_type) + tensor.name = "x" + tensor.dims.extend([3, 4]) + field = tensor_dtype_to_field(tensor.data_type) + getattr(tensor, field).extend(ivals) + + output = tensor + + node = onnx.helper.make_node( + "Cast", + inputs=["input"], + outputs=["output"], + to=getattr(TensorProto, to_type), + saturate=0, + ) + expect( + node, + inputs=[input], + outputs=[output], + name="test_cast_no_saturate_" + from_type + "_to_" + to_type, + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/castlike.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/castlike.py new file mode 100644 index 0000000000000000000000000000000000000000..e66e87e3325a2fb72e2b5c23e2eae1d650834137 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/castlike.py @@ -0,0 +1,238 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import sys + +import numpy as np + +import onnx +from onnx import TensorProto, helper +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import float32_to_float8e4m3, float32_to_float8e5m2, make_tensor +from onnx.numpy_helper import float8e4m3_to_float32, float8e5m2_to_float32 + + +class CastLike(Base): + @staticmethod + def export() -> None: + shape = (3, 4) + test_cases = [ + ("FLOAT", "FLOAT16"), + ("FLOAT", "DOUBLE"), + ("FLOAT16", "FLOAT"), + ("FLOAT16", "DOUBLE"), + ("DOUBLE", "FLOAT"), + ("DOUBLE", "FLOAT16"), + ("FLOAT", "STRING"), + ("STRING", "FLOAT"), + ("FLOAT", "BFLOAT16"), + ("BFLOAT16", "FLOAT"), + ("FLOAT", "FLOAT8E4M3FN"), + ("FLOAT", "FLOAT8E4M3FNUZ"), + ("FLOAT8E4M3FN", "FLOAT"), + ("FLOAT8E4M3FNUZ", "FLOAT"), + ("FLOAT", "FLOAT8E5M2"), + ("FLOAT", "FLOAT8E5M2FNUZ"), + ("FLOAT8E5M2", "FLOAT"), + ("FLOAT8E5M2FNUZ", "FLOAT"), + ] + + vect_float32_to_float8e4m3 = np.vectorize(float32_to_float8e4m3) + vect_float32_to_float8e5m2 = np.vectorize(float32_to_float8e5m2) + + for from_type, to_type in test_cases: + input_type_proto = None + output_type_proto = None + if from_type == "BFLOAT16" or to_type == "BFLOAT16": + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ) + little_endisan = sys.byteorder == "little" + np_uint16_view = np_fp32.view(dtype=np.uint16) + np_bfp16 = ( + np_uint16_view[1::2] if little_endisan else np_uint16_view[0::2] + ) + if to_type == "BFLOAT16": + assert from_type == "FLOAT" + input = np_fp32.reshape([3, 4]) + output = np_bfp16.reshape([3, 4]) + input_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.FLOAT), input.shape + ) + output_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.BFLOAT16), output.shape + ) + else: + assert to_type == "FLOAT" + input = np_bfp16.reshape([3, 4]) + # convert bfloat to FLOAT + np_fp32_zeros = np.zeros((len(np_bfp16) * 2,), dtype=np.uint16) + if little_endisan: + np_fp32_zeros[1::2] = np_bfp16 + else: + np_fp32_zeros[0::2] = np_bfp16 + np_fp32_from_bfloat = np_fp32_zeros.view(dtype=np.float32) + output = np_fp32_from_bfloat.reshape([3, 4]) + input_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.BFLOAT16), input.shape + ) + output_type_proto = onnx.helper.make_tensor_type_proto( + int(TensorProto.FLOAT), output.shape + ) + like = output.flatten()[0:1] + elif from_type in ( + "FLOAT8E4M3FN", + "FLOAT8E4M3FNUZ", + "FLOAT8E5M2", + "FLOAT8E5M2FNUZ", + ) or to_type in ( + "FLOAT8E4M3FN", + "FLOAT8E4M3FNUZ", + "FLOAT8E5M2", + "FLOAT8E5M2FNUZ", + ): + np_fp32 = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.float32, + ) + if to_type == "FLOAT8E4M3FN": + expected = float8e4m3_to_float32( + vect_float32_to_float8e4m3(np_fp32) + ) + expected_tensor = make_tensor( + "x", TensorProto.FLOAT8E4M3FN, [3, 4], expected.tolist() + ) + like_tensor = make_tensor( + "x", TensorProto.FLOAT8E4M3FN, [1], expected[:1] + ) + elif to_type == "FLOAT8E4M3FNUZ": + expected = float8e4m3_to_float32( + vect_float32_to_float8e4m3(np_fp32, uz=True), uz=True + ) + expected_tensor = make_tensor( + "x", TensorProto.FLOAT8E4M3FNUZ, [3, 4], expected.tolist() + ) + like_tensor = make_tensor( + "x", TensorProto.FLOAT8E4M3FNUZ, [1], expected[:1] + ) + elif to_type == "FLOAT8E5M2": + expected = float8e5m2_to_float32( + vect_float32_to_float8e5m2(np_fp32) + ) + expected_tensor = make_tensor( + "x", TensorProto.FLOAT8E5M2, [3, 4], expected.tolist() + ) + like_tensor = make_tensor( + "x", TensorProto.FLOAT8E5M2, [1], expected[:1] + ) + elif to_type == "FLOAT8E5M2FNUZ": + expected = float8e5m2_to_float32( + vect_float32_to_float8e5m2(np_fp32, fn=True, uz=True), + fn=True, + uz=True, + ) + expected_tensor = make_tensor( + "x", TensorProto.FLOAT8E5M2FNUZ, [3, 4], expected.tolist() + ) + like_tensor = make_tensor( + "x", TensorProto.FLOAT8E5M2FNUZ, [1], expected[:1] + ) + if from_type == "FLOAT": + input = np_fp32.reshape((3, 4)) + output = expected_tensor + like = like_tensor + else: + assert to_type == "FLOAT" + input = expected_tensor + output = expected.reshape((3, 4)) + like = output.flatten()[:1] + elif from_type != "STRING": + input = np.random.random_sample(shape).astype( + helper.tensor_dtype_to_np_dtype(getattr(TensorProto, from_type)) + ) + if to_type == "STRING": + # Converting input to str, then give it object dtype for generating script + ss = [] + for i in input.flatten(): + s = str(i).encode("utf-8") + su = s.decode("utf-8") + ss.append(su) + + output = np.array(ss).astype(object).reshape([3, 4]) + else: + output = input.astype( + helper.tensor_dtype_to_np_dtype(getattr(TensorProto, to_type)) + ) + like = output.flatten()[0:1] + else: + input = np.array( + [ + "0.47892547", + "0.48033667", + "0.49968487", + "0.81910545", + "0.47031248", + "0.816468", + "0.21087195", + "0.7229038", + "NaN", + "INF", + "+INF", + "-INF", + ], + dtype=np.dtype(object), + ).reshape([3, 4]) + output = input.astype( + helper.tensor_dtype_to_np_dtype(getattr(TensorProto, to_type)) + ) + like = output.flatten()[0:1] + node = onnx.helper.make_node( + "CastLike", + inputs=["input", "like"], + outputs=["output"], + ) + if input_type_proto and output_type_proto: + expect( + node, + inputs=[input, like], + outputs=[output], + name="test_castlike_" + from_type + "_to_" + to_type, + input_type_protos=[input_type_proto, output_type_proto], + output_type_protos=[output_type_proto], + ) + else: + expect( + node, + inputs=[input, like], + outputs=[output], + name="test_castlike_" + from_type + "_to_" + to_type, + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/ceil.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/ceil.py new file mode 100644 index 0000000000000000000000000000000000000000..d87644ed644ec17db9fb87f2f54ac05961ce0c35 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/ceil.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Ceil(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Ceil", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.5, 1.2]).astype(np.float32) + y = np.ceil(x) # expected output [-1., 2.] + expect(node, inputs=[x], outputs=[y], name="test_ceil_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.ceil(x) + expect(node, inputs=[x], outputs=[y], name="test_ceil") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/celu.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/celu.py new file mode 100644 index 0000000000000000000000000000000000000000..1c2879df4d2b24b54ca647ef664f83372cce802f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/celu.py @@ -0,0 +1,49 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Celu(Base): + @staticmethod + def export() -> None: + alpha = 2.0 + node = onnx.helper.make_node( + "Celu", + inputs=["X"], + outputs=["Y"], + alpha=alpha, + ) + + input_data = np.array( + [ + [ + [[0.8439683], [0.5665144], [0.05836735]], + [[0.02916367], [0.12964272], [0.5060197]], + [[0.79538304], [0.9411346], [0.9546573]], + ], + [ + [[0.17730942], [0.46192095], [0.26480448]], + [[0.6746842], [0.01665257], [0.62473077]], + [[0.9240844], [0.9722341], [0.11965699]], + ], + [ + [[0.41356155], [0.9129373], [0.59330076]], + [[0.81929934], [0.7862604], [0.11799799]], + [[0.69248444], [0.54119414], [0.07513223]], + ], + ], + dtype=np.float32, + ) + + # Calculate expected output data + positive_input = np.maximum(0, input_data) + negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1)) + expected_output = positive_input + negative_input + + expect(node, inputs=[input_data], outputs=[expected_output], name="test_celu") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/center_crop_pad.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/center_crop_pad.py new file mode 100644 index 0000000000000000000000000000000000000000..579232f5cebfd928ede810dd8d3794814bdf8b7d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/center_crop_pad.py @@ -0,0 +1,129 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class CenterCropPad(Base): + @staticmethod + def export_center_crop_pad_crop() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + ) + + # First dim is even diff, second is uneven + x = np.random.randn(20, 10, 3).astype(np.float32) + shape = np.array([10, 7, 3], dtype=np.int64) + y = x[5:15, 1:8, :] + + expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_crop") + + @staticmethod + def export_center_crop_pad_pad() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + ) + + # First dim is even diff, second is uneven + x = np.random.randn(10, 7, 3).astype(np.float32) + shape = np.array([20, 10, 3], dtype=np.int64) + y = np.zeros([20, 10, 3], dtype=np.float32) + y[5:15, 1:8, :] = x + + expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_pad") + + @staticmethod + def export_center_crop_pad_crop_and_pad() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + ) + + # Cropping on first dim, padding on second, third stays the same + x = np.random.randn(20, 8, 3).astype(np.float32) + shape = np.array([10, 10, 3], dtype=np.int64) + y = np.zeros([10, 10, 3], dtype=np.float32) + y[:, 1:9, :] = x[5:15, :, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_and_pad", + ) + + @staticmethod + def export_center_crop_pad_crop_axes_hwc() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + axes=[0, 1], + ) + + # Cropping on first dim, padding on second, third stays the same + x = np.random.randn(20, 8, 3).astype(np.float32) + shape = np.array([10, 9], dtype=np.int64) + y = np.zeros([10, 9, 3], dtype=np.float32) + y[:, :8, :] = x[5:15, :, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_axes_hwc", + ) + + @staticmethod + def export_center_crop_pad_crop_negative_axes_hwc() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + axes=[-3, -2], + ) + + # Cropping on first dim, padding on second, third stays the same + x = np.random.randn(20, 8, 3).astype(np.float32) + shape = np.array([10, 9], dtype=np.int64) + y = np.zeros([10, 9, 3], dtype=np.float32) + y[:, :8, :] = x[5:15, :, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_negative_axes_hwc", + ) + + @staticmethod + def export_center_crop_pad_crop_axes_chw() -> None: + node = onnx.helper.make_node( + "CenterCropPad", + inputs=["x", "shape"], + outputs=["y"], + axes=[1, 2], + ) + + # Cropping on second dim, padding on third, first stays the same + x = np.random.randn(3, 20, 8).astype(np.float32) + shape = np.array([10, 9], dtype=np.int64) + y = np.zeros([3, 10, 9], dtype=np.float32) + y[:, :, :8] = x[:, 5:15, :] + + expect( + node, + inputs=[x, shape], + outputs=[y], + name="test_center_crop_pad_crop_axes_chw", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/clip.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..e7046ff02d2bd3d7d1e2346efc788c790bd276b0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/clip.py @@ -0,0 +1,132 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Clip(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min", "max"], + outputs=["y"], + ) + + x = np.array([-2, 0, 2]).astype(np.float32) + min_val = np.float32(-1) + max_val = np.float32(1) + y = np.clip(x, min_val, max_val) # expected output [-1., 0., 1.] + expect( + node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_example" + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, min_val, max_val) + expect(node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip") + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min", "max"], + outputs=["y"], + ) + + min_val = np.float32(-5) + max_val = np.float32(5) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.array([-1, 0, 1]).astype(np.float32) + expect( + node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_inbounds" + ) + + x = np.array([-6, 0, 6]).astype(np.float32) + y = np.array([-5, 0, 5]).astype(np.float32) + expect( + node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_outbounds" + ) + + x = np.array([-1, 0, 6]).astype(np.float32) + y = np.array([-1, 0, 5]).astype(np.float32) + expect( + node, + inputs=[x, min_val, max_val], + outputs=[y], + name="test_clip_splitbounds", + ) + + @staticmethod + def export_clip_default() -> None: + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min"], + outputs=["y"], + ) + min_val = np.float32(0) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, min_val, np.inf) + expect(node, inputs=[x, min_val], outputs=[y], name="test_clip_default_min") + + no_min = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, "max"], + outputs=["y"], + ) + max_val = np.float32(0) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, -np.inf, max_val) + expect(node, inputs=[x, max_val], outputs=[y], name="test_clip_default_max") + + no_max = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, no_max], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.array([-1, 0, 1]).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_clip_default_inbounds") + + @staticmethod + def export_clip_default_int8() -> None: + node = onnx.helper.make_node( + "Clip", + inputs=["x", "min"], + outputs=["y"], + ) + min_val = np.int8(0) + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.clip(x, min_val, np.iinfo(np.int8).max) + expect( + node, inputs=[x, min_val], outputs=[y], name="test_clip_default_int8_min" + ) + + no_min = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, "max"], + outputs=["y"], + ) + max_val = np.int8(0) + x = np.random.randn(3, 4, 5).astype(np.int8) + y = np.clip(x, np.iinfo(np.int8).min, max_val) + expect( + node, inputs=[x, max_val], outputs=[y], name="test_clip_default_int8_max" + ) + + no_max = "" # optional input, not supplied + node = onnx.helper.make_node( + "Clip", + inputs=["x", no_min, no_max], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.int8) + y = np.array([-1, 0, 1]).astype(np.int8) + expect(node, inputs=[x], outputs=[y], name="test_clip_default_int8_inbounds") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/col2im.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/col2im.py new file mode 100644 index 0000000000000000000000000000000000000000..dc3c5404a1c80d4a67114fd2fe9c9468065555e9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/col2im.py @@ -0,0 +1,350 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import absolute_import, division, print_function, unicode_literals + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Col2Im(Base): + """Col2Im operator with N-dimension support + + The tests below can be reproduced in Python using https://github.com/f-dangel/unfoldNd/ + """ + + @staticmethod + def export() -> None: + input = np.array( + [ + [ + [1.0, 6.0, 11.0, 16.0, 21.0], # (1, 5, 5) + [2.0, 7.0, 12.0, 17.0, 22.0], + [3.0, 8.0, 13.0, 18.0, 23.0], + [4.0, 9.0, 14.0, 19.0, 24.0], + [5.0, 0.0, 15.0, 20.0, 25.0], + ] + ] + ).astype(np.float32) + + image_shape = np.array([5, 5]).astype(np.int64) + block_shape = np.array([1, 5]).astype(np.int64) + node = onnx.helper.make_node( + "Col2Im", ["input", "image_shape", "block_shape"], ["output"] + ) + + output = np.array( + [ + [ + [ + [1.0, 2.0, 3.0, 4.0, 5.0], # (1, 1, 5, 5) + [6.0, 7.0, 8.0, 9.0, 0.0], + [11.0, 12.0, 13.0, 14.0, 15.0], + [16.0, 17.0, 18.0, 19.0, 20.0], + [21.0, 22.0, 23.0, 24.0, 25.0], + ] + ] + ] + ).astype(np.float32) + + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im", + ) + + @staticmethod + def export_col2im_strides() -> None: + input = np.array( + [ + [ + [0.0, 0.0, 0.0, 0.0], # (1, 9, 4) + [1.0, 1.0, 1.0, 1.0], + [1.0, 1.0, 1.0, 1.0], + [1.0, 1.0, 1.0, 1.0], + [0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0], + [1.0, 1.0, 1.0, 1.0], + [0.0, 0.0, 0.0, 0.0], + ] + ] + ).astype(np.float32) + image_shape = np.array([5, 5]).astype(np.int64) + block_shape = np.array([3, 3]).astype(np.int64) + + output = np.array( + [ + [ + [ + [0.0, 1.0, 1.0, 1.0, 1.0], # (1, 1, 5, 5) + [1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 2.0, 1.0, 2.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0], + ] + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", + ["input", "image_shape", "block_shape"], + ["output"], + strides=[2, 2], + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_strides", + ) + + @staticmethod + def export_col2im_pads() -> None: + input = np.array( + [ + [ + [ + 1.0, + 6.0, + 11.0, + 16.0, + 21.0, + 26, + 31, + 36, + 41, + 46, + 51, + 56, + 61, + 66, + 71, + ], # (1, 5, 15) + [ + 2.0, + 7.0, + 12.0, + 17.0, + 22.0, + 27, + 32, + 37, + 42, + 47, + 52, + 57, + 62, + 67, + 72, + ], + [ + 3.0, + 8.0, + 13.0, + 18.0, + 23.0, + 28, + 33, + 38, + 43, + 48, + 53, + 58, + 63, + 68, + 73, + ], + [ + 4.0, + 9.0, + 14.0, + 19.0, + 24.0, + 29, + 34, + 39, + 44, + 49, + 54, + 59, + 64, + 69, + 74, + ], + [ + 5.0, + 10.0, + 15.0, + 20.0, + 25.0, + 30, + 35, + 40, + 45, + 50, + 55, + 60, + 65, + 70, + 75, + ], + ] + ] + ).astype(np.float32) + image_shape = np.array([5, 5]).astype(np.int64) + block_shape = np.array([1, 5]).astype(np.int64) + + output = np.array( + [ + [ + [ + [8.0, 21.0, 24.0, 27.0, 24.0], # (1, 1, 5, 5) + [38.0, 66.0, 69.0, 72.0, 54.0], + [68.0, 111.0, 114.0, 117.0, 84.0], + [98.0, 156.0, 159.0, 162.0, 114.0], + [128.0, 201.0, 204.0, 207.0, 144.0], + ] + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", + ["input", "image_shape", "block_shape"], + ["output"], + pads=[0, 1, 0, 1], + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_pads", + ) + + @staticmethod + def export_col2im_dilations() -> None: + input = np.array( + [ + [ + [1.0, 5.0, 9.0, 13.0, 17], # (1, 4, 5) + [2.0, 6.0, 10.0, 14.0, 18], + [3.0, 7.0, 11.0, 15.0, 19], + [4.0, 8.0, 12.0, 16.0, 20], + ] + ] + ).astype(np.float32) + image_shape = np.array([6, 6]).astype(np.int64) + block_shape = np.array([2, 2]).astype(np.int64) + + output = np.array( + [ + [ + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 2.0], # (1, 1, 6, 6) + [8.0, 0.0, 0.0, 0.0, 0.0, 10.0], + [16.0, 0.0, 0.0, 0.0, 0.0, 18.0], + [24.0, 0.0, 0.0, 0.0, 0.0, 26.0], + [32.0, 0.0, 0.0, 0.0, 0.0, 34.0], + [19.0, 0.0, 0.0, 0.0, 0.0, 20.0], + ] + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", + ["input", "image_shape", "block_shape"], + ["output"], + dilations=[1, 5], + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_dilations", + ) + + @staticmethod + def export_col2im_5d() -> None: + input = np.array( + [ + [ + [1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56], # (1, 10, 12) + [2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57], + [3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58], + [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59], + [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60], + [61, 66, 71, 76, 81, 86, 91, 96, 101, 106, 111, 116], + [62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117], + [63, 68, 73, 78, 83, 88, 93, 98, 103, 108, 113, 118], + [64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119], + [65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120], + ] + ] + ).astype(np.float32) + image_shape = np.array([3, 4, 5]).astype(np.int64) + block_shape = np.array([1, 1, 5]).astype(np.int64) + + output = np.array( + [ + [ + [ + [ + [1, 2, 3, 4, 5], # (1, 2, 3, 4, 5) + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + ], + [ + [21, 22, 23, 24, 25], + [26, 27, 28, 29, 30], + [31, 32, 33, 34, 35], + [36, 37, 38, 39, 40], + ], + [ + [41, 42, 43, 44, 45], + [46, 47, 48, 49, 50], + [51, 52, 53, 54, 55], + [56, 57, 58, 59, 60], + ], + ], + [ + [ + [61, 62, 63, 64, 65], + [66, 67, 68, 69, 70], + [71, 72, 73, 74, 75], + [76, 77, 78, 79, 80], + ], + [ + [81, 82, 83, 84, 85], + [86, 87, 88, 89, 90], + [91, 92, 93, 94, 95], + [96, 97, 98, 99, 100], + ], + [ + [101, 102, 103, 104, 105], + [106, 107, 108, 109, 110], + [111, 112, 113, 114, 115], + [116, 117, 118, 119, 120], + ], + ], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "Col2Im", ["input", "image_shape", "block_shape"], ["output"] + ) + expect( + node, + inputs=[input, image_shape, block_shape], + outputs=[output], + name="test_col2im_5d", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/compress.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/compress.py new file mode 100644 index 0000000000000000000000000000000000000000..65551575d8a1f4f2007d07451cff813a22dc119e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/compress.py @@ -0,0 +1,98 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Compress(Base): + @staticmethod + def export_compress_0() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + axis=0, + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1, 1]) + output = np.compress(condition, input, axis=0) + # print(output) + # [[ 3. 4.] + # [ 5. 6.]] + + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_0", + ) + + @staticmethod + def export_compress_1() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + axis=1, + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1]) + output = np.compress(condition, input, axis=1) + # print(output) + # [[ 2.] + # [ 4.] + # [ 6.]] + + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_1", + ) + + @staticmethod + def export_compress_default_axis() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1, 0, 0, 1]) + output = np.compress(condition, input) + # print(output) + # [ 2., 5.] + + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_default_axis", + ) + + @staticmethod + def export_compress_negative_axis() -> None: + node = onnx.helper.make_node( + "Compress", + inputs=["input", "condition"], + outputs=["output"], + axis=-1, + ) + input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32) + condition = np.array([0, 1]) + output = np.compress(condition, input, axis=-1) + # print(output) + # [[ 2.] + # [ 4.] + # [ 6.]] + expect( + node, + inputs=[input, condition.astype(bool)], + outputs=[output], + name="test_compress_negative_axis", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/concat.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/concat.py new file mode 100644 index 0000000000000000000000000000000000000000..f099134826d8f95c91c3d10341e02c5a5dfbf256 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/concat.py @@ -0,0 +1,52 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Dict, Sequence + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Concat(Base): + @staticmethod + def export() -> None: + test_cases: Dict[str, Sequence[Any]] = { + "1d": ([1, 2], [3, 4]), + "2d": ([[1, 2], [3, 4]], [[5, 6], [7, 8]]), + "3d": ( + [[[1, 2], [3, 4]], [[5, 6], [7, 8]]], + [[[9, 10], [11, 12]], [[13, 14], [15, 16]]], + ), + } + + for test_case, values_ in test_cases.items(): + values = [np.asarray(v, dtype=np.float32) for v in values_] + for i in range(len(values[0].shape)): + in_args = ["value" + str(k) for k in range(len(values))] + node = onnx.helper.make_node( + "Concat", inputs=[s for s in in_args], outputs=["output"], axis=i + ) + output = np.concatenate(values, i) + expect( + node, + inputs=[v for v in values], + outputs=[output], + name="test_concat_" + test_case + "_axis_" + str(i), + ) + + for i in range(-len(values[0].shape), 0): + in_args = ["value" + str(k) for k in range(len(values))] + node = onnx.helper.make_node( + "Concat", inputs=[s for s in in_args], outputs=["output"], axis=i + ) + output = np.concatenate(values, i) + expect( + node, + inputs=[v for v in values], + outputs=[output], + name="test_concat_" + test_case + "_axis_negative_" + str(abs(i)), + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/constant.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/constant.py new file mode 100644 index 0000000000000000000000000000000000000000..30f81e12ceb96421fdf17814ef6d53208f0c9b5e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/constant.py @@ -0,0 +1,28 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Constant(Base): + @staticmethod + def export() -> None: + values = np.random.randn(5, 5).astype(np.float32) + node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["values"], + value=onnx.helper.make_tensor( + name="const_tensor", + data_type=onnx.TensorProto.FLOAT, + dims=values.shape, + vals=values.flatten().astype(float), + ), + ) + + expect(node, inputs=[], outputs=[values], name="test_constant") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/constantofshape.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/constantofshape.py new file mode 100644 index 0000000000000000000000000000000000000000..dbb768880c9db6c5953f917d26c47f2cc34d5722 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/constantofshape.py @@ -0,0 +1,63 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ConstantOfShape(Base): + @staticmethod + def export_float_ones() -> None: + x = np.array([4, 3, 2]).astype(np.int64) + tensor_value = onnx.helper.make_tensor( + "value", onnx.TensorProto.FLOAT, [1], [1] + ) + node = onnx.helper.make_node( + "ConstantOfShape", + inputs=["x"], + outputs=["y"], + value=tensor_value, + ) + + y = np.ones(x, dtype=np.float32) + expect(node, inputs=[x], outputs=[y], name="test_constantofshape_float_ones") + + @staticmethod + def export_int32_zeros() -> None: + x = np.array([10, 6]).astype(np.int64) + tensor_value = onnx.helper.make_tensor( + "value", onnx.TensorProto.INT32, [1], [0] + ) + node = onnx.helper.make_node( + "ConstantOfShape", + inputs=["x"], + outputs=["y"], + value=tensor_value, + ) + y = np.zeros(x, dtype=np.int32) + expect(node, inputs=[x], outputs=[y], name="test_constantofshape_int_zeros") + + @staticmethod + def export_int32_shape_zero() -> None: + x = np.array( + [ + 0, + ] + ).astype(np.int64) + tensor_value = onnx.helper.make_tensor( + "value", onnx.TensorProto.INT32, [1], [0] + ) + node = onnx.helper.make_node( + "ConstantOfShape", + inputs=["x"], + outputs=["y"], + value=tensor_value, + ) + y = np.zeros(x, dtype=np.int32) + expect( + node, inputs=[x], outputs=[y], name="test_constantofshape_int_shape_zero" + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/conv.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/conv.py new file mode 100644 index 0000000000000000000000000000000000000000..a219a9ae4ac9cf48215c28b2be352efaa807564e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/conv.py @@ -0,0 +1,256 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Conv(Base): + @staticmethod + def export() -> None: + x = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 5, 5) input tensor + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + [20.0, 21.0, 22.0, 23.0, 24.0], + ] + ] + ] + ).astype(np.float32) + W = np.array( + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 1, 3, 3) tensor for convolution weights + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ] + ] + ] + ).astype(np.float32) + + # Convolution with padding + node_with_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1 + pads=[1, 1, 1, 1], + ) + y_with_padding = np.array( + [ + [ + [ + [12.0, 21.0, 27.0, 33.0, 24.0], # (1, 1, 5, 5) output tensor + [33.0, 54.0, 63.0, 72.0, 51.0], + [63.0, 99.0, 108.0, 117.0, 81.0], + [93.0, 144.0, 153.0, 162.0, 111.0], + [72.0, 111.0, 117.0, 123.0, 84.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_padding, + inputs=[x, W], + outputs=[y_with_padding], + name="test_basic_conv_with_padding", + ) + + # Convolution without padding + node_without_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1 + pads=[0, 0, 0, 0], + ) + y_without_padding = np.array( + [ + [ + [ + [54.0, 63.0, 72.0], # (1, 1, 3, 3) output tensor + [99.0, 108.0, 117.0], + [144.0, 153.0, 162.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_without_padding, + inputs=[x, W], + outputs=[y_without_padding], + name="test_basic_conv_without_padding", + ) + + @staticmethod + def export_conv_with_strides() -> None: + x = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 7, 5) input tensor + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + [20.0, 21.0, 22.0, 23.0, 24.0], + [25.0, 26.0, 27.0, 28.0, 29.0], + [30.0, 31.0, 32.0, 33.0, 34.0], + ] + ] + ] + ).astype(np.float32) + W = np.array( + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 1, 3, 3) tensor for convolution weights + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ] + ] + ] + ).astype(np.float32) + + # Convolution with strides=2 and padding + node_with_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[1, 1, 1, 1], + strides=[ + 2, + 2, + ], # Default values for other attributes: dilations=[1, 1], groups=1 + ) + y_with_padding = np.array( + [ + [ + [ + [12.0, 27.0, 24.0], # (1, 1, 4, 3) output tensor + [63.0, 108.0, 81.0], + [123.0, 198.0, 141.0], + [112.0, 177.0, 124.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_padding, + inputs=[x, W], + outputs=[y_with_padding], + name="test_conv_with_strides_padding", + ) + + # Convolution with strides=2 and no padding + node_without_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[0, 0, 0, 0], + strides=[ + 2, + 2, + ], # Default values for other attributes: dilations=[1, 1], groups=1 + ) + y_without_padding = np.array( + [ + [ + [ + [54.0, 72.0], # (1, 1, 3, 2) output tensor + [144.0, 162.0], + [234.0, 252.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_without_padding, + inputs=[x, W], + outputs=[y_without_padding], + name="test_conv_with_strides_no_padding", + ) + + # Convolution with strides=2 and padding only along one dimension (the H dimension in NxCxHxW tensor) + node_with_asymmetric_padding = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[1, 0, 1, 0], + strides=[ + 2, + 2, + ], # Default values for other attributes: dilations=[1, 1], groups=1 + ) + y_with_asymmetric_padding = np.array( + [ + [ + [ + [21.0, 33.0], # (1, 1, 4, 2) output tensor + [99.0, 117.0], + [189.0, 207.0], + [171.0, 183.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_asymmetric_padding, + inputs=[x, W], + outputs=[y_with_asymmetric_padding], + name="test_conv_with_strides_and_asymmetric_padding", + ) + + @staticmethod + def export_conv_with_autopad_same() -> None: + x = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 5, 5) input tensor + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + [20.0, 21.0, 22.0, 23.0, 24.0], + ] + ] + ] + ).astype(np.float32) + W = np.array( + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 1, 3, 3) tensor for convolution weights + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ] + ] + ] + ).astype(np.float32) + + # Convolution with auto_pad='SAME_LOWER' and strides=2 + node = onnx.helper.make_node( + "Conv", + inputs=["x", "W"], + outputs=["y"], + auto_pad="SAME_LOWER", + kernel_shape=[3, 3], + strides=[2, 2], + ) + y = np.array( + [[[[12.0, 27.0, 24.0], [63.0, 108.0, 81.0], [72.0, 117.0, 84.0]]]] + ).astype(np.float32) + expect(node, inputs=[x, W], outputs=[y], name="test_conv_with_autopad_same") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/convinteger.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/convinteger.py new file mode 100644 index 0000000000000000000000000000000000000000..90faca43eba1e776344fcd22db4e5cba7220b3a8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/convinteger.py @@ -0,0 +1,66 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ConvInteger(Base): + @staticmethod + def export_without_padding() -> None: + x = ( + np.array([2, 3, 4, 5, 6, 7, 8, 9, 10]) + .astype(np.uint8) + .reshape((1, 1, 3, 3)) + ) + x_zero_point = np.uint8(1) + w = np.array([1, 1, 1, 1]).astype(np.uint8).reshape((1, 1, 2, 2)) + + y = np.array([12, 16, 24, 28]).astype(np.int32).reshape(1, 1, 2, 2) + + # ConvInteger without padding + convinteger_node = onnx.helper.make_node( + "ConvInteger", inputs=["x", "w", "x_zero_point"], outputs=["y"] + ) + + expect( + convinteger_node, + inputs=[x, w, x_zero_point], + outputs=[y], + name="test_convinteger_without_padding", + ) + + @staticmethod + def export_with_padding() -> None: + x = ( + np.array([2, 3, 4, 5, 6, 7, 8, 9, 10]) + .astype(np.uint8) + .reshape((1, 1, 3, 3)) + ) + x_zero_point = np.uint8(1) + w = np.array([1, 1, 1, 1]).astype(np.uint8).reshape((1, 1, 2, 2)) + + y = ( + np.array([1, 3, 5, 3, 5, 12, 16, 9, 11, 24, 28, 15, 7, 15, 17, 9]) + .astype(np.int32) + .reshape((1, 1, 4, 4)) + ) + + # ConvInteger with padding + convinteger_node_with_padding = onnx.helper.make_node( + "ConvInteger", + inputs=["x", "w", "x_zero_point"], + outputs=["y"], + pads=[1, 1, 1, 1], + ) + + expect( + convinteger_node_with_padding, + inputs=[x, w, x_zero_point], + outputs=[y], + name="test_convinteger_with_padding", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/convtranspose.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/convtranspose.py new file mode 100644 index 0000000000000000000000000000000000000000..33f9bba2fa6f46608195979b49ab43221f8c42ce --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/convtranspose.py @@ -0,0 +1,397 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class ConvTranspose(Base): + @staticmethod + def export() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"]) + + y = np.array( + [ + [ + [ + [0.0, 1.0, 3.0, 3.0, 2.0], # (1, 2, 5, 5) + [3.0, 8.0, 15.0, 12.0, 7.0], + [9.0, 21.0, 36.0, 27.0, 15.0], + [9.0, 20.0, 33.0, 24.0, 13.0], + [6.0, 13.0, 21.0, 15.0, 8.0], + ], + [ + [0.0, 1.0, 3.0, 3.0, 2.0], + [3.0, 8.0, 15.0, 12.0, 7.0], + [9.0, 21.0, 36.0, 27.0, 15.0], + [9.0, 20.0, 33.0, 24.0, 13.0], + [6.0, 13.0, 21.0, 15.0, 8.0], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose") + + @staticmethod + def export_convtranspose_1d() -> None: + x = np.array([[[0.0, 1.0, 2.0]]]).astype(np.float32) # (1, 1, 3) + + W = np.array([[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]]).astype( # (1, 2, 3) + np.float32 + ) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"]) + + y = np.array( + [[[0.0, 1.0, 3.0, 3.0, 2.0], [0.0, 1.0, 3.0, 3.0, 2.0]]] # (1, 2, 5) + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_1d") + + @staticmethod + def export_convtranspose_3d() -> None: + x = np.array( + [ + [ + [ + [ + [0.0, 1.0, 2.0, 3.0, 4.0], # (1, 1, 3, 4, 5) + [5.0, 6.0, 7.0, 8.0, 9.0], + [10.0, 11.0, 12.0, 13.0, 14.0], + [15.0, 16.0, 17.0, 18.0, 19.0], + ], + [ + [20.0, 21.0, 22.0, 23.0, 24.0], + [25.0, 26.0, 27.0, 28.0, 29.0], + [30.0, 31.0, 32.0, 33.0, 34.0], + [35.0, 36.0, 37.0, 38.0, 39.0], + ], + [ + [40.0, 41.0, 42.0, 43.0, 44.0], + [45.0, 46.0, 47.0, 48.0, 49.0], + [50.0, 51.0, 52.0, 53.0, 54.0], + [55.0, 56.0, 57.0, 58.0, 59.0], + ], + ] + ] + ] + ).astype(np.float32) + + W = np.array( + [ + [ + [ + [ + [1.0, 1.0, 1.0], # (1, 2, 3, 3, 3) + [1.0, 1.0, 1.0], + [1.0, 1.0, 1.0], + ], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"]) + + y = np.array( + [ + [ + [ + [ + [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0], # (1, 2, 5, 6, 7) + [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0], + [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0], + [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0], + [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0], + [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0], + ], + [ + [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0], + [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0], + [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0], + [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0], + [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0], + [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0], + ], + [ + [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0], + [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0], + [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0], + [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0], + [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0], + [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0], + ], + [ + [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0], + [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0], + [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0], + [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0], + [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0], + [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0], + ], + [ + [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0], + [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0], + [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0], + [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0], + [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0], + [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0], + ], + ], + [ + [ + [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0], + [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0], + [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0], + [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0], + [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0], + [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0], + ], + [ + [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0], + [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0], + [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0], + [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0], + [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0], + [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0], + ], + [ + [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0], + [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0], + [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0], + [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0], + [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0], + [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0], + ], + [ + [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0], + [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0], + [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0], + [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0], + [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0], + [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0], + ], + [ + [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0], + [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0], + [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0], + [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0], + [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0], + [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0], + ], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_3d") + + @staticmethod + def export_convtranspose_attributes() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + y = np.array( + [ + [ + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], # (1, 2, 10, 8) + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + ], + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + ], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_shape=[10, 8] + ) + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_output_shape") + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_padding=[1, 1] + ) + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pad") + + node = onnx.helper.make_node( + "ConvTranspose", + ["X", "W"], + ["Y"], + name="test", + strides=[3, 2], + output_shape=[10, 8], + kernel_shape=[3, 3], + output_padding=[1, 1], + ) + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_kernel_shape") + + @staticmethod + def export_convtranspose_pads() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], pads=[1, 2, 1, 2] + ) + + y = np.array( + [ + [ + [ + [1.0, 1.0, 3.0], # (1, 2, 7, 3) + [1.0, 1.0, 3.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [13.0, 7.0, 15.0], + [13.0, 7.0, 15.0], + ], + [ + [1.0, 1.0, 3.0], + [1.0, 1.0, 3.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [7.0, 4.0, 9.0], + [13.0, 7.0, 15.0], + [13.0, 7.0, 15.0], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pads") + + @staticmethod + def export_convtranspose_dilations() -> None: + x = np.array( + [[[[3.0, 8.0, 1.0], [9.0, 5.0, 7.0], [3.0, 2.0, 6.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + W = np.array([[[[7.0, 2.0], [1.0, 9.0]]]]).astype(np.float32) # (1, 1, 2, 2) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], dilations=[2, 2] + ) + + y = np.array( + [ + [ + [ + [21.0, 56.0, 13.0, 16.0, 2.0], # [1, 1, 5, 5] + [63.0, 35.0, 67.0, 10.0, 14.0], + [24.0, 22.0, 76.0, 76.0, 21.0], + [9.0, 5.0, 88.0, 45.0, 63.0], + [3.0, 2.0, 33.0, 18.0, 54.0], + ] + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_dilations") + + @staticmethod + def export_convtranspose_autopad_same() -> None: + x = np.array( + [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]] # (1, 1, 3, 3) + ).astype(np.float32) + + W = np.array( + [ + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], # (1, 2, 3, 3) + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ] + ] + ).astype(np.float32) + + node = onnx.helper.make_node( + "ConvTranspose", ["X", "W"], ["Y"], auto_pad="SAME_UPPER", strides=[2, 2] + ) + + y = np.array( + [ + [ + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [3.0, 3.0, 8.0, 5.0, 12.0, 7.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0], + [9.0, 9.0, 20.0, 11.0, 24.0, 13.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0], + ], + [ + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [0.0, 0.0, 1.0, 1.0, 3.0, 2.0], + [3.0, 3.0, 8.0, 5.0, 12.0, 7.0], + [3.0, 3.0, 7.0, 4.0, 9.0, 5.0], + [9.0, 9.0, 20.0, 11.0, 24.0, 13.0], + [6.0, 6.0, 13.0, 7.0, 15.0, 8.0], + ], + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_autopad_same") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/cos.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/cos.py new file mode 100644 index 0000000000000000000000000000000000000000..6c8fa3faaac62a6123440656fe76b86b2884f907 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/cos.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Cos(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Cos", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.cos(x) + expect(node, inputs=[x], outputs=[y], name="test_cos_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.cos(x) + expect(node, inputs=[x], outputs=[y], name="test_cos") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/cosh.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/cosh.py new file mode 100644 index 0000000000000000000000000000000000000000..d6832a89afc36c79695545d3b24c74c8ced7bd6e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/cosh.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Cosh(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Cosh", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.cosh(x) # expected output [1.54308069, 1., 1.54308069] + expect(node, inputs=[x], outputs=[y], name="test_cosh_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.cosh(x) + expect(node, inputs=[x], outputs=[y], name="test_cosh") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/cumsum.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/cumsum.py new file mode 100644 index 0000000000000000000000000000000000000000..febbb8034eb44fa7f237348a509ea5c6ed4d1113 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/cumsum.py @@ -0,0 +1,87 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class CumSum(Base): + @staticmethod + def export_cumsum_1d() -> None: + node = onnx.helper.make_node("CumSum", inputs=["x", "axis"], outputs=["y"]) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([1.0, 3.0, 6.0, 10.0, 15.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d") + + @staticmethod + def export_cumsum_1d_exclusive() -> None: + node = onnx.helper.make_node( + "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([0.0, 1.0, 3.0, 6.0, 10.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_exclusive") + + @staticmethod + def export_cumsum_1d_reverse() -> None: + node = onnx.helper.make_node( + "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([15.0, 14.0, 12.0, 9.0, 5.0]).astype(np.float64) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse") + + @staticmethod + def export_cumsum_1d_reverse_exclusive() -> None: + node = onnx.helper.make_node( + "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1 + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64) + axis = np.int32(0) + y = np.array([14.0, 12.0, 9.0, 5.0, 0.0]).astype(np.float64) + expect( + node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse_exclusive" + ) + + @staticmethod + def export_cumsum_2d_axis_0() -> None: + node = onnx.helper.make_node( + "CumSum", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.int32(0) + y = np.array([1.0, 2.0, 3.0, 5.0, 7.0, 9.0]).astype(np.float64).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_0") + + @staticmethod + def export_cumsum_2d_axis_1() -> None: + node = onnx.helper.make_node( + "CumSum", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.int32(1) + y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_1") + + @staticmethod + def export_cumsum_2d_negative_axis() -> None: + node = onnx.helper.make_node( + "CumSum", + inputs=["x", "axis"], + outputs=["y"], + ) + x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3)) + axis = np.int32(-1) + y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3)) + expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_negative_axis") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/deformconv.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/deformconv.py new file mode 100644 index 0000000000000000000000000000000000000000..cd40174291a5fd0c1d690de9e3e7a99886906424 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/deformconv.py @@ -0,0 +1,170 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DeformConv(Base): + @staticmethod + def export() -> None: + X = np.arange(9).astype(np.float32) + X.shape = (1, 1, 3, 3) + W = np.ones((1, 1, 2, 2), dtype=np.float32) + + # Convolution with padding + offset_with_padding = np.zeros((1, 8, 4, 4), dtype=np.float32) + offset_with_padding[ + 0, 0, 0, 0 + ] = 0.5 # h-coord of [0, 0] element of kernel, at output position [0, 0] + offset_with_padding[ + 0, 5, 1, 2 + ] = -0.1 # w-coord of [1, 0] element of kernel, at output position [1, 2] + + node_with_padding = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset_with_padding"], + outputs=["Y_with_padding"], + kernel_shape=[2, 2], + pads=[1, 1, 1, 1], + ) + Y_with_padding = np.array( + [ + [ + [ + [0.0, 1.0, 3.0, 2.0], # (1, 1, 4, 4) output tensor + [3.0, 8.0, 11.9, 7.0], + [9.0, 20.0, 24.0, 13.0], + [6.0, 13.0, 15.0, 8.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_with_padding, + inputs=[X, W, offset_with_padding], + outputs=[Y_with_padding], + name="test_basic_deform_conv_with_padding", + ) + + # Convolution without padding + offset_without_padding = np.zeros((1, 8, 2, 2), dtype=np.float32) + offset_without_padding[ + 0, 0, 0, 0 + ] = 0.5 # h-coord of [0, 0] element of kernel, at output position [0, 0] + offset_without_padding[ + 0, 5, 0, 1 + ] = -0.1 # w-coord of [1, 0] element of kernel, at output position [0, 1] + + node_without_padding = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset_without_padding"], + outputs=["Y_without_padding"], + kernel_shape=[2, 2], + pads=[0, 0, 0, 0], + ) + Y_without_padding = np.array( + [ + [ + [ + [9.5, 11.9], # (1, 1, 2, 2) output tensor + [20.0, 24.0], + ] + ] + ] + ).astype(np.float32) + expect( + node_without_padding, + inputs=[X, W, offset_without_padding], + outputs=[Y_without_padding], + name="test_basic_deform_conv_without_padding", + ) + + @staticmethod + def export_deformconv_with_mask_bias() -> None: + X = np.arange(9).astype(np.float32) + X.shape = (1, 1, 3, 3) + W = np.ones((1, 1, 2, 2), dtype=np.float32) + B = np.ones((1,), dtype=np.float32) + + offset = np.zeros((1, 8, 2, 2), dtype=np.float32) + offset[ + 0, 0, 0, 0 + ] = 0.5 # h-coord of [0, 0] element of kernel, at output position [0, 0] + offset[ + 0, 5, 0, 1 + ] = -0.1 # w-coord of [1, 0] element of kernel, at output position [0, 1] + + mask = np.ones((1, 4, 2, 2), dtype=np.float32) + mask[0, 2, 1, 1] = 0.2 # [1, 0] element of kernel at output position [1, 1] + + node = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset", "B", "mask"], + outputs=["Y"], + kernel_shape=[2, 2], + pads=[0, 0, 0, 0], + ) + Y = np.array( + [ + [ + [ + [10.5, 12.9], # (1, 1, 2, 2) output tensor + [21.0, 19.4], + ] + ] + ] + ).astype(np.float32) + expect( + node, + inputs=[X, W, offset, B, mask], + outputs=[Y], + name="test_deform_conv_with_mask_bias", + ) + + @staticmethod + def export_deformconv_with_multiple_offset_groups() -> None: + X = np.zeros((1, 2, 3, 3), dtype=np.float32) + X[0, 0] = np.reshape(np.arange(9).astype(np.float32), (3, 3)) + X[0, 1] = np.reshape(np.arange(8, -1, -1).astype(np.float32), (3, 3)) + X.shape = (1, 2, 3, 3) + W = np.ones((1, 2, 2, 2), dtype=np.float32) + + offset = np.zeros((1, 16, 2, 2), dtype=np.float32) + offset[ + 0, 0, 0, 0 + ] = 0.5 # h-coord of [0, 0] element of kernel in channel 0, at output position [0, 0] + offset[ + 0, 13, 0, 1 + ] = ( + -0.1 + ) # w-coord of [1, 0] element of kernel in channel 1, at output position [0, 1] + + node = onnx.helper.make_node( + "DeformConv", + inputs=["X", "W", "offset"], + outputs=["Y"], + kernel_shape=[2, 2], + pads=[0, 0, 0, 0], + offset_group=2, + ) + Y = np.array( + [ + [ + [ + [33.5, 32.1], # (1, 1, 2, 2) output tensor + [32.0, 32.0], + ] + ] + ] + ).astype(np.float32) + expect( + node, + inputs=[X, W, offset], + outputs=[Y], + name="test_deform_conv_with_multiple_offset_groups", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/depthtospace.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/depthtospace.py new file mode 100644 index 0000000000000000000000000000000000000000..47aa65d48bffd55319bd8334fc94f646d899b406 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/depthtospace.py @@ -0,0 +1,97 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DepthToSpace(Base): + @staticmethod + def export_default_mode_example() -> None: + node = onnx.helper.make_node( + "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="DCR" + ) + + # (1, 8, 2, 3) input tensor + x = np.array( + [ + [ + [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]], + [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]], + [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]], + [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]], + [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]], + [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]], + [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]], + ] + ] + ).astype(np.float32) + + # (1, 2, 4, 6) output tensor + y = np.array( + [ + [ + [ + [0.0, 18.0, 1.0, 19.0, 2.0, 20.0], + [36.0, 54.0, 37.0, 55.0, 38.0, 56.0], + [3.0, 21.0, 4.0, 22.0, 5.0, 23.0], + [39.0, 57.0, 40.0, 58.0, 41.0, 59.0], + ], + [ + [9.0, 27.0, 10.0, 28.0, 11.0, 29.0], + [45.0, 63.0, 46.0, 64.0, 47.0, 65.0], + [12.0, 30.0, 13.0, 31.0, 14.0, 32.0], + [48.0, 66.0, 49.0, 67.0, 50.0, 68.0], + ], + ] + ] + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_depthtospace_example") + + @staticmethod + def export_crd_mode_example() -> None: + node = onnx.helper.make_node( + "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="CRD" + ) + + # (1, 8, 2, 3) input tensor + x = np.array( + [ + [ + [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]], + [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]], + [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]], + [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]], + [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]], + [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]], + [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]], + [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]], + ] + ] + ).astype(np.float32) + + # (1, 2, 4, 6) output tensor + y = np.array( + [ + [ + [ + [0.0, 9.0, 1.0, 10.0, 2.0, 11.0], + [18.0, 27.0, 19.0, 28.0, 20.0, 29.0], + [3.0, 12.0, 4.0, 13.0, 5.0, 14.0], + [21.0, 30.0, 22.0, 31.0, 23.0, 32.0], + ], + [ + [36.0, 45.0, 37.0, 46.0, 38.0, 47.0], + [54.0, 63.0, 55.0, 64.0, 56.0, 65.0], + [39.0, 48.0, 40.0, 49.0, 41.0, 50.0], + [57.0, 66.0, 58.0, 67.0, 59.0, 68.0], + ], + ] + ] + ).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_depthtospace_crd_mode_example") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/dequantizelinear.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/dequantizelinear.py new file mode 100644 index 0000000000000000000000000000000000000000..1d311107cd5c708268617b39a56e48c5612dc022 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/dequantizelinear.py @@ -0,0 +1,106 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx import TensorProto +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.helper import make_tensor + + +class DequantizeLinear(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + ) + + # scalar zero point and scale + x = np.array([0, 3, 128, 255]).astype(np.uint8) + x_scale = np.float32(2) + x_zero_point = np.uint8(128) + y = np.array([-256, -250, 0, 254], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear", + ) + + @staticmethod + def export_axis() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale", "x_zero_point"], + outputs=["y"], + ) + + # 1-D tensor zero point and scale of size equal to axis 1 of the input tensor + x = np.array( + [ + [ + [[3, 89], [34, 200], [74, 59]], + [[5, 24], [24, 87], [32, 13]], + [[245, 99], [4, 142], [121, 102]], + ], + ], + dtype=np.uint8, + ) + x_scale = np.array([2, 4, 5], dtype=np.float32) + x_zero_point = np.array([84, 24, 196], dtype=np.uint8) + y = ( + x.astype(np.float32) - x_zero_point.reshape(1, 3, 1, 1).astype(np.float32) + ) * x_scale.reshape(1, 3, 1, 1) + + expect( + node, + inputs=[x, x_scale, x_zero_point], + outputs=[y], + name="test_dequantizelinear_axis", + ) + + @staticmethod + def export_e4m3fn() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale"], + outputs=["y"], + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, 104]) + x_scale = np.float32(2) + y = np.array([0.0, 1.0, 2.0, 896.0, 208.0], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale], + outputs=[y], + name="test_dequantizelinear_e4m3fn", + ) + + @staticmethod + def export_e5m2() -> None: + node = onnx.helper.make_node( + "DequantizeLinear", + inputs=["x", "x_scale"], + outputs=["y"], + ) + + # scalar zero point and scale + x = make_tensor("x", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, 96]) + x_scale = np.float32(2) + y = np.array([0.0, 1.0, 2.0, 98304.0, 192.0], dtype=np.float32) + + expect( + node, + inputs=[x, x_scale], + outputs=[y], + name="test_dequantizelinear_e5m2", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/det.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/det.py new file mode 100644 index 0000000000000000000000000000000000000000..5ce46ce4bf4e71e4d0fc6500d28a1d34643fadac --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/det.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Det(Base): + @staticmethod + def export_2d() -> None: + node = onnx.helper.make_node( + "Det", + inputs=["x"], + outputs=["y"], + ) + + x = np.arange(4).reshape(2, 2).astype(np.float32) + y = np.linalg.det(x) # expect -2 + expect(node, inputs=[x], outputs=[y], name="test_det_2d") + + @staticmethod + def export_nd() -> None: + node = onnx.helper.make_node( + "Det", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]]).astype( + np.float32 + ) + y = np.linalg.det(x) # expect array([-2., -3., -8.]) + expect(node, inputs=[x], outputs=[y], name="test_det_nd") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/dft.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/dft.py new file mode 100644 index 0000000000000000000000000000000000000000..ac522ffbfb23bfccf7a746a199e62333d7e27454 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/dft.py @@ -0,0 +1,42 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DFT(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=1) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + y = np.fft.fft(x, axis=0) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect(node, inputs=[x], outputs=[y], name="test_dft") + + node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=2) + x = np.arange(0, 100).reshape(10, 10).astype(np.float32) + y = np.fft.fft(x, axis=1) + + x = x.reshape(1, 10, 10, 1) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect(node, inputs=[x], outputs=[y], name="test_dft_axis") + + node = onnx.helper.make_node( + "DFT", inputs=["x"], outputs=["y"], inverse=1, axis=1 + ) + x = np.arange(0, 100, dtype=np.complex64).reshape( + 10, + 10, + ) + y = np.fft.ifft(x, axis=0) + + x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2) + expect(node, inputs=[x], outputs=[y], name="test_dft_inverse") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/div.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/div.py new file mode 100644 index 0000000000000000000000000000000000000000..7ca86c30ee1343816d9b410346034512fa237ccf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/div.py @@ -0,0 +1,47 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Div(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Div", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([3, 4]).astype(np.float32) + y = np.array([1, 2]).astype(np.float32) + z = x / y # expected output [3., 2.] + expect(node, inputs=[x, y], outputs=[z], name="test_div_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.rand(3, 4, 5).astype(np.float32) + 1.0 + z = x / y + expect(node, inputs=[x, y], outputs=[z], name="test_div") + + x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + 1 + z = x // y + expect(node, inputs=[x, y], outputs=[z], name="test_div_uint8") + + @staticmethod + def export_div_broadcast() -> None: + node = onnx.helper.make_node( + "Div", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.rand(5).astype(np.float32) + 1.0 + z = x / y + expect(node, inputs=[x, y], outputs=[z], name="test_div_bcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/dropout.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/dropout.py new file mode 100644 index 0000000000000000000000000000000000000000..415682f960b285d3ff8be790d95cc9a7fccc38e0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/dropout.py @@ -0,0 +1,210 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx import helper +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def dropout(X, drop_probability=0.5, seed=0, training_mode=False, return_mask=False): # type: ignore + if drop_probability == 0 or training_mode is False: + if return_mask is True: + return X, np.ones(X.shape, dtype=bool) + else: + return X + + np.random.seed(seed) + mask = np.random.uniform(0, 1.0, X.shape) >= drop_probability + scale = 1 / (1 - drop_probability) + if return_mask is True: + return mask * X * scale, mask.astype(bool) + else: + return mask * X * scale + + +class Dropout(Base): + # Inferencing tests. + @staticmethod + def export_default() -> None: + seed = np.int64(0) + node = onnx.helper.make_node("Dropout", inputs=["x"], outputs=["y"], seed=seed) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = dropout(x) + expect(node, inputs=[x], outputs=[y], name="test_dropout_default") + + @staticmethod + def export_default_ratio() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r"], outputs=["y"], seed=seed + ) + + r = np.float32(0.1) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = dropout(x, r) + expect(node, inputs=[x, r], outputs=[y], name="test_dropout_default_ratio") + + @staticmethod + def export_default_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y, z = dropout(x, return_mask=True) + expect(node, inputs=[x], outputs=[y, z], name="test_dropout_default_mask") + + @staticmethod + def export_default_mask_ratio() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r"], outputs=["y", "z"], seed=seed + ) + + r = np.float32(0.1) + x = np.random.randn(3, 4, 5).astype(np.float32) + y, z = dropout(x, r, return_mask=True) + expect( + node, inputs=[x, r], outputs=[y, z], name="test_dropout_default_mask_ratio" + ) + + # Training tests. + + @staticmethod + def export_training_default() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.5) + t = np.bool_(True) + y = dropout(x, r, training_mode=t) + expect( + node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_default" + ) + + @staticmethod + def export_training_default_ratio_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.5) + t = np.bool_(True) + y, z = dropout(x, r, training_mode=t, return_mask=True) + expect( + node, + inputs=[x, r, t], + outputs=[y, z], + name="test_training_dropout_default_mask", + ) + + @staticmethod + def export_training() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.75) + t = np.bool_(True) + y = dropout(x, r, training_mode=t) + expect(node, inputs=[x, r, t], outputs=[y], name="test_training_dropout") + + @staticmethod + def export_training_ratio_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.75) + t = np.bool_(True) + y, z = dropout(x, r, training_mode=t, return_mask=True) + expect( + node, inputs=[x, r, t], outputs=[y, z], name="test_training_dropout_mask" + ) + + @staticmethod + def export_training_default_zero_ratio() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.0) + t = np.bool_(True) + y = dropout(x, r, training_mode=t) + expect( + node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_zero_ratio" + ) + + @staticmethod + def export_training_default_zero_ratio_mask() -> None: + seed = np.int64(0) + node = onnx.helper.make_node( + "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + r = np.float32(0.0) + t = np.bool_(True) + y, z = dropout(x, r, training_mode=t, return_mask=True) + expect( + node, + inputs=[x, r, t], + outputs=[y, z], + name="test_training_dropout_zero_ratio_mask", + ) + + # Old dropout tests + + @staticmethod + def export_default_old() -> None: + node = onnx.helper.make_node( + "Dropout", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = x + expect( + node, + inputs=[x], + outputs=[y], + name="test_dropout_default_old", + opset_imports=[helper.make_opsetid("", 11)], + ) + + @staticmethod + def export_random_old() -> None: + node = onnx.helper.make_node( + "Dropout", + inputs=["x"], + outputs=["y"], + ratio=0.2, + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = x + expect( + node, + inputs=[x], + outputs=[y], + name="test_dropout_random_old", + opset_imports=[helper.make_opsetid("", 11)], + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/dynamicquantizelinear.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/dynamicquantizelinear.py new file mode 100644 index 0000000000000000000000000000000000000000..e9992c950fdb94ba3ee19d9b99a11e67c28841f2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/dynamicquantizelinear.py @@ -0,0 +1,69 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class DynamicQuantizeLinear(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "DynamicQuantizeLinear", + inputs=["x"], + outputs=["y", "y_scale", "y_zero_point"], + ) + + # expected scale 0.0196078438 and zero point 153 + X = np.array([0, 2, -3, -2.5, 1.34, 0.5]).astype(np.float32) + x_min = np.minimum(0, np.min(X)) + x_max = np.maximum(0, np.max(X)) + Y_Scale = np.float32((x_max - x_min) / (255 - 0)) # uint8 -> [0, 255] + Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8) + Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8) + + expect( + node, + inputs=[X], + outputs=[Y, Y_Scale, Y_ZeroPoint], + name="test_dynamicquantizelinear", + ) + + # expected scale 0.0156862754 and zero point 255 + X = np.array([-1.0, -2.1, -1.3, -2.5, -3.34, -4.0]).astype(np.float32) + x_min = np.minimum(0, np.min(X)) + x_max = np.maximum(0, np.max(X)) + Y_Scale = np.float32((x_max - x_min) / (255 - 0)) # uint8 -> [0, 255] + Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8) + Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8) + + expect( + node, + inputs=[X], + outputs=[Y, Y_Scale, Y_ZeroPoint], + name="test_dynamicquantizelinear_max_adjusted", + ) + + X = ( + np.array([1, 2.1, 1.3, 2.5, 3.34, 4.0, 1.5, 2.6, 3.9, 4.0, 3.0, 2.345]) + .astype(np.float32) + .reshape((3, 4)) + ) + + # expected scale 0.0156862754 and zero point 0 + x_min = np.minimum(0, np.min(X)) + x_max = np.maximum(0, np.max(X)) + Y_Scale = np.float32((x_max - x_min) / (255 - 0)) # uint8 -> [0, 255] + Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8) + Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8) + + expect( + node, + inputs=[X], + outputs=[Y, Y_Scale, Y_ZeroPoint], + name="test_dynamicquantizelinear_min_adjusted", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/einsum.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/einsum.py new file mode 100644 index 0000000000000000000000000000000000000000..88ebb5b53477fdc6b68ddee102ecf587fbe95b58 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/einsum.py @@ -0,0 +1,82 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Tuple + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def einsum_reference_implementation( + Eqn: str, Operands: Tuple[np.ndarray, ...] +) -> np.ndarray: + Z = np.einsum(Eqn, *Operands) + return Z + + +class Einsum(Base): + @staticmethod + def export_einsum_transpose() -> None: + Eqn = "ij->ji" + node = onnx.helper.make_node( + "Einsum", inputs=["x"], outputs=["y"], equation=Eqn + ) + + X = np.random.randn(3, 4) + Y = einsum_reference_implementation(Eqn, (X,)) + + expect(node, inputs=[X], outputs=[Y], name="test_einsum_transpose") + + @staticmethod + def export_einsum_sum() -> None: + Eqn = "ij->i" + node = onnx.helper.make_node( + "Einsum", inputs=["x"], outputs=["y"], equation=Eqn + ) + + X = np.random.randn(3, 4) + Z = einsum_reference_implementation(Eqn, (X,)) + + expect(node, inputs=[X], outputs=[Z], name="test_einsum_sum") + + @staticmethod + def export_einsum_batch_diagonal() -> None: + Eqn = "...ii ->...i" + node = onnx.helper.make_node( + "Einsum", inputs=["x"], outputs=["y"], equation=Eqn + ) + + X = np.random.randn(3, 5, 5) + Z = einsum_reference_implementation(Eqn, (X,)) + + expect(node, inputs=[X], outputs=[Z], name="test_einsum_batch_diagonal") + + @staticmethod + def export_einsum_inner_prod() -> None: + Eqn = "i,i" + node = onnx.helper.make_node( + "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn + ) + + X = np.random.randn(5) + Y = np.random.randn(5) + Z = einsum_reference_implementation(Eqn, (X, Y)) + + expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_inner_prod") + + @staticmethod + def export_einsum_batch_matmul() -> None: + Eqn = "bij, bjk -> bik" + node = onnx.helper.make_node( + "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn + ) + + X = np.random.randn(5, 2, 3) + Y = np.random.randn(5, 3, 4) + Z = einsum_reference_implementation(Eqn, (X, Y)) + + expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_batch_matmul") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/elu.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/elu.py new file mode 100644 index 0000000000000000000000000000000000000000..1a237dfc50073015029e84864a62fce2ea4ce493 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/elu.py @@ -0,0 +1,36 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Elu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Elu", inputs=["x"], outputs=["y"], alpha=2.0) + + x = np.array([-1, 0, 1]).astype(np.float32) + # expected output [-1.2642411, 0., 1.] + y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 + expect(node, inputs=[x], outputs=[y], name="test_elu_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 + expect(node, inputs=[x], outputs=[y], name="test_elu") + + @staticmethod + def export_elu_default() -> None: + default_alpha = 1.0 + node = onnx.helper.make_node( + "Elu", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha + expect(node, inputs=[x], outputs=[y], name="test_elu_default") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/equal.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/equal.py new file mode 100644 index 0000000000000000000000000000000000000000..ebb6abef27c2a334a4843b20c712b88b0d33a900 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/equal.py @@ -0,0 +1,61 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Equal(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + + x = (np.random.randn(3, 4, 5) * 10).astype(np.int32) + y = (np.random.randn(3, 4, 5) * 10).astype(np.int32) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal") + + @staticmethod + def export_equal_broadcast() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + + x = (np.random.randn(3, 4, 5) * 10).astype(np.int32) + y = (np.random.randn(5) * 10).astype(np.int32) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_bcast") + + @staticmethod + def export_equal_string() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + x = np.array(["string1", "string2"], dtype=np.dtype(object)) + y = np.array(["string1", "string3"], dtype=np.dtype(object)) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_string") + + @staticmethod + def export_equal_string_broadcast() -> None: + node = onnx.helper.make_node( + "Equal", + inputs=["x", "y"], + outputs=["z"], + ) + x = np.array(["string1", "string2"], dtype=np.dtype(object)) + y = np.array(["string1"], dtype=np.dtype(object)) + z = np.equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_equal_string_broadcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/erf.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/erf.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c4766aa3e904c82dc04900b9964622a098d4ff --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/erf.py @@ -0,0 +1,25 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import math + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Erf(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Erf", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + y = np.vectorize(math.erf)(x).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_erf") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/exp.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/exp.py new file mode 100644 index 0000000000000000000000000000000000000000..3e2031dc3290b8c1e5e852177330e901e10445a9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/exp.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Exp(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Exp", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.exp(x) # expected output [0.36787945, 1., 2.71828175] + expect(node, inputs=[x], outputs=[y], name="test_exp_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.exp(x) + expect(node, inputs=[x], outputs=[y], name="test_exp") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/expand.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/expand.py new file mode 100644 index 0000000000000000000000000000000000000000..c86f94f6c692772339c36cb421c046efde311ca7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/expand.py @@ -0,0 +1,65 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Expand(Base): + @staticmethod + def export_dim_changed() -> None: + node = onnx.helper.make_node( + "Expand", + inputs=["data", "new_shape"], + outputs=["expanded"], + ) + shape = [3, 1] + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[1.], [2.], [3.]] + new_shape = [2, 1, 6] + expanded = data * np.ones(new_shape, dtype=np.float32) + # print(expanded) + # [[[1., 1., 1., 1., 1., 1.], + # [2., 2., 2., 2., 2., 2.], + # [3., 3., 3., 3., 3., 3.]], + # + # [[1., 1., 1., 1., 1., 1.], + # [2., 2., 2., 2., 2., 2.], + # [3., 3., 3., 3., 3., 3.]]] + new_shape = np.array(new_shape, dtype=np.int64) + expect( + node, + inputs=[data, new_shape], + outputs=[expanded], + name="test_expand_dim_changed", + ) + + @staticmethod + def export_dim_unchanged() -> None: + node = onnx.helper.make_node( + "Expand", + inputs=["data", "new_shape"], + outputs=["expanded"], + ) + shape = [3, 1] + new_shape = [3, 4] + data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape) + # print(data) + # [[1.], [2.], [3.]] + expanded = np.tile(data, 4) + # print(expanded) + # [[1., 1., 1., 1.], + # [2., 2., 2., 2.], + # [3., 3., 3., 3.]] + new_shape = np.array(new_shape, dtype=np.int64) + expect( + node, + inputs=[data, new_shape], + outputs=[expanded], + name="test_expand_dim_unchanged", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/eyelike.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/eyelike.py new file mode 100644 index 0000000000000000000000000000000000000000..355f808ae2f6caf8d65d7e363f6dfd6e6a8f7135 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/eyelike.py @@ -0,0 +1,59 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class EyeLike(Base): + @staticmethod + def export_without_dtype() -> None: + shape = (4, 4) + node = onnx.helper.make_node( + "EyeLike", + inputs=["x"], + outputs=["y"], + ) + + x = np.random.randint(0, 100, size=shape, dtype=np.int32) + y = np.eye(shape[0], shape[1], dtype=np.int32) + expect(node, inputs=[x], outputs=[y], name="test_eyelike_without_dtype") + + @staticmethod + def export_with_dtype() -> None: + shape = (3, 4) + node = onnx.helper.make_node( + "EyeLike", + inputs=["x"], + outputs=["y"], + dtype=onnx.TensorProto.DOUBLE, + ) + + x = np.random.randint(0, 100, size=shape, dtype=np.int32) + y = np.eye(shape[0], shape[1], dtype=np.float64) + expect(node, inputs=[x], outputs=[y], name="test_eyelike_with_dtype") + + @staticmethod + def export_populate_off_main_diagonal() -> None: + shape = (4, 5) + off_diagonal_offset = 1 + node = onnx.helper.make_node( + "EyeLike", + inputs=["x"], + outputs=["y"], + k=off_diagonal_offset, + dtype=onnx.TensorProto.FLOAT, + ) + + x = np.random.randint(0, 100, size=shape, dtype=np.int32) + y = np.eye(shape[0], shape[1], k=off_diagonal_offset, dtype=np.float32) + expect( + node, + inputs=[x], + outputs=[y], + name="test_eyelike_populate_off_main_diagonal", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/flatten.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/flatten.py new file mode 100644 index 0000000000000000000000000000000000000000..7fe585a3fc9d369b6f3b1fa49cec2aa1cd6fd062 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/flatten.py @@ -0,0 +1,64 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Flatten(Base): + @staticmethod + def export() -> None: + shape = (2, 3, 4, 5) + a = np.random.random_sample(shape).astype(np.float32) + + for i in range(len(shape)): + node = onnx.helper.make_node( + "Flatten", + inputs=["a"], + outputs=["b"], + axis=i, + ) + + new_shape = (1, -1) if i == 0 else (np.prod(shape[0:i]).astype(int), -1) + b = np.reshape(a, new_shape) + expect(node, inputs=[a], outputs=[b], name="test_flatten_axis" + str(i)) + + @staticmethod + def export_flatten_with_default_axis() -> None: + node = onnx.helper.make_node( + "Flatten", + inputs=["a"], + outputs=["b"], # Default value for axis: axis=1 + ) + + shape = (5, 4, 3, 2) + a = np.random.random_sample(shape).astype(np.float32) + new_shape = (5, 24) + b = np.reshape(a, new_shape) + expect(node, inputs=[a], outputs=[b], name="test_flatten_default_axis") + + @staticmethod + def export_flatten_negative_axis() -> None: + shape = (2, 3, 4, 5) + a = np.random.random_sample(shape).astype(np.float32) + + for i in range(-len(shape), 0): + node = onnx.helper.make_node( + "Flatten", + inputs=["a"], + outputs=["b"], + axis=i, + ) + + new_shape = (np.prod(shape[0:i]).astype(int), -1) + b = np.reshape(a, new_shape) + expect( + node, + inputs=[a], + outputs=[b], + name="test_flatten_negative_axis" + str(abs(i)), + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/floor.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/floor.py new file mode 100644 index 0000000000000000000000000000000000000000..440b6ea8c446a3409550afac53739d3b72d5a255 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/floor.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Floor(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Floor", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.5, 1.2, 2]).astype(np.float32) + y = np.floor(x) # expected output [-2., 1., 2.] + expect(node, inputs=[x], outputs=[y], name="test_floor_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.floor(x) + expect(node, inputs=[x], outputs=[y], name="test_floor") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/gather.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/gather.py new file mode 100644 index 0000000000000000000000000000000000000000..cad3edbc3273d75299bf34fb0932871a0d08ed55 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/gather.py @@ -0,0 +1,90 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Gather(Base): + @staticmethod + def export_gather_0() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=0, + ) + data = np.random.randn(5, 4, 3, 2).astype(np.float32) + indices = np.array([0, 1, 3]) + y = np.take(data, indices, axis=0) + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_0", + ) + + @staticmethod + def export_gather_1() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=1, + ) + data = np.random.randn(5, 4, 3, 2).astype(np.float32) + indices = np.array([0, 1, 3]) + y = np.take(data, indices, axis=1) + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_1", + ) + + @staticmethod + def export_gather_2d_indices() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=1, + ) + data = np.random.randn(3, 3).astype(np.float32) + indices = np.array([[0, 2]]) + y = np.take(data, indices, axis=1) + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_2d_indices", + ) + + @staticmethod + def export_gather_negative_indices() -> None: + node = onnx.helper.make_node( + "Gather", + inputs=["data", "indices"], + outputs=["y"], + axis=0, + ) + data = np.arange(10).astype(np.float32) + indices = np.array([0, -9, -10]) + y = np.take(data, indices, axis=0) + + # print(y) + # [0. 1. 0.] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_negative_indices", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/gatherelements.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/gatherelements.py new file mode 100644 index 0000000000000000000000000000000000000000..57982d6943b02f483e7c2a0f5bab7840cdbf1b75 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/gatherelements.py @@ -0,0 +1,92 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# The below GatherElements' numpy implementation is from https://stackoverflow.com/a/46204790/11767360 +def gather_elements(data, indices, axis=0): # type: ignore + data_swaped = np.swapaxes(data, 0, axis) + index_swaped = np.swapaxes(indices, 0, axis) + gathered = np.choose(index_swaped, data_swaped, mode="wrap") + y = np.swapaxes(gathered, 0, axis) + return y + + +class GatherElements(Base): + @staticmethod + def export_gather_elements_0() -> None: + axis = 1 + node = onnx.helper.make_node( + "GatherElements", + inputs=["data", "indices"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1, 2], [3, 4]], dtype=np.float32) + indices = np.array([[0, 0], [1, 0]], dtype=np.int32) + + y = gather_elements(data, indices, axis) + # print(y) produces + # [[1, 1], + # [4, 3]] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_elements_0", + ) + + @staticmethod + def export_gather_elements_1() -> None: + axis = 0 + node = onnx.helper.make_node( + "GatherElements", + inputs=["data", "indices"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32) + indices = np.array([[1, 2, 0], [2, 0, 0]], dtype=np.int32) + + y = gather_elements(data, indices, axis) + # print(y) produces + # [[4, 8, 3], + # [7, 2, 3]] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_elements_1", + ) + + @staticmethod + def export_gather_elements_negative_indices() -> None: + axis = 0 + node = onnx.helper.make_node( + "GatherElements", + inputs=["data", "indices"], + outputs=["y"], + axis=axis, + ) + data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32) + indices = np.array([[-1, -2, 0], [-2, 0, 0]], dtype=np.int32) + + y = gather_elements(data, indices, axis) + # print(y) produces + # [[7, 5, 3], + # [4, 2, 3]] + + expect( + node, + inputs=[data, indices.astype(np.int64)], + outputs=[y], + name="test_gather_elements_negative_indices", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/gathernd.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/gathernd.py new file mode 100644 index 0000000000000000000000000000000000000000..0570f339809dddbf21ced7b09bd26887d0d67f66 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/gathernd.py @@ -0,0 +1,120 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def gather_nd_impl( + data: np.ndarray, indices: np.ndarray, batch_dims: int +) -> np.ndarray: + # Note the data rank - will be reused multiple times later + data_rank = len(data.shape) + + # Check input tensors' shape/rank condition + assert indices.shape[-1] <= data_rank + + # The list of data/indice shape of batch_dims + batch_dims_shape = [] + + # The number of elements in the batch_dims for data/indice array + batch_dims_size = 1 + + # Check the shape of indice and data are identicial for batch dims. + for i in range(batch_dims): + batch_dims_shape.append(indices.shape[i]) + batch_dims_size *= indices.shape[i] + + # Compute output of the op as below + + # Compute shape of output array + output_shape = ( + batch_dims_shape + list(indices.shape)[batch_dims:-1] + if (indices.shape[-1] == data_rank - batch_dims) + else batch_dims_shape + + list(indices.shape)[batch_dims:-1] + + list(data.shape)[batch_dims + indices.shape[-1] :] + ) + + # Placeholder for output data + output_data_buffer = [] + + # Flatten 'indices' to 2D array + reshaped_indices = indices.reshape(batch_dims_size, -1, indices.shape[-1]) + + # Flatten 'data' to array of shape (batch_dim_size, data.shape[batch_dimes:]) + reshaped_data = data.reshape((batch_dims_size,) + data.shape[batch_dims:]) + + # gather each scalar value from 'data' + for batch_dim in range(reshaped_indices.shape[0]): + for outer_dim in range(reshaped_indices.shape[1]): + gather_index = tuple(reshaped_indices[batch_dim][outer_dim]) + output_data_buffer.append(reshaped_data[(batch_dim, *gather_index)]) + return np.asarray(output_data_buffer, dtype=data.dtype).reshape(output_shape) + + +class GatherND(Base): + @staticmethod + def export_int32() -> None: + node = onnx.helper.make_node( + "GatherND", + inputs=["data", "indices"], + outputs=["output"], + ) + + data = np.array([[0, 1], [2, 3]], dtype=np.int32) + indices = np.array([[0, 0], [1, 1]], dtype=np.int64) + output = gather_nd_impl(data, indices, 0) + expected_output = np.array([0, 3], dtype=np.int32) + assert np.array_equal(output, expected_output) + expect( + node, + inputs=[data, indices], + outputs=[output], + name="test_gathernd_example_int32", + ) + + @staticmethod + def export_float32() -> None: + node = onnx.helper.make_node( + "GatherND", + inputs=["data", "indices"], + outputs=["output"], + ) + + data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.float32) + indices = np.array([[[0, 1]], [[1, 0]]], dtype=np.int64) + output = gather_nd_impl(data, indices, 0) + expected_output = np.array([[[2, 3]], [[4, 5]]], dtype=np.float32) + assert np.array_equal(output, expected_output) + expect( + node, + inputs=[data, indices], + outputs=[output], + name="test_gathernd_example_float32", + ) + + @staticmethod + def export_int32_batchdim_1() -> None: + node = onnx.helper.make_node( + "GatherND", + inputs=["data", "indices"], + outputs=["output"], + batch_dims=1, + ) + + data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.int32) + indices = np.array([[1], [0]], dtype=np.int64) + output = gather_nd_impl(data, indices, 1) + expected_output = np.array([[2, 3], [4, 5]], dtype=np.int32) + assert np.array_equal(output, expected_output) + expect( + node, + inputs=[data, indices], + outputs=[output], + name="test_gathernd_example_int32_batch_dim1", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/gemm.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/gemm.py new file mode 100644 index 0000000000000000000000000000000000000000..8bc739e406a3f71510536bb860c9023ddab9e34f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/gemm.py @@ -0,0 +1,158 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Optional + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def gemm_reference_implementation( + A: np.ndarray, + B: np.ndarray, + C: Optional[np.ndarray] = None, + alpha: float = 1.0, + beta: float = 1.0, + transA: int = 0, + transB: int = 0, +) -> np.ndarray: + A = A if transA == 0 else A.T + B = B if transB == 0 else B.T + C = C if C is not None else np.array(0) + + Y = alpha * np.dot(A, B) + beta * C + + return Y + + +class Gemm(Base): + @staticmethod + def export_default_zero_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([3, 5]).astype(np.float32) + b = np.random.ranf([5, 4]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_zero_bias") + + @staticmethod + def export_default_no_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b"], outputs=["y"]) + a = np.random.ranf([2, 10]).astype(np.float32) + b = np.random.ranf([10, 3]).astype(np.float32) + y = gemm_reference_implementation(a, b) + expect(node, inputs=[a, b], outputs=[y], name="test_gemm_default_no_bias") + + @staticmethod + def export_default_scalar_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([2, 3]).astype(np.float32) + b = np.random.ranf([3, 4]).astype(np.float32) + c = np.array(3.14).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_scalar_bias" + ) + + @staticmethod + def export_default_single_elem_vector_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([3, 7]).astype(np.float32) + b = np.random.ranf([7, 3]).astype(np.float32) + c = np.random.ranf([1]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, + inputs=[a, b, c], + outputs=[y], + name="test_gemm_default_single_elem_vector_bias", + ) + + @staticmethod + def export_default_vector_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([2, 7]).astype(np.float32) + b = np.random.ranf([7, 4]).astype(np.float32) + c = np.random.ranf([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_vector_bias" + ) + + @staticmethod + def export_default_matrix_bias() -> None: + node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"]) + a = np.random.ranf([3, 6]).astype(np.float32) + b = np.random.ranf([6, 4]).astype(np.float32) + c = np.random.ranf([3, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c) + expect( + node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_matrix_bias" + ) + + @staticmethod + def export_transposeA() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], transA=1 + ) + a = np.random.ranf([6, 3]).astype(np.float32) + b = np.random.ranf([6, 4]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, transA=1) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeA") + + @staticmethod + def export_transposeB() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], transB=1 + ) + a = np.random.ranf([3, 6]).astype(np.float32) + b = np.random.ranf([4, 6]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, transB=1) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeB") + + @staticmethod + def export_alpha() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], alpha=0.5 + ) + a = np.random.ranf([3, 5]).astype(np.float32) + b = np.random.ranf([5, 4]).astype(np.float32) + c = np.zeros([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, alpha=0.5) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_alpha") + + @staticmethod + def export_beta() -> None: + node = onnx.helper.make_node( + "Gemm", inputs=["a", "b", "c"], outputs=["y"], beta=0.5 + ) + a = np.random.ranf([2, 7]).astype(np.float32) + b = np.random.ranf([7, 4]).astype(np.float32) + c = np.random.ranf([1, 4]).astype(np.float32) + y = gemm_reference_implementation(a, b, c, beta=0.5) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_beta") + + @staticmethod + def export_all_attributes() -> None: + node = onnx.helper.make_node( + "Gemm", + inputs=["a", "b", "c"], + outputs=["y"], + alpha=0.25, + beta=0.35, + transA=1, + transB=1, + ) + a = np.random.ranf([4, 3]).astype(np.float32) + b = np.random.ranf([5, 4]).astype(np.float32) + c = np.random.ranf([1, 5]).astype(np.float32) + y = gemm_reference_implementation( + a, b, c, transA=1, transB=1, alpha=0.25, beta=0.35 + ) + expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_all_attributes") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/globalaveragepool.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/globalaveragepool.py new file mode 100644 index 0000000000000000000000000000000000000000..3a1730f88b283460b23ca483d9e0bbc944a44146 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/globalaveragepool.py @@ -0,0 +1,43 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GlobalAveragePool(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "GlobalAveragePool", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(1, 3, 5, 5).astype(np.float32) + y = np.mean(x, axis=tuple(range(2, np.ndim(x))), keepdims=True) + expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool") + + @staticmethod + def export_globalaveragepool_precomputed() -> None: + node = onnx.helper.make_node( + "GlobalAveragePool", + inputs=["x"], + outputs=["y"], + ) + x = np.array( + [ + [ + [ + [1, 2, 3], + [4, 5, 6], + [7, 8, 9], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[5]]]]).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool_precomputed") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/globalmaxpool.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/globalmaxpool.py new file mode 100644 index 0000000000000000000000000000000000000000..bff8ef65dd9fc0461fe31566d9832ebd83eb5bc2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/globalmaxpool.py @@ -0,0 +1,43 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GlobalMaxPool(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "GlobalMaxPool", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(1, 3, 5, 5).astype(np.float32) + y = np.max(x, axis=tuple(range(2, np.ndim(x))), keepdims=True) + expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool") + + @staticmethod + def export_globalmaxpool_precomputed() -> None: + node = onnx.helper.make_node( + "GlobalMaxPool", + inputs=["x"], + outputs=["y"], + ) + x = np.array( + [ + [ + [ + [1, 2, 3], + [4, 5, 6], + [7, 8, 9], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[9]]]]).astype(np.float32) + expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool_precomputed") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/greater.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/greater.py new file mode 100644 index 0000000000000000000000000000000000000000..7241dde8e2bfc14fe8689f7ed77520084e7b2810 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/greater.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Greater(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Greater", + inputs=["x", "y"], + outputs=["greater"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater") + + @staticmethod + def export_greater_broadcast() -> None: + node = onnx.helper.make_node( + "Greater", + inputs=["x", "y"], + outputs=["greater"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.greater(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_bcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/greater_equal.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/greater_equal.py new file mode 100644 index 0000000000000000000000000000000000000000..d1e174f1a6fcc33cccc575d11d7440590e69aed0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/greater_equal.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Greater(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "GreaterOrEqual", + inputs=["x", "y"], + outputs=["greater_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal") + + @staticmethod + def export_greater_broadcast() -> None: + node = onnx.helper.make_node( + "GreaterOrEqual", + inputs=["x", "y"], + outputs=["greater_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.greater_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_bcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/gridsample.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/gridsample.py new file mode 100644 index 0000000000000000000000000000000000000000..94310f3d4419420f52eb2be3ee0c07552ed35579 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/gridsample.py @@ -0,0 +1,329 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GridSample(Base): + @staticmethod + def export_gridsample() -> None: + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="bilinear", + padding_mode="zeros", + align_corners=0, + ) + # X shape, [N, C, H, W] - [1, 1, 4, 4] + X = np.array( + [ + [ + [ + [0.0, 1.0, 2.0, 3.0], + [4.0, 5.0, 6.0, 7.0], + [8.0, 9.0, 10.0, 11.0], + [12.0, 13.0, 14.0, 15.0], + ] + ] + ], + dtype=np.float32, + ) + # Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2] + Grid = np.array( + [ + [ + [ + [-1.0000, -1.0000], + [-0.6000, -1.0000], + [-0.2000, -1.0000], + [0.2000, -1.0000], + [0.6000, -1.0000], + [1.0000, -1.0000], + ], + [ + [-1.0000, -0.6000], + [-0.6000, -0.6000], + [-0.2000, -0.6000], + [0.2000, -0.6000], + [0.6000, -0.6000], + [1.0000, -0.6000], + ], + [ + [-1.0000, -0.2000], + [-0.6000, -0.2000], + [-0.2000, -0.2000], + [0.2000, -0.2000], + [0.6000, -0.2000], + [1.0000, -0.2000], + ], + [ + [-1.0000, 0.2000], + [-0.6000, 0.2000], + [-0.2000, 0.2000], + [0.2000, 0.2000], + [0.6000, 0.2000], + [1.0000, 0.2000], + ], + [ + [-1.0000, 0.6000], + [-0.6000, 0.6000], + [-0.2000, 0.6000], + [0.2000, 0.6000], + [0.6000, 0.6000], + [1.0000, 0.6000], + ], + [ + [-1.0000, 1.0000], + [-0.6000, 1.0000], + [-0.2000, 1.0000], + [0.2000, 1.0000], + [0.6000, 1.0000], + [1.0000, 1.0000], + ], + ] + ], + dtype=np.float32, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6] + Y = np.array( + [ + [ + [ + [0.0000, 0.1500, 0.5500, 0.9500, 1.3500, 0.7500], + [0.6000, 1.5000, 2.3000, 3.1000, 3.9000, 2.1000], + [2.2000, 4.7000, 5.5000, 6.3000, 7.1000, 3.7000], + [3.8000, 7.9000, 8.7000, 9.5000, 10.3000, 5.3000], + [5.4000, 11.1000, 11.9000, 12.7000, 13.5000, 6.9000], + [3.0000, 6.1500, 6.5500, 6.9500, 7.3500, 3.7500], + ] + ] + ], + dtype=np.float32, + ) + expect(node, inputs=[X, Grid], outputs=[Y], name="test_gridsample") + + @staticmethod + def export_gridsample_paddingmode() -> None: + # X shape, [N, C, H, W] - [1, 1, 3, 2] + X = np.array( + [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]], + dtype=np.float32, + ) + # Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2] + Grid = np.array( + [ + [ + [ + [-10.0000, -10.0000], + [-5.0000, -5.0000], + [-0.2000, -0.2000], + [10.0000, 10.0000], + ], + [ + [10.0000, 10.0000], + [-0.2000, -0.2000], + [5.0000, 5.0000], + [10.0000, 10.0000], + ], + ] + ], + dtype=np.float32, + ) + + # setting padding_mode = 'zeros' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + padding_mode="zeros", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_zeros = np.array( + [[[[0.0000, 0.0000, 1.7000, 0.0000], [0.0000, 1.7000, 0.0000, 0.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_zeros], + name="test_gridsample_zeros_padding", + ) + + # setting padding_mode = 'border' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + padding_mode="border", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_border = np.array( + [[[[0.0000, 0.0000, 1.7000, 5.0000], [5.0000, 1.7000, 5.0000, 5.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_border], + name="test_gridsample_border_padding", + ) + + # setting padding_mode = 'reflection' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + padding_mode="reflection", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_reflection = np.array( + [[[[2.5000, 0.0000, 1.7000, 2.5000], [2.5000, 1.7000, 5.0000, 2.5000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_reflection], + name="test_gridsample_reflection_padding", + ) + + @staticmethod + def export_gridsample_mode_aligncorners() -> None: + # X shape, [N, C, H, W] - [1, 1, 3, 2] + X = np.array( + [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]], + dtype=np.float32, + ) + # Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2] + Grid = np.array( + [ + [ + [ + [-1.0000, -1.0000], + [-0.5000, -0.5000], + [-0.2000, -0.2000], + [0.0000, 0.0000], + ], + [ + [0.0000, 0.0000], + [-0.2000, -0.2000], + [0.5000, 0.5000], + [1.0000, 1.0000], + ], + ] + ], + dtype=np.float32, + ) + + # setting mode = 'bilinear', default align_corners = 0 + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="bilinear", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bilinear = np.array( + [[[[0.0000, 0.5000, 1.7000, 2.5000], [2.5000, 1.7000, 4.5000, 1.2500]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_bilinear], + name="test_gridsample_bilinear", + ) + + # setting mode = 'bilinear', align_corners = 1 + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="bilinear", + align_corners=1, + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_align_corners = np.array( + [[[[0.0000, 1.2500, 2.0000, 2.5000], [2.5000, 2.0000, 3.7500, 5.0000]]]], + dtype=np.float32, + ) + + expect( + node, + inputs=[X, Grid], + outputs=[Y_align_corners], + name="test_gridsample_aligncorners_true", + ) + + # setting mode = 'nearest' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="nearest", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_nearest = np.array( + [[[[0.0, 0.0, 2.0, 2.0], [2.0, 2.0, 5.0, 0.0]]]], + dtype=np.float32, + ) + + expect( + node, inputs=[X, Grid], outputs=[Y_nearest], name="test_gridsample_nearest" + ) + + # setting mode = 'bicubic' + node = onnx.helper.make_node( + "GridSample", + inputs=["X", "Grid"], + outputs=["Y"], + mode="bicubic", + ) + # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4] + Y_bicubic = np.array( + [[[[-0.1406, 0.3828, 1.7556, 2.9688], [2.9688, 1.7556, 5.1445, 1.3906]]]], + dtype=np.float32, + ) + + expect( + node, inputs=[X, Grid], outputs=[Y_bicubic], name="test_gridsample_bicubic" + ) + + """ + For someone who want to test by script. Comment it cause github ONNX CI + do not have the torch python package. + @staticmethod + def export_gridsample_torch(): # type: () -> None + node = onnx.helper.make_node( + 'GridSample', + inputs=['X', 'Grid'], + outputs=['Y'], + mode='bilinear', + padding_mode='zeros', + align_corners=0, + ) + + # X shape, [N, C, H, W] - [1, 1, 4, 4] + # Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2] + # Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6] + import torch + X = torch.arange(3 * 3).view(1, 1, 3, 3).float() + d = torch.linspace(-1, 1, 6) + meshx, meshy = torch.meshgrid((d, d)) + grid = torch.stack((meshy, meshx), 2) + Grid = grid.unsqueeze(0) + Y = torch.nn.functional.grid_sample(X, Grid, mode='bilinear', + padding_mode='zeros', align_corners=False) + expect(node, inputs=[X.numpy(), Grid.numpy()], outputs=[Y.numpy()], + name='test_gridsample_torch') + """ diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/groupnormalization.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/groupnormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..79ad0658846999a8f3911e2ee10c9a291b9e52b3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/groupnormalization.py @@ -0,0 +1,73 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# Group normalization's reference implementation +def _group_normalization(x, num_groups, scale, bias, epsilon=1e-5): + # Assume channel is first dim + assert x.shape[1] % num_groups == 0 + group_size = x.shape[1] // num_groups + # Reshape to [N, group_size, C/group_size, H, W, ...] + new_shape = [x.shape[0], num_groups, group_size, *list(x.shape[2:])] + x_reshaped = x.reshape(new_shape) + axes = tuple(range(2, len(new_shape))) + mean = np.mean(x_reshaped, axis=axes, keepdims=True) + var = np.var(x_reshaped, axis=axes, keepdims=True) + dim_ones = (1,) * (len(new_shape) - 2) + scale = scale.reshape(-1, *dim_ones) + bias = bias.reshape(-1, *dim_ones) + res = scale * (x_reshaped - mean) / np.sqrt(var + epsilon) + bias + return res.reshape(x.shape) + + +class GroupNormalization(Base): + @staticmethod + def export() -> None: + x = np.random.randn(3, 4, 2, 2).astype(np.float32) + num_groups = 2 + scale = np.random.randn(num_groups).astype(np.float32) + bias = np.random.randn(num_groups).astype(np.float32) + y = _group_normalization(x, num_groups, scale, bias).astype(np.float32) + + node = onnx.helper.make_node( + "GroupNormalization", + inputs=["x", "scale", "bias"], + outputs=["y"], + num_groups=num_groups, + ) + + expect( + node, + inputs=[x, scale, bias], + outputs=[y], + name="test_group_normalization_example", + ) + + x = np.random.randn(3, 4, 2, 2).astype(np.float32) + num_groups = 2 + scale = np.random.randn(num_groups).astype(np.float32) + bias = np.random.randn(num_groups).astype(np.float32) + epsilon = 1e-2 + y = _group_normalization(x, num_groups, scale, bias, epsilon).astype(np.float32) + + node = onnx.helper.make_node( + "GroupNormalization", + inputs=["x", "scale", "bias"], + outputs=["y"], + epsilon=epsilon, + num_groups=num_groups, + ) + + expect( + node, + inputs=[x, scale, bias], + outputs=[y], + name="test_group_normalization_epsilon", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/gru.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/gru.py new file mode 100644 index 0000000000000000000000000000000000000000..fed4c1791a4f8f72dedb16531d02d61db1101c6e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/gru.py @@ -0,0 +1,263 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Tuple + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class GRUHelper: + def __init__(self, **params: Any) -> None: + # GRU Input Names + X = "X" + W = "W" + R = "R" + B = "B" + H_0 = "initial_h" + LBR = "linear_before_reset" + LAYOUT = "layout" + number_of_gates = 3 + + required_inputs = [X, W, R] + for i in required_inputs: + assert i in params, f"Missing Required Input: {i}" + + self.num_directions = params[W].shape[0] + + if self.num_directions == 1: + for k in params: + if k != X: + params[k] = np.squeeze(params[k], axis=0) + + hidden_size = params[R].shape[-1] + batch_size = params[X].shape[1] + + layout = params[LAYOUT] if LAYOUT in params else 0 + x = params[X] + x = x if layout == 0 else np.swapaxes(x, 0, 1) + b = ( + params[B] + if B in params + else np.zeros(2 * number_of_gates * hidden_size) + ) + h_0 = params[H_0] if H_0 in params else np.zeros((batch_size, hidden_size)) + lbr = params[LBR] if LBR in params else 0 + + self.X = x + self.W = params[W] + self.R = params[R] + self.B = b + self.H_0 = h_0 + self.LBR = lbr + self.LAYOUT = layout + + else: + raise NotImplementedError() + + def f(self, x: np.ndarray) -> np.ndarray: + return 1 / (1 + np.exp(-x)) + + def g(self, x: np.ndarray) -> np.ndarray: + return np.tanh(x) + + def step(self) -> Tuple[np.ndarray, np.ndarray]: + seq_length = self.X.shape[0] + hidden_size = self.H_0.shape[-1] + batch_size = self.X.shape[1] + + Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size]) + h_list = [] + + [w_z, w_r, w_h] = np.split(self.W, 3) + [r_z, r_r, r_h] = np.split(self.R, 3) + [w_bz, w_br, w_bh, r_bz, r_br, r_bh] = np.split(self.B, 6) + gates_w = np.transpose(np.concatenate((w_z, w_r))) + gates_r = np.transpose(np.concatenate((r_z, r_r))) + gates_b = np.add(np.concatenate((w_bz, w_br)), np.concatenate((r_bz, r_br))) + + H_t = self.H_0 + for x in np.split(self.X, self.X.shape[0], axis=0): + gates = np.dot(x, gates_w) + np.dot(H_t, gates_r) + gates_b + z, r = np.split(gates, 2, -1) + z = self.f(z) + r = self.f(r) + h_default = self.g( + np.dot(x, np.transpose(w_h)) + + np.dot(r * H_t, np.transpose(r_h)) + + w_bh + + r_bh + ) + h_linear = self.g( + np.dot(x, np.transpose(w_h)) + + r * (np.dot(H_t, np.transpose(r_h)) + r_bh) + + w_bh + ) + h = h_linear if self.LBR else h_default + H = (1 - z) * h + z * H_t + h_list.append(H) + H_t = H + + concatenated = np.concatenate(h_list) + if self.num_directions == 1: + Y[:, 0, :, :] = concatenated + + if self.LAYOUT == 0: + Y_h = Y[-1] + else: + Y = np.transpose(Y, [2, 0, 1, 3]) + Y_h = Y[:, :, -1, :] + + return Y, Y_h + + +class GRU(Base): + @staticmethod + def export_defaults() -> None: + input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 5 + weight_scale = 0.1 + number_of_gates = 3 + + node = onnx.helper.make_node( + "GRU", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + gru = GRUHelper(X=input, W=W, R=R) + _, Y_h = gru.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y_h.astype(np.float32)], + name="test_gru_defaults", + ) + + @staticmethod + def export_initial_bias() -> None: + input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype( + np.float32 + ) + + input_size = 3 + hidden_size = 3 + weight_scale = 0.1 + custom_bias = 0.1 + number_of_gates = 3 + + node = onnx.helper.make_node( + "GRU", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + # Adding custom bias + W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype( + np.float32 + ) + R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32) + B = np.concatenate((W_B, R_B), axis=1) + + gru = GRUHelper(X=input, W=W, R=R, B=B) + _, Y_h = gru.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_gru_with_initial_bias", + ) + + @staticmethod + def export_seq_length() -> None: + input = np.array( + [ + [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], + [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]], + ] + ).astype(np.float32) + + input_size = 3 + hidden_size = 5 + number_of_gates = 3 + + node = onnx.helper.make_node( + "GRU", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = np.random.randn(1, number_of_gates * hidden_size, input_size).astype( + np.float32 + ) + R = np.random.randn(1, number_of_gates * hidden_size, hidden_size).astype( + np.float32 + ) + + # Adding custom bias + W_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32) + R_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32) + B = np.concatenate((W_B, R_B), axis=1) + + gru = GRUHelper(X=input, W=W, R=R, B=B) + _, Y_h = gru.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_gru_seq_length", + ) + + @staticmethod + def export_batchwise() -> None: + input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 6 + number_of_gates = 3 + weight_scale = 0.2 + layout = 1 + + node = onnx.helper.make_node( + "GRU", + inputs=["X", "W", "R"], + outputs=["Y", "Y_h"], + hidden_size=hidden_size, + layout=layout, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + gru = GRUHelper(X=input, W=W, R=R, layout=layout) + Y, Y_h = gru.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y.astype(np.float32), Y_h.astype(np.float32)], + name="test_gru_batchwise", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/hammingwindow.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/hammingwindow.py new file mode 100644 index 0000000000000000000000000000000000000000..f5aef2bfbfce32508836557c98cd73a26db0d7a2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/hammingwindow.py @@ -0,0 +1,39 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class HammingWindow(Base): + @staticmethod + def export() -> None: + # Test periodic window + node = onnx.helper.make_node( + "HammingWindow", + inputs=["x"], + outputs=["y"], + ) + size = np.int32(10) + a0 = 25 / 46 + a1 = 1 - a0 + y = a0 - a1 * np.cos( + 2 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / size + ) + expect(node, inputs=[size], outputs=[y], name="test_hammingwindow") + + # Test symmetric window + node = onnx.helper.make_node( + "HammingWindow", inputs=["x"], outputs=["y"], periodic=0 + ) + size = np.int32(10) + a0 = 25 / 46 + a1 = 1 - a0 + y = a0 - a1 * np.cos( + 2 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + expect(node, inputs=[size], outputs=[y], name="test_hammingwindow_symmetric") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/hannwindow.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/hannwindow.py new file mode 100644 index 0000000000000000000000000000000000000000..fcf96fa67e29a13bfc1dab981ff99b1b6954d394 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/hannwindow.py @@ -0,0 +1,39 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class HannWindow(Base): + @staticmethod + def export() -> None: + # Test periodic window + node = onnx.helper.make_node( + "HannWindow", + inputs=["x"], + outputs=["y"], + ) + size = np.int32(10) + a0 = 0.5 + a1 = 0.5 + y = a0 - a1 * np.cos( + 2 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / size + ) + expect(node, inputs=[size], outputs=[y], name="test_hannwindow") + + # Test symmetric window + node = onnx.helper.make_node( + "HannWindow", inputs=["x"], outputs=["y"], periodic=0 + ) + size = np.int32(10) + a0 = 0.5 + a1 = 0.5 + y = a0 - a1 * np.cos( + 2 * 3.1415 * np.arange(0, size, 1, dtype=np.float32) / (size - 1) + ) + expect(node, inputs=[size], outputs=[y], name="test_hannwindow_symmetric") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/hardmax.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/hardmax.py new file mode 100644 index 0000000000000000000000000000000000000000..4751ef956578b98e614113676907cff21a1b9ac0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/hardmax.py @@ -0,0 +1,91 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def hardmax(x: np.ndarray, axis: int = -1) -> np.ndarray: + x_argmax = np.argmax(x, axis=axis) + y = np.zeros_like(x) + np.put_along_axis(y, np.expand_dims(x_argmax, axis=axis), 1, axis=axis) + return y + + +class Hardmax(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([[3, 0, 1, 2], [2, 5, 1, 0], [0, 1, 3, 2], [0, 1, 2, 3]]).astype( + np.float32 + ) + # expect result: + # [[1. 0. 0. 0.] + # [0. 1. 0. 0.] + # [0. 0. 1. 0.] + # [0. 0. 0. 1.]] + y = hardmax(x) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_example") + + # For multiple occurrences of the maximal values, the first occurrence is selected for one-hot output + x = np.array([[3, 3, 3, 1]]).astype(np.float32) + # expect result: + # [[1, 0, 0, 0]] + y = hardmax(x) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_one_hot") + + @staticmethod + def export_hardmax_axis() -> None: + x = np.random.randn(3, 4, 5).astype(np.float32) + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=0, + ) + y = hardmax(x, axis=0) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_0") + + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=1, + ) + y = hardmax(x, axis=1) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_1") + + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=2, + ) + y = hardmax(x, axis=2) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_2") + + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + axis=-1, + ) + y = hardmax(x, axis=-1) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_negative_axis") + + # default axis is -1 + node = onnx.helper.make_node( + "Hardmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_hardmax_default_axis") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/hardsigmoid.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/hardsigmoid.py new file mode 100644 index 0000000000000000000000000000000000000000..20bc543907ce8ece8678f5b1e7fbd32540528eb6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/hardsigmoid.py @@ -0,0 +1,38 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class HardSigmoid(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "HardSigmoid", inputs=["x"], outputs=["y"], alpha=0.5, beta=0.6 + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + y = np.clip(x * 0.5 + 0.6, 0, 1) # expected output [0.1, 0.6, 1.] + expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x * 0.5 + 0.6, 0, 1) + expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid") + + @staticmethod + def export_hardsigmoid_default() -> None: + default_alpha = 0.2 + default_beta = 0.5 + node = onnx.helper.make_node( + "HardSigmoid", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x * default_alpha + default_beta, 0, 1) + expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_default") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/hardswish.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/hardswish.py new file mode 100644 index 0000000000000000000000000000000000000000..61678d777a716168ccae3463a3b7fc7dbbb11023 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/hardswish.py @@ -0,0 +1,29 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def hardswish(x: np.ndarray) -> np.ndarray: + alfa = float(1 / 6) + beta = 0.5 + return x * np.maximum(0, np.minimum(1, alfa * x + beta)) + + +class HardSwish(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "HardSwish", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = hardswish(x) + + expect(node, inputs=[x], outputs=[y], name="test_hardswish") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/identity.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/identity.py new file mode 100644 index 0000000000000000000000000000000000000000..984bdfd301c072169aa35a4403fbefba3a846b4e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/identity.py @@ -0,0 +1,92 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Identity(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Identity", + inputs=["x"], + outputs=["y"], + ) + + data = np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ) + + expect(node, inputs=[data], outputs=[data], name="test_identity") + + @staticmethod + def export_sequence() -> None: + node = onnx.helper.make_node( + "Identity", + inputs=["x"], + outputs=["y"], + ) + + data = [ + np.array( + [ + [ + [ + [1, 2], + [3, 4], + ] + ] + ], + dtype=np.float32, + ), + np.array( + [ + [ + [ + [2, 3], + [1, 5], + ] + ] + ], + dtype=np.float32, + ), + ] + + expect(node, inputs=[data], outputs=[data], name="test_identity_sequence") + + @staticmethod + def export_identity_opt() -> None: + ten_in_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp) + opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["opt_in"], outputs=["opt_out"] + ) + + x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)] + + expect( + identity_node, + inputs=[x], + outputs=[x], + name="test_identity_opt", + opset_imports=[onnx.helper.make_opsetid("", 16)], + input_type_protos=[opt_in_tp], + output_type_protos=[opt_in_tp], + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/if.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/if.py new file mode 100644 index 0000000000000000000000000000000000000000..684842983030c6db43477b32a2985313927d7407 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/if.py @@ -0,0 +1,210 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def compute_if_outputs(x, cond): # type: ignore + if cond: + return [] + else: + return x + + +class If(Base): + @staticmethod + def export_if() -> None: + # Given a bool scalar input cond. + # return constant tensor x if cond is True, otherwise return constant tensor y. + + then_out = onnx.helper.make_tensor_value_info( + "then_out", onnx.TensorProto.FLOAT, [5] + ) + else_out = onnx.helper.make_tensor_value_info( + "else_out", onnx.TensorProto.FLOAT, [5] + ) + + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + y = np.array([5, 4, 3, 2, 1]).astype(np.float32) + + then_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["then_out"], + value=onnx.numpy_helper.from_array(x), + ) + + else_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["else_out"], + value=onnx.numpy_helper.from_array(y), + ) + + then_body = onnx.helper.make_graph( + [then_const_node], "then_body", [], [then_out] + ) + + else_body = onnx.helper.make_graph( + [else_const_node], "else_body", [], [else_out] + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["cond"], + outputs=["res"], + then_branch=then_body, + else_branch=else_body, + ) + + cond = np.array(1).astype(bool) + res = x if cond else y + expect( + if_node, + inputs=[cond], + outputs=[res], + name="test_if", + opset_imports=[onnx.helper.make_opsetid("", 11)], + ) + + @staticmethod + def export_if_seq() -> None: + # Given a bool scalar input cond. + # return constant sequence x if cond is True, otherwise return constant sequence y. + + then_out = onnx.helper.make_tensor_sequence_value_info( + "then_out", onnx.TensorProto.FLOAT, shape=[5] + ) + else_out = onnx.helper.make_tensor_sequence_value_info( + "else_out", onnx.TensorProto.FLOAT, shape=[5] + ) + + x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)] + y = [np.array([5, 4, 3, 2, 1]).astype(np.float32)] + + then_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.numpy_helper.from_array(x[0]), + ) + + then_seq_node = onnx.helper.make_node( + "SequenceConstruct", inputs=["x"], outputs=["then_out"] + ) + + else_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["y"], + value=onnx.numpy_helper.from_array(y[0]), + ) + + else_seq_node = onnx.helper.make_node( + "SequenceConstruct", inputs=["y"], outputs=["else_out"] + ) + + then_body = onnx.helper.make_graph( + [then_const_node, then_seq_node], "then_body", [], [then_out] + ) + + else_body = onnx.helper.make_graph( + [else_const_node, else_seq_node], "else_body", [], [else_out] + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["cond"], + outputs=["res"], + then_branch=then_body, + else_branch=else_body, + ) + + cond = np.array(1).astype(bool) + res = x if cond else y + expect( + if_node, + inputs=[cond], + outputs=[res], + name="test_if_seq", + opset_imports=[onnx.helper.make_opsetid("", 13)], + ) + + @staticmethod + def export_if_optional() -> None: + # Given a bool scalar input cond, return an empty optional sequence of + # tensor if True, return an optional sequence with value x + # (the input optional sequence) otherwise. + + ten_in_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp) + + then_out_tensor_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + then_out_seq_tp = onnx.helper.make_sequence_type_proto(then_out_tensor_tp) + then_out_opt_tp = onnx.helper.make_optional_type_proto(then_out_seq_tp) + then_out = onnx.helper.make_value_info("optional_empty", then_out_opt_tp) + + else_out_tensor_tp = onnx.helper.make_tensor_type_proto( + onnx.TensorProto.FLOAT, shape=[5] + ) + else_out_seq_tp = onnx.helper.make_sequence_type_proto(else_out_tensor_tp) + else_out_opt_tp = onnx.helper.make_optional_type_proto(else_out_seq_tp) + else_out = onnx.helper.make_value_info("else_opt", else_out_opt_tp) + + x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)] + cond = np.array(0).astype(bool) + res = compute_if_outputs(x, cond) + + opt_empty_in = onnx.helper.make_node( + "Optional", inputs=[], outputs=["optional_empty"], type=seq_in_tp + ) + + then_body = onnx.helper.make_graph([opt_empty_in], "then_body", [], [then_out]) + + else_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.numpy_helper.from_array(x[0]), + ) + + else_seq_node = onnx.helper.make_node( + "SequenceConstruct", inputs=["x"], outputs=["else_seq"] + ) + + else_optional_seq_node = onnx.helper.make_node( + "Optional", inputs=["else_seq"], outputs=["else_opt"] + ) + + else_body = onnx.helper.make_graph( + [else_const_node, else_seq_node, else_optional_seq_node], + "else_body", + [], + [else_out], + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["cond"], + outputs=["sequence"], + then_branch=then_body, + else_branch=else_body, + ) + + expect( + if_node, + inputs=[cond], + outputs=[res], + name="test_if_opt", + output_type_protos=[else_out_opt_tp], + opset_imports=[onnx.helper.make_opsetid("", 16)], + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/instancenorm.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/instancenorm.py new file mode 100644 index 0000000000000000000000000000000000000000..f335dbebb094ec216a101c677a63eb5f4774e0c7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/instancenorm.py @@ -0,0 +1,55 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class InstanceNormalization(Base): + @staticmethod + def export() -> None: + def _instancenorm_test_mode(x, s, bias, epsilon=1e-5): # type: ignore + dims_x = len(x.shape) + axis = tuple(range(2, dims_x)) + mean = np.mean(x, axis=axis, keepdims=True) + var = np.var(x, axis=axis, keepdims=True) + dim_ones = (1,) * (dims_x - 2) + s = s.reshape(-1, *dim_ones) + bias = bias.reshape(-1, *dim_ones) + return s * (x - mean) / np.sqrt(var + epsilon) + bias + + # input size: (1, 2, 1, 3) + x = np.array([[[[-1, 0, 1]], [[2, 3, 4]]]]).astype(np.float32) + s = np.array([1.0, 1.5]).astype(np.float32) + bias = np.array([0, 1]).astype(np.float32) + y = _instancenorm_test_mode(x, s, bias).astype(np.float32) + + node = onnx.helper.make_node( + "InstanceNormalization", + inputs=["x", "s", "bias"], + outputs=["y"], + ) + + # output size: (1, 2, 1, 3) + expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_example") + + # input size: (2, 3, 4, 5) + x = np.random.randn(2, 3, 4, 5).astype(np.float32) + s = np.random.randn(3).astype(np.float32) + bias = np.random.randn(3).astype(np.float32) + epsilon = 1e-2 + y = _instancenorm_test_mode(x, s, bias, epsilon).astype(np.float32) + + node = onnx.helper.make_node( + "InstanceNormalization", + inputs=["x", "s", "bias"], + outputs=["y"], + epsilon=epsilon, + ) + + # output size: (2, 3, 4, 5) + expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_epsilon") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/isinf.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/isinf.py new file mode 100644 index 0000000000000000000000000000000000000000..18deb2b67726d23e2a6fab961af62de1010fcfeb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/isinf.py @@ -0,0 +1,43 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class IsInf(Base): + @staticmethod + def export_infinity() -> None: + node = onnx.helper.make_node( + "IsInf", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf], dtype=np.float32) + y = np.isinf(x) + expect(node, inputs=[x], outputs=[y], name="test_isinf") + + @staticmethod + def export_positive_infinity_only() -> None: + node = onnx.helper.make_node( + "IsInf", inputs=["x"], outputs=["y"], detect_negative=0 + ) + + x = np.array([-1.7, np.nan, np.inf, 3.6, np.NINF, np.inf], dtype=np.float32) + y = np.isposinf(x) + expect(node, inputs=[x], outputs=[y], name="test_isinf_positive") + + @staticmethod + def export_negative_infinity_only() -> None: + node = onnx.helper.make_node( + "IsInf", inputs=["x"], outputs=["y"], detect_positive=0 + ) + + x = np.array([-1.7, np.nan, np.inf, -3.6, np.NINF, np.inf], dtype=np.float32) + y = np.isneginf(x) + expect(node, inputs=[x], outputs=[y], name="test_isinf_negative") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/isnan.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/isnan.py new file mode 100644 index 0000000000000000000000000000000000000000..094b4e57c6b46f7e4a345dc37b6ad94e593a7c4a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/isnan.py @@ -0,0 +1,23 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class IsNaN(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "IsNaN", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([3.0, np.nan, 4.0, np.nan], dtype=np.float32) + y = np.isnan(x) + expect(node, inputs=[x], outputs=[y], name="test_isnan") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/layernormalization.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/layernormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..52b250a2ee67f7c9040c1c2c479e22020fe8c7e9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/layernormalization.py @@ -0,0 +1,177 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +# Layer normalization's reference implementation +def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5): # type: ignore + X_shape = X.shape + X_rank = len(X_shape) + if axis < 0: + # If axis = -1 and rank of X is 4, + # the axis is changed to -1 + 4 = 3, + # which means the last axis. + axis = axis + X_rank + unsqueezed_rank = X_rank - axis + reduction_shape = X_shape[0:axis] + (1,) * unsqueezed_rank + + # Parameter used to convert N-D tensor layer + # normalization to equivalent 2-D matirx operations. + row_number = 1 + col_number = 1 + for i in range(X_rank): + if i < axis: + row_number *= X_shape[i] + else: + col_number *= X_shape[i] + + # After reshaping input tensor X into a matrix, + # layer normalization is equivalent to conducting + # standardization on each column vector (s.t. each + # column has zero mean and unit variance). + x_mat = np.reshape(X, (row_number, col_number)) + # This computes mean for every x_mat's column. + x_mean = np.sum(x_mat, axis=1, keepdims=True) / col_number + x_diff = x_mat - x_mean + x_squared_diff = x_diff * x_diff + # This computes variance for every x_mat's column. + variance = np.sum(x_squared_diff, axis=1, keepdims=True) / col_number + variance_eps = variance + epsilon + std_dev = np.sqrt(variance_eps) + inv_std_dev = np.reciprocal(std_dev) + # Standardization step. y_mat is zero-mean and unit-variance. + y_mat = x_diff * inv_std_dev + # Apply affine transform on normalization outcome. + # W is linear coefficient while B is bias. + Y = np.reshape(y_mat, X_shape) * W + B + # Matrix-level operations' outputs should be reshaped + # to compensate the initial tensor-to-matrix reshape. + X_mean = np.reshape(x_mean, reduction_shape) + X_inv_std_dev = np.reshape(inv_std_dev, reduction_shape) + + return Y, X_mean, X_inv_std_dev + + +def calculate_normalized_shape(X_shape, axis): # type: ignore + X_rank = len(X_shape) + if axis < 0: + axis = axis + X_rank + return X_shape[axis:] + + +class LayerNormalization(Base): + @staticmethod + def export() -> None: + X = np.random.randn(2, 3, 4, 5).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis) + + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + axis=axis, + ) + + if axis < 0: + name = f"test_layer_normalization_4d_axis_negative_{-axis}" + else: + name = f"test_layer_normalization_4d_axis{axis}" + + expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) + + @staticmethod + def export_default_axis() -> None: + X = np.random.randn(2, 3, 4, 5).astype(np.float32) + + # Default axis in LayerNormalization is -1. + normalized_shape = calculate_normalized_shape(X.shape, -1) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + # Axis is default to -1 in the reference implementation. + Y, mean, inv_std_dev = _layer_normalization(X, W, B) + + # Not specifying axis attribute means -1. + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + ) + + expect( + node, + inputs=[X, W, B], + outputs=[Y, mean, inv_std_dev], + name="test_layer_normalization_default_axis", + ) + + @staticmethod + def export2d() -> None: + X = np.random.randn(3, 4).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis=axis) + + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + axis=axis, + ) + + if axis < 0: + name = f"test_layer_normalization_2d_axis_negative_{-axis}" + else: + name = f"test_layer_normalization_2d_axis{axis}" + + expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) + + @staticmethod + def export3d_epsilon() -> None: + epsilon = 1e-1 + X = np.random.randn(2, 3, 5).astype(np.float32) + + def case(axis: int) -> None: + normalized_shape = calculate_normalized_shape(X.shape, axis) + W = np.random.randn(*normalized_shape).astype(np.float32) + B = np.random.randn(*normalized_shape).astype(np.float32) + Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis, epsilon) + node = onnx.helper.make_node( + "LayerNormalization", + inputs=["X", "W", "B"], + outputs=["Y", "Mean", "InvStdDev"], + axis=axis, + epsilon=epsilon, + ) + + if axis < 0: + name = f"test_layer_normalization_3d_axis_negative_{-axis}_epsilon" + else: + name = f"test_layer_normalization_3d_axis{axis}_epsilon" + + expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name) + + for i in range(len(X.shape)): + case(i) + case(i - len(X.shape)) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/leakyrelu.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/leakyrelu.py new file mode 100644 index 0000000000000000000000000000000000000000..ca13351e6eb2a4182b600d56a388d435ba2f5ac3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/leakyrelu.py @@ -0,0 +1,38 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class LeakyRelu(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "LeakyRelu", inputs=["x"], outputs=["y"], alpha=0.1 + ) + + x = np.array([-1, 0, 1]).astype(np.float32) + # expected output [-0.1, 0., 1.] + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1 + expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_example") + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1 + expect(node, inputs=[x], outputs=[y], name="test_leakyrelu") + + @staticmethod + def export_leakyrelu_default() -> None: + default_alpha = 0.01 + node = onnx.helper.make_node( + "LeakyRelu", + inputs=["x"], + outputs=["y"], + ) + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * default_alpha + expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_default") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/less.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/less.py new file mode 100644 index 0000000000000000000000000000000000000000..fe57ec139544f1b21c17f5a65787aba3781c5860 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/less.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Less(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Less", + inputs=["x", "y"], + outputs=["less"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less") + + @staticmethod + def export_less_broadcast() -> None: + node = onnx.helper.make_node( + "Less", + inputs=["x", "y"], + outputs=["less"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.less(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_bcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/less_equal.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/less_equal.py new file mode 100644 index 0000000000000000000000000000000000000000..3852fec02c090ea3b7432511dd1c10c3614d2206 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/less_equal.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Less(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "LessOrEqual", + inputs=["x", "y"], + outputs=["less_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(3, 4, 5).astype(np.float32) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal") + + @staticmethod + def export_less_broadcast() -> None: + node = onnx.helper.make_node( + "LessOrEqual", + inputs=["x", "y"], + outputs=["less_equal"], + ) + + x = np.random.randn(3, 4, 5).astype(np.float32) + y = np.random.randn(5).astype(np.float32) + z = np.less_equal(x, y) + expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_bcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/log.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/log.py new file mode 100644 index 0000000000000000000000000000000000000000..3570517a83e1d79ae9053ee2ead2f3e812d8f651 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/log.py @@ -0,0 +1,27 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Log(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "Log", + inputs=["x"], + outputs=["y"], + ) + + x = np.array([1, 10]).astype(np.float32) + y = np.log(x) # expected output [0., 2.30258512] + expect(node, inputs=[x], outputs=[y], name="test_log_example") + + x = np.exp(np.random.randn(3, 4, 5).astype(np.float32)) + y = np.log(x) + expect(node, inputs=[x], outputs=[y], name="test_log") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/logsoftmax.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/logsoftmax.py new file mode 100644 index 0000000000000000000000000000000000000000..29e8d0a7e3a42afc5d490e99c5a138687154af42 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/logsoftmax.py @@ -0,0 +1,91 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def logsoftmax(x: np.ndarray, axis: int = -1) -> np.ndarray: + x_max = np.max(x, axis=axis, keepdims=True) + tmp = np.exp(x - x_max) + s = np.sum(tmp, axis=axis, keepdims=True) + return (x - x_max) - np.log(s) + + +class LogSoftmax(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + ) + x = np.array([[-1, 0, 1]]).astype(np.float32) + # expected output + # [[-2.4076061 -1.407606 -0.407606 ]] + y = logsoftmax(x) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_example_1") + + @staticmethod + def export_logsoftmax_axis() -> None: + x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32) + # expected output + # [[-3.4401896 -2.4401896 -1.4401896 -0.44018966] + # [-3.4401896 -2.4401896 -1.4401896 -0.44018966]] + y = logsoftmax(x) + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_large_number") + + x = np.abs(np.random.randn(3, 4, 5).astype(np.float32)) + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=0, + ) + y = logsoftmax(x, axis=0) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_0") + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=1, + ) + y = logsoftmax(x, axis=1) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_1") + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=2, + ) + y = logsoftmax(x, axis=2) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_2") + + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + axis=-1, + ) + y = logsoftmax(x, axis=-1) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_negative_axis") + + # default axis is -1 + node = onnx.helper.make_node( + "LogSoftmax", + inputs=["x"], + outputs=["y"], + ) + expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_default_axis") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/loop.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/loop.py new file mode 100644 index 0000000000000000000000000000000000000000..a4486a5cee269eb4bea013b294c66fe97130c274 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/loop.py @@ -0,0 +1,458 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, List + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +def compute_loop_outputs(x, seq, trip_count): # type: ignore + for i in range(trip_count): + if seq is None: + seq = [] + seq += [x[: int(i + 1)]] + return seq + + +class Loop(Base): + @staticmethod + def export_loop_11() -> None: + # Given a tensor x of values [x1, ..., xN], and initial tensor y + # sum up its elements using a scan + # returning the final state (y+x1+x2+...+xN) as well the scan_output + # [y+x1, y+x1+x2, ..., y+x1+x2+...+xN] + + y_in = onnx.helper.make_tensor_value_info("y_in", onnx.TensorProto.FLOAT, [1]) + y_out = onnx.helper.make_tensor_value_info("y_out", onnx.TensorProto.FLOAT, [1]) + scan_out = onnx.helper.make_tensor_value_info( + "scan_out", onnx.TensorProto.FLOAT, [1] + ) + cond_in = onnx.helper.make_tensor_value_info( + "cond_in", onnx.TensorProto.BOOL, [] + ) + cond_out = onnx.helper.make_tensor_value_info( + "cond_out", onnx.TensorProto.BOOL, [] + ) + iter_count = onnx.helper.make_tensor_value_info( + "iter_count", onnx.TensorProto.INT64, [] + ) + + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + y = np.array([-2]).astype(np.float32) + + x_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.helper.make_tensor( + name="const_tensor_x", + data_type=onnx.TensorProto.FLOAT, + dims=x.shape, + vals=x.flatten().astype(float), + ), + ) + + one_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["one"], + value=onnx.helper.make_tensor( + name="const_tensor_one", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[1], + ), + ) + + i_add_node = onnx.helper.make_node( + "Add", inputs=["iter_count", "one"], outputs=["end"] + ) + + start_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["iter_count"], outputs=["slice_start"], axes=[0] + ) + + end_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["end"], outputs=["slice_end"], axes=[0] + ) + + slice_node = onnx.helper.make_node( + "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"] + ) + + y_add_node = onnx.helper.make_node( + "Add", inputs=["y_in", "slice_out"], outputs=["y_out"] + ) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["cond_in"], outputs=["cond_out"] + ) + + scan_identity_node = onnx.helper.make_node( + "Identity", inputs=["y_out"], outputs=["scan_out"] + ) + + loop_body = onnx.helper.make_graph( + [ + identity_node, + x_const_node, + one_const_node, + i_add_node, + start_unsqueeze_node, + end_unsqueeze_node, + slice_node, + y_add_node, + scan_identity_node, + ], + "loop_body", + [iter_count, cond_in, y_in], + [cond_out, y_out, scan_out], + ) + + node = onnx.helper.make_node( + "Loop", + inputs=["trip_count", "cond", "y"], + outputs=["res_y", "res_scan"], + body=loop_body, + ) + + trip_count = np.array(5).astype(np.int64) + res_y = np.array([13]).astype(np.float32) + cond = np.array(1).astype(bool) + res_scan = np.array([-1, 1, 4, 8, 13]).astype(np.float32).reshape((5, 1)) + expect( + node, + inputs=[trip_count, cond, y], + outputs=[res_y, res_scan], + name="test_loop11", + opset_imports=[onnx.helper.make_opsetid("", 11)], + ) + + @staticmethod + def export_loop_13() -> None: + # Given a tensor x of values [x1, ..., xN], + # Return a sequence of tensors of + # [[x1], [x1, x2], ..., [x1, ..., xN]] + + seq_in = onnx.helper.make_tensor_sequence_value_info( + "seq_in", onnx.TensorProto.FLOAT, None + ) + seq_out = onnx.helper.make_tensor_sequence_value_info( + "seq_out", onnx.TensorProto.FLOAT, None + ) + cond_in = onnx.helper.make_tensor_value_info( + "cond_in", onnx.TensorProto.BOOL, [] + ) + cond_out = onnx.helper.make_tensor_value_info( + "cond_out", onnx.TensorProto.BOOL, [] + ) + iter_count = onnx.helper.make_tensor_value_info( + "iter_count", onnx.TensorProto.INT64, [] + ) + + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + + x_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.helper.make_tensor( + name="const_tensor_x", + data_type=onnx.TensorProto.FLOAT, + dims=x.shape, + vals=x.flatten().astype(float), + ), + ) + + one_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["one"], + value=onnx.helper.make_tensor( + name="const_tensor_one", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[1], + ), + ) + + zero_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["slice_start"], + value=onnx.helper.make_tensor( + name="const_tensor_zero", + data_type=onnx.TensorProto.INT64, + dims=(1,), + vals=[0], + ), + ) + + axes_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["axes"], + value=onnx.helper.make_tensor( + name="const_tensor_axes", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[0], + ), + ) + + add_node = onnx.helper.make_node( + "Add", inputs=["iter_count", "one"], outputs=["end"] + ) + + end_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"] + ) + + slice_node = onnx.helper.make_node( + "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"] + ) + + insert_node = onnx.helper.make_node( + "SequenceInsert", inputs=["seq_in", "slice_out"], outputs=["seq_out"] + ) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["cond_in"], outputs=["cond_out"] + ) + + loop_body = onnx.helper.make_graph( + [ + identity_node, + x_const_node, + one_const_node, + zero_const_node, + add_node, + axes_node, + end_unsqueeze_node, + slice_node, + insert_node, + ], + "loop_body", + [iter_count, cond_in, seq_in], + [cond_out, seq_out], + ) + + node = onnx.helper.make_node( + "Loop", + inputs=["trip_count", "cond", "seq_empty"], + outputs=["seq_res"], + body=loop_body, + ) + + trip_count = np.array(5).astype(np.int64) + seq_empty: List[Any] = [] + seq_res = [x[: int(i)] for i in x] + cond = np.array(1).astype(bool) + expect( + node, + inputs=[trip_count, cond, seq_empty], + outputs=[seq_res], + name="test_loop13_seq", + opset_imports=[onnx.helper.make_opsetid("", 13)], + input_type_protos=[ + onnx.helper.make_tensor_type_proto( + onnx.TensorProto.INT64, trip_count.shape + ), + onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape), + onnx.helper.make_sequence_type_proto( + onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, []) + ), + ], + ) + + @staticmethod + def export_loop_16_none() -> None: + # Given a tensor sequence of values [x1, ..., xN], and an initial optional sequence of tensors [x0], + # Return a concatenated sequence of tensors of + # [x0, [x1], [x1, x2], ..., [x1, ..., xN]] + + ten_in_tp = onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, []) + seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp) + opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp) + opt_in = onnx.helper.make_value_info("opt_seq_in", opt_in_tp) + seq_out = onnx.helper.make_tensor_sequence_value_info( + "seq_out", onnx.TensorProto.FLOAT, [] + ) + cond_in = onnx.helper.make_tensor_value_info( + "cond_in", onnx.TensorProto.BOOL, [] + ) + cond_out = onnx.helper.make_tensor_value_info( + "cond_out", onnx.TensorProto.BOOL, [] + ) + iter_count = onnx.helper.make_tensor_value_info( + "iter_count", onnx.TensorProto.INT64, [] + ) + + x0 = np.array(0).astype(np.float32) + x = np.array([1, 2, 3, 4, 5]).astype(np.float32) + + optional_has_elem_node = onnx.helper.make_node( + "OptionalHasElement", inputs=["opt_seq_in"], outputs=["optional_has_elem"] + ) + + optional_is_none = onnx.helper.make_node( + "Not", inputs=["optional_has_elem"], outputs=["optional_is_none"] + ) + + optional_get_elem = onnx.helper.make_node( + "OptionalGetElement", inputs=["opt_seq_in"], outputs=["seq_in"] + ) + + constant_in = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["constant_in"], + value=onnx.helper.make_tensor( + name="const_tensor", data_type=onnx.TensorProto.FLOAT, dims=(), vals=[0] + ), + ) + + seq_const_in = onnx.helper.make_node( + "SequenceConstruct", inputs=["constant_in"], outputs=["init_seq_in"] + ) + + then_seq_out = onnx.helper.make_tensor_sequence_value_info( + "init_seq_in", onnx.TensorProto.FLOAT, [] + ) + then_body = onnx.helper.make_graph( + [constant_in, seq_const_in], "then_body", [], [then_seq_out] + ) + + else_seq_out = onnx.helper.make_tensor_sequence_value_info( + "seq_in", onnx.TensorProto.FLOAT, [] + ) + else_body = onnx.helper.make_graph( + [optional_get_elem], "else_body", [], [else_seq_out] + ) + + if_node = onnx.helper.make_node( + "If", + inputs=["optional_is_none"], + outputs=["sequence"], + then_branch=then_body, + else_branch=else_body, + ) + + x_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["x"], + value=onnx.helper.make_tensor( + name="const_tensor_x", + data_type=onnx.TensorProto.FLOAT, + dims=x.shape, + vals=x.flatten().astype(float), + ), + ) + + one_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["one"], + value=onnx.helper.make_tensor( + name="const_tensor_one", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[1], + ), + ) + + zero_const_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["slice_start"], + value=onnx.helper.make_tensor( + name="const_tensor_zero", + data_type=onnx.TensorProto.INT64, + dims=(1,), + vals=[0], + ), + ) + + axes_node = onnx.helper.make_node( + "Constant", + inputs=[], + outputs=["axes"], + value=onnx.helper.make_tensor( + name="const_tensor_axes", + data_type=onnx.TensorProto.INT64, + dims=(), + vals=[0], + ), + ) + + add_node = onnx.helper.make_node( + "Add", inputs=["iter_count", "one"], outputs=["end"] + ) + + end_unsqueeze_node = onnx.helper.make_node( + "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"] + ) + + slice_node = onnx.helper.make_node( + "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"] + ) + + insert_node = onnx.helper.make_node( + "SequenceInsert", inputs=["sequence", "slice_out"], outputs=["seq_out"] + ) + + identity_node = onnx.helper.make_node( + "Identity", inputs=["cond_in"], outputs=["cond_out"] + ) + + loop_body = onnx.helper.make_graph( + [ + identity_node, + optional_has_elem_node, + optional_is_none, + if_node, + x_const_node, + one_const_node, + zero_const_node, + add_node, + axes_node, + end_unsqueeze_node, + slice_node, + insert_node, + ], + "loop_body", + [iter_count, cond_in, opt_in], + [cond_out, seq_out], + ) + + node = onnx.helper.make_node( + "Loop", + inputs=["trip_count", "cond", "opt_seq"], + outputs=["seq_res"], + body=loop_body, + ) + + trip_count = np.array(5).astype(np.int64) + cond = np.array(1).astype(bool) + seq_res = compute_loop_outputs(x, [x0], trip_count) + opt_seq_in: List[Any] = [x0] + expect( + node, + inputs=[trip_count, cond, opt_seq_in], + outputs=[seq_res], + name="test_loop16_seq_none", + opset_imports=[onnx.helper.make_opsetid("", 16)], + input_type_protos=[ + onnx.helper.make_tensor_type_proto( + onnx.TensorProto.INT64, trip_count.shape + ), + onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape), + opt_in_tp, + ], + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/lppool.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/lppool.py new file mode 100644 index 0000000000000000000000000000000000000000..e0e111bf612789ad980233bca5695cd12b44bce6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/lppool.py @@ -0,0 +1,279 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.backend.test.case.node.pool_op_common import ( + get_output_shape, + get_pad_shape, + pool, +) + + +class LpPool(Base): + @staticmethod + def export_lppool_1d_default() -> None: + """ + input_shape: [1, 3, 32] + output_shape: [1, 3, 31] + """ + p = 3 + kernel_shape = [2] + strides = [1] + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=kernel_shape, + strides=strides, + p=p, + ) + x = np.random.randn(1, 3, 32).astype(np.float32) + x_shape = np.shape(x) + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, [0], "LPPOOL", p=p) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_1d_default") + + @staticmethod + def export_lppool_2d_default() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 31, 31] + """ + p = 4 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "LPPOOL", p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_default") + + @staticmethod + def export_lppool_3d_default() -> None: + """ + input_shape: [1, 3, 32, 32, 32] + output_shape: [1, 3, 31, 31, 31] + """ + p = 3 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + p=p, + ) + x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = [2, 2, 2] + strides = [1, 1, 1] + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, [0, 0, 0], "LPPOOL", p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_3d_default") + + @staticmethod + def export_lppool_2d_same_upper() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [0, 1, 0, 1] by axis + """ + p = 2 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_UPPER", + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("SAME_UPPER", x_shape[2:], kernel_shape, strides) + pad_shape = get_pad_shape( + "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_top = pad_shape[0] // 2 + pad_bottom = pad_shape[0] - pad_top + pad_left = pad_shape[1] // 2 + pad_right = pad_shape[1] - pad_left + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=0, + ) + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "LPPOOL", p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_upper") + + @staticmethod + def export_lppool_2d_same_lower() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [1, 0, 1, 0] by axis + """ + p = 4 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_LOWER", + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("SAME_LOWER", x_shape[2:], kernel_shape, strides) + pad_shape = get_pad_shape( + "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_bottom = pad_shape[0] // 2 + pad_top = pad_shape[0] - pad_bottom + pad_right = pad_shape[1] // 2 + pad_left = pad_shape[1] - pad_right + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=0, + ) + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "LPPOOL", p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_lower") + + @staticmethod + def export_lppool_2d_pads() -> None: + """ + input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + p = 3 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + p=p, + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = pad_top = pad_right = pad_left = 2 + pad_shape = [pad_top + pad_bottom, pad_left + pad_right] + out_shape = get_output_shape( + "VALID", np.add(x_shape[2:], pad_shape), kernel_shape, strides + ) + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=0, + ) + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "LPPOOL", p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_pads") + + @staticmethod + def export_lppool_2d_strides() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 10, 10] + """ + p = 2 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + strides=[3, 3], + p=p, + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (5, 5) + strides = (3, 3) + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool( + padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "LPPOOL", p=p + ) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_strides") + + @staticmethod + def export_lppool_2d_dilations() -> None: + """ + input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + p = 2 + node = onnx.helper.make_node( + "LpPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[1, 1], + dilations=[2, 2], + p=p, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + + y = np.array( + [ + [ + [ + [14.560219778561036, 16.24807680927192], + [21.633307652783937, 23.49468024894146], + ] + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_dilations") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/lrn.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/lrn.py new file mode 100644 index 0000000000000000000000000000000000000000..43b53c708f8e0f306cfedd4e82a53241f088a38a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/lrn.py @@ -0,0 +1,69 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import math + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class LRN(Base): + @staticmethod + def export() -> None: + alpha = 0.0002 + beta = 0.5 + bias = 2.0 + nsize = 3 + node = onnx.helper.make_node( + "LRN", + inputs=["x"], + outputs=["y"], + alpha=alpha, + beta=beta, + bias=bias, + size=nsize, + ) + x = np.random.randn(5, 5, 5, 5).astype(np.float32) + square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32) + for n, c, h, w in np.ndindex(x.shape): + square_sum[n, c, h, w] = sum( + x[ + n, + max(0, c - int(math.floor((nsize - 1) / 2))) : min( + 5, c + int(math.ceil((nsize - 1) / 2)) + 1 + ), + h, + w, + ] + ** 2 + ) + y = x / ((bias + (alpha / nsize) * square_sum) ** beta) + expect(node, inputs=[x], outputs=[y], name="test_lrn") + + @staticmethod + def export_default() -> None: + alpha = 0.0001 + beta = 0.75 + bias = 1.0 + nsize = 3 + node = onnx.helper.make_node("LRN", inputs=["x"], outputs=["y"], size=3) + x = np.random.randn(5, 5, 5, 5).astype(np.float32) + square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32) + for n, c, h, w in np.ndindex(x.shape): + square_sum[n, c, h, w] = sum( + x[ + n, + max(0, c - int(math.floor((nsize - 1) / 2))) : min( + 5, c + int(math.ceil((nsize - 1) / 2)) + 1 + ), + h, + w, + ] + ** 2 + ) + y = x / ((bias + (alpha / nsize) * square_sum) ** beta) + expect(node, inputs=[x], outputs=[y], name="test_lrn_default") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/lstm.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/lstm.py new file mode 100644 index 0000000000000000000000000000000000000000..c4dfab7d52421acb0c442efc31f1c7780992d0fe --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/lstm.py @@ -0,0 +1,277 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Tuple + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class LSTMHelper: + def __init__(self, **params: Any) -> None: + # LSTM Input Names + X = "X" + W = "W" + R = "R" + B = "B" + H_0 = "initial_h" + C_0 = "initial_c" + P = "P" + LAYOUT = "layout" + number_of_gates = 4 + number_of_peepholes = 3 + + required_inputs = [X, W, R] + for i in required_inputs: + assert i in params, f"Missing Required Input: {i}" + + self.num_directions = params[W].shape[0] + + if self.num_directions == 1: + for k in params: + if k != X: + params[k] = np.squeeze(params[k], axis=0) + + hidden_size = params[R].shape[-1] + batch_size = params[X].shape[1] + + layout = params[LAYOUT] if LAYOUT in params else 0 + x = params[X] + x = x if layout == 0 else np.swapaxes(x, 0, 1) + b = ( + params[B] + if B in params + else np.zeros(2 * number_of_gates * hidden_size, dtype=np.float32) + ) + p = ( + params[P] + if P in params + else np.zeros(number_of_peepholes * hidden_size, dtype=np.float32) + ) + h_0 = ( + params[H_0] + if H_0 in params + else np.zeros((batch_size, hidden_size), dtype=np.float32) + ) + c_0 = ( + params[C_0] + if C_0 in params + else np.zeros((batch_size, hidden_size), dtype=np.float32) + ) + + self.X = x + self.W = params[W] + self.R = params[R] + self.B = b + self.P = p + self.H_0 = h_0 + self.C_0 = c_0 + self.LAYOUT = layout + + else: + raise NotImplementedError() + + def f(self, x: np.ndarray) -> np.ndarray: + return 1 / (1 + np.exp(-x)) + + def g(self, x: np.ndarray) -> np.ndarray: + return np.tanh(x) + + def h(self, x: np.ndarray) -> np.ndarray: + return np.tanh(x) + + def step(self) -> Tuple[np.ndarray, np.ndarray]: + seq_length = self.X.shape[0] + hidden_size = self.H_0.shape[-1] + batch_size = self.X.shape[1] + + Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size]) + h_list = [] + + [p_i, p_o, p_f] = np.split(self.P, 3) + H_t = self.H_0 + C_t = self.C_0 + for x in np.split(self.X, self.X.shape[0], axis=0): + gates = ( + np.dot(x, np.transpose(self.W)) + + np.dot(H_t, np.transpose(self.R)) + + np.add(*np.split(self.B, 2)) + ) + i, o, f, c = np.split(gates, 4, -1) + i = self.f(i + p_i * C_t) + f = self.f(f + p_f * C_t) + c = self.g(c) + C = f * C_t + i * c + o = self.f(o + p_o * C) + H = o * self.h(C) + h_list.append(H) + H_t = H + C_t = C + + concatenated = np.concatenate(h_list) + if self.num_directions == 1: + Y[:, 0, :, :] = concatenated + + if self.LAYOUT == 0: + Y_h = Y[-1] + else: + Y = np.transpose(Y, [2, 0, 1, 3]) + Y_h = Y[:, :, -1, :] + + return Y, Y_h + + +class LSTM(Base): + @staticmethod + def export_defaults() -> None: + input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 3 + weight_scale = 0.1 + number_of_gates = 4 + + node = onnx.helper.make_node( + "LSTM", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + lstm = LSTMHelper(X=input, W=W, R=R) + _, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y_h.astype(np.float32)], + name="test_lstm_defaults", + ) + + @staticmethod + def export_initial_bias() -> None: + input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype( + np.float32 + ) + + input_size = 3 + hidden_size = 4 + weight_scale = 0.1 + custom_bias = 0.1 + number_of_gates = 4 + + node = onnx.helper.make_node( + "LSTM", + inputs=["X", "W", "R", "B"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + # Adding custom bias + W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype( + np.float32 + ) + R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32) + B = np.concatenate((W_B, R_B), 1) + + lstm = LSTMHelper(X=input, W=W, R=R, B=B) + _, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R, B], + outputs=[Y_h.astype(np.float32)], + name="test_lstm_with_initial_bias", + ) + + @staticmethod + def export_peepholes() -> None: + input = np.array([[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]]).astype( + np.float32 + ) + + input_size = 4 + hidden_size = 3 + weight_scale = 0.1 + number_of_gates = 4 + number_of_peepholes = 3 + + node = onnx.helper.make_node( + "LSTM", + inputs=["X", "W", "R", "B", "sequence_lens", "initial_h", "initial_c", "P"], + outputs=["", "Y_h"], + hidden_size=hidden_size, + ) + + # Initializing Inputs + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + B = np.zeros((1, 2 * number_of_gates * hidden_size)).astype(np.float32) + seq_lens = np.repeat(input.shape[0], input.shape[1]).astype(np.int32) + init_h = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32) + init_c = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32) + P = weight_scale * np.ones((1, number_of_peepholes * hidden_size)).astype( + np.float32 + ) + + lstm = LSTMHelper( + X=input, W=W, R=R, B=B, P=P, initial_c=init_c, initial_h=init_h + ) + _, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R, B, seq_lens, init_h, init_c, P], + outputs=[Y_h.astype(np.float32)], + name="test_lstm_with_peepholes", + ) + + @staticmethod + def export_batchwise() -> None: + input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32) + + input_size = 2 + hidden_size = 7 + weight_scale = 0.3 + number_of_gates = 4 + layout = 1 + + node = onnx.helper.make_node( + "LSTM", + inputs=["X", "W", "R"], + outputs=["Y", "Y_h"], + hidden_size=hidden_size, + layout=layout, + ) + + W = weight_scale * np.ones( + (1, number_of_gates * hidden_size, input_size) + ).astype(np.float32) + R = weight_scale * np.ones( + (1, number_of_gates * hidden_size, hidden_size) + ).astype(np.float32) + + lstm = LSTMHelper(X=input, W=W, R=R, layout=layout) + Y, Y_h = lstm.step() + expect( + node, + inputs=[input, W, R], + outputs=[Y.astype(np.float32), Y_h.astype(np.float32)], + name="test_lstm_batchwise", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/matmul.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/matmul.py new file mode 100644 index 0000000000000000000000000000000000000000..60f2406decc898167c808afd3a38884b75e98696 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/matmul.py @@ -0,0 +1,37 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MatMul(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MatMul", + inputs=["a", "b"], + outputs=["c"], + ) + + # 2d + a = np.random.randn(3, 4).astype(np.float32) + b = np.random.randn(4, 3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_2d") + + # 3d + a = np.random.randn(2, 3, 4).astype(np.float32) + b = np.random.randn(2, 4, 3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_3d") + + # 4d + a = np.random.randn(1, 2, 3, 4).astype(np.float32) + b = np.random.randn(1, 2, 4, 3).astype(np.float32) + c = np.matmul(a, b) + expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/matmulinteger.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/matmulinteger.py new file mode 100644 index 0000000000000000000000000000000000000000..fee17590ec4ac7e6495d1a180cda862fac388a53 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/matmulinteger.py @@ -0,0 +1,59 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MatMulInteger(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MatMulInteger", + inputs=["A", "B", "a_zero_point", "b_zero_point"], + outputs=["Y"], + ) + + A = np.array( + [ + [11, 7, 3], + [10, 6, 2], + [9, 5, 1], + [8, 4, 0], + ], + dtype=np.uint8, + ) + + a_zero_point = np.array([12], dtype=np.uint8) + + B = np.array( + [ + [1, 4], + [2, 5], + [3, 6], + ], + dtype=np.uint8, + ) + + b_zero_point = np.array([0], dtype=np.uint8) + + output = np.array( + [ + [-38, -83], + [-44, -98], + [-50, -113], + [-56, -128], + ], + dtype=np.int32, + ) + + expect( + node, + inputs=[A, B, a_zero_point, b_zero_point], + outputs=[output], + name="test_matmulinteger", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/max.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/max.py new file mode 100644 index 0000000000000000000000000000000000000000..77569716b1c24b16198db341e333fc07f89a0865 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/max.py @@ -0,0 +1,65 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.backend.test.case.utils import all_numeric_dtypes + + +class Max(Base): + @staticmethod + def export() -> None: + data_0 = np.array([3, 2, 1]).astype(np.float32) + data_1 = np.array([1, 4, 4]).astype(np.float32) + data_2 = np.array([2, 5, 3]).astype(np.float32) + result = np.array([3, 5, 4]).astype(np.float32) + node = onnx.helper.make_node( + "Max", + inputs=["data_0", "data_1", "data_2"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1, data_2], + outputs=[result], + name="test_max_example", + ) + + node = onnx.helper.make_node( + "Max", + inputs=["data_0"], + outputs=["result"], + ) + expect(node, inputs=[data_0], outputs=[data_0], name="test_max_one_input") + + result = np.maximum(data_0, data_1) + node = onnx.helper.make_node( + "Max", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, inputs=[data_0, data_1], outputs=[result], name="test_max_two_inputs" + ) + + @staticmethod + def export_max_all_numeric_types() -> None: + for op_dtype in all_numeric_dtypes: + data_0 = np.array([3, 2, 1]).astype(op_dtype) + data_1 = np.array([1, 4, 4]).astype(op_dtype) + result = np.array([3, 4, 4]).astype(op_dtype) + node = onnx.helper.make_node( + "Max", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1], + outputs=[result], + name=f"test_max_{np.dtype(op_dtype).name}", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/maxpool.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/maxpool.py new file mode 100644 index 0000000000000000000000000000000000000000..dfd41fcc84ca7a80e43f31ec1559ac70deb86e9f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/maxpool.py @@ -0,0 +1,512 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.backend.test.case.node.pool_op_common import ( + get_output_shape, + get_pad_shape, + pool, +) + + +class MaxPool(Base): + @staticmethod + def export_maxpool_2d_uint8() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.uint8) + y = np.array( + [ + [ + [ + [13, 14, 15, 15, 15], + [18, 19, 20, 20, 20], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + ] + ] + ] + ).astype(np.uint8) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_uint8") + + @staticmethod + def export_maxpool_2d_precomputed_pads() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [13, 14, 15, 15, 15], + [18, 19, 20, 20, 20], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + ] + ] + ] + ).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_pads") + + @staticmethod + def export_maxpool_with_argmax_2d_precomputed_pads() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 5, 5] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y", "z"], + kernel_shape=[5, 5], + pads=[2, 2, 2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array( + [ + [ + [ + [13, 14, 15, 15, 15], + [18, 19, 20, 20, 20], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + [23, 24, 25, 25, 25], + ] + ] + ] + ).astype(np.float32) + z = np.array( + [ + [ + [ + [12, 13, 14, 14, 14], + [17, 18, 19, 19, 19], + [22, 23, 24, 24, 24], + [22, 23, 24, 24, 24], + [22, 23, 24, 24, 24], + ] + ] + ] + ).astype(np.int64) + + expect( + node, + inputs=[x], + outputs=[y, z], + name="test_maxpool_with_argmax_2d_precomputed_pads", + ) + + @staticmethod + def export_maxpool_2d_precomputed_strides() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[2, 2], strides=[2, 2] + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32) + + expect( + node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_strides" + ) + + @staticmethod + def export_maxpool_with_argmax_2d_precomputed_strides() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y", "z"], + kernel_shape=[2, 2], + strides=[2, 2], + storage_order=1, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32) + z = np.array([[[[6, 16], [8, 18]]]]).astype(np.int64) + + expect( + node, + inputs=[x], + outputs=[y, z], + name="test_maxpool_with_argmax_2d_precomputed_strides", + ) + + @staticmethod + def export_maxpool_2d_precomputed_same_upper() -> None: + """ + input_shape: [1, 1, 5, 5] + output_shape: [1, 1, 3, 3] + pad_shape: [2, 2] -> [1, 1, 1, 1] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4, 5], + [6, 7, 8, 9, 10], + [11, 12, 13, 14, 15], + [16, 17, 18, 19, 20], + [21, 22, 23, 24, 25], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[7, 9, 10], [17, 19, 20], [22, 24, 25]]]]).astype(np.float32) + + expect( + node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_same_upper" + ) + + @staticmethod + def export_maxpool_1d_default() -> None: + """ + input_shape: [1, 3, 32] + output_shape: [1, 3, 31] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2], + ) + x = np.random.randn(1, 3, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = [2] + strides = [1] + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, [0], "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_1d_default") + + @staticmethod + def export_maxpool_2d_default() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 31, 31] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_default") + + @staticmethod + def export_maxpool_3d_default() -> None: + """ + input_shape: [1, 3, 32, 32, 32] + output_shape: [1, 3, 31, 31, 31] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2, 2], + ) + x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = [2, 2, 2] + strides = [1, 1, 1] + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, [0, 0, 0], "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_default") + + @staticmethod + def export_maxpool_2d_same_upper() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [0, 1, 0, 1] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_UPPER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("SAME_UPPER", x_shape[2:], kernel_shape, strides) + pad_shape = get_pad_shape( + "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_top = pad_shape[0] // 2 + pad_bottom = pad_shape[0] - pad_top + pad_left = pad_shape[1] // 2 + pad_right = pad_shape[1] - pad_left + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + y = pool(padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_upper") + + @staticmethod + def export_maxpool_2d_same_lower() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 32, 32] + pad_shape: [1, 1] -> [1, 0, 1, 0] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + auto_pad="SAME_LOWER", + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (2, 2) + strides = (1, 1) + out_shape = get_output_shape("SAME_LOWER", x_shape[2:], kernel_shape, strides) + pad_shape = get_pad_shape( + "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape + ) + pad_bottom = pad_shape[0] // 2 + pad_top = pad_shape[0] - pad_bottom + pad_right = pad_shape[1] // 2 + pad_left = pad_shape[1] - pad_right + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + y = pool(padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_lower") + + @staticmethod + def export_maxpool_2d_pads() -> None: + """ + input_shape: [1, 3, 28, 28] + output_shape: [1, 3, 30, 30] + pad_shape: [4, 4] -> [2, 2, 2, 2] by axis + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + pads=[2, 2, 2, 2], + ) + x = np.random.randn(1, 3, 28, 28).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (3, 3) + strides = (1, 1) + pad_bottom = pad_top = pad_right = pad_left = 2 + pad_shape = [pad_top + pad_bottom, pad_left + pad_right] + out_shape = get_output_shape( + "VALID", np.add(x_shape[2:], pad_shape), kernel_shape, strides + ) + padded = np.pad( + x, + ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)), + mode="constant", + constant_values=np.nan, + ) + y = pool(padded, x_shape, kernel_shape, strides, out_shape, pad_shape, "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_pads") + + @staticmethod + def export_maxpool_2d_strides() -> None: + """ + input_shape: [1, 3, 32, 32] + output_shape: [1, 3, 10, 10] + """ + node = onnx.helper.make_node( + "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[5, 5], strides=[3, 3] + ) + x = np.random.randn(1, 3, 32, 32).astype(np.float32) + x_shape = np.shape(x) + kernel_shape = (5, 5) + strides = (3, 3) + out_shape = get_output_shape("VALID", x_shape[2:], kernel_shape, strides) + padded = x + y = pool(padded, x_shape, kernel_shape, strides, out_shape, (0, 0), "MAX") + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_strides") + + @staticmethod + def export_maxpool_2d_ceil() -> None: + """ + input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[3, 3], + strides=[2, 2], + ceil_mode=True, + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_ceil") + + @staticmethod + def export_maxpool_2d_dilations() -> None: + """ + input_shape: [1, 1, 4, 4] + output_shape: [1, 1, 2, 2] + """ + node = onnx.helper.make_node( + "MaxPool", + inputs=["x"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[1, 1], + dilations=[2, 2], + ) + x = np.array( + [ + [ + [ + [1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12], + [13, 14, 15, 16], + ] + ] + ] + ).astype(np.float32) + y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32) + + expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_dilations") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/maxunpool.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/maxunpool.py new file mode 100644 index 0000000000000000000000000000000000000000..3f92dea0711928e03f09d35af99a28800ccfc5ac --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/maxunpool.py @@ -0,0 +1,66 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MaxUnpool(Base): + @staticmethod + def export_without_output_shape() -> None: + node = onnx.helper.make_node( + "MaxUnpool", + inputs=["xT", "xI"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[2, 2], + ) + xT = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32) + xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64) + y = np.array( + [[[[0, 0, 0, 0], [0, 1, 0, 2], [0, 0, 0, 0], [0, 3, 0, 4]]]], + dtype=np.float32, + ) + expect( + node, + inputs=[xT, xI], + outputs=[y], + name="test_maxunpool_export_without_output_shape", + ) + + @staticmethod + def export_with_output_shape() -> None: + node = onnx.helper.make_node( + "MaxUnpool", + inputs=["xT", "xI", "output_shape"], + outputs=["y"], + kernel_shape=[2, 2], + strides=[2, 2], + ) + xT = np.array([[[[5, 6], [7, 8]]]], dtype=np.float32) + xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64) + output_shape = np.array((1, 1, 5, 5), dtype=np.int64) + y = np.array( + [ + [ + [ + [0, 0, 0, 0, 0], + [0, 5, 0, 6, 0], + [0, 0, 0, 0, 0], + [0, 7, 0, 8, 0], + [0, 0, 0, 0, 0], + ] + ] + ], + dtype=np.float32, + ) + expect( + node, + inputs=[xT, xI, output_shape], + outputs=[y], + name="test_maxunpool_export_with_output_shape", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/mean.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/mean.py new file mode 100644 index 0000000000000000000000000000000000000000..1ec54a34cff469b31365e1ffc4e488484b8c72d6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/mean.py @@ -0,0 +1,46 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Mean(Base): + @staticmethod + def export() -> None: + data_0 = np.array([3, 0, 2]).astype(np.float32) + data_1 = np.array([1, 3, 4]).astype(np.float32) + data_2 = np.array([2, 6, 6]).astype(np.float32) + result = np.array([2, 3, 4]).astype(np.float32) + node = onnx.helper.make_node( + "Mean", + inputs=["data_0", "data_1", "data_2"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1, data_2], + outputs=[result], + name="test_mean_example", + ) + + node = onnx.helper.make_node( + "Mean", + inputs=["data_0"], + outputs=["result"], + ) + expect(node, inputs=[data_0], outputs=[data_0], name="test_mean_one_input") + + result = np.divide(np.add(data_0, data_1), 2.0) + node = onnx.helper.make_node( + "Mean", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, inputs=[data_0, data_1], outputs=[result], name="test_mean_two_inputs" + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/meanvariancenormalization.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/meanvariancenormalization.py new file mode 100644 index 0000000000000000000000000000000000000000..d94dbcdd26e6295d0edcaf498cfe123a3e28b012 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/meanvariancenormalization.py @@ -0,0 +1,48 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MeanVarianceNormalization(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MeanVarianceNormalization", inputs=["X"], outputs=["Y"] + ) + + input_data = np.array( + [ + [ + [[0.8439683], [0.5665144], [0.05836735]], + [[0.02916367], [0.12964272], [0.5060197]], + [[0.79538304], [0.9411346], [0.9546573]], + ], + [ + [[0.17730942], [0.46192095], [0.26480448]], + [[0.6746842], [0.01665257], [0.62473077]], + [[0.9240844], [0.9722341], [0.11965699]], + ], + [ + [[0.41356155], [0.9129373], [0.59330076]], + [[0.81929934], [0.7862604], [0.11799799]], + [[0.69248444], [0.54119414], [0.07513223]], + ], + ], + dtype=np.float32, + ) + + # Calculate expected output data + data_mean = np.mean(input_data, axis=(0, 2, 3), keepdims=1) + data_mean_squared = np.power(data_mean, 2) + data_squared = np.power(input_data, 2) + data_squared_mean = np.mean(data_squared, axis=(0, 2, 3), keepdims=1) + std = np.sqrt(data_squared_mean - data_mean_squared) + expected_output = (input_data - data_mean) / (std + 1e-9) + + expect(node, inputs=[input_data], outputs=[expected_output], name="test_mvn") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/melweightmatrix.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/melweightmatrix.py new file mode 100644 index 0000000000000000000000000000000000000000..ad491058bb7727fbabc16c40bb8399ce85b31ec6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/melweightmatrix.py @@ -0,0 +1,89 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class MelWeightMatrix(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node( + "MelWeightMatrix", + inputs=[ + "num_mel_bins", + "dft_length", + "sample_rate", + "lower_edge_hertz", + "upper_edge_hertz", + ], + outputs=["output"], + ) + + num_mel_bins = np.int32(8) + dft_length = np.int32(16) + sample_rate = np.int32(8192) + lower_edge_hertz = np.float32(0) + upper_edge_hertz = np.float32(8192 / 2) + + num_spectrogram_bins = dft_length // 2 + 1 + frequency_bins = np.arange(0, num_mel_bins + 2) + + low_frequency_mel = 2595 * np.log10(1 + lower_edge_hertz / 700) + high_frequency_mel = 2595 * np.log10(1 + upper_edge_hertz / 700) + mel_step = (high_frequency_mel - low_frequency_mel) / frequency_bins.shape[0] + + frequency_bins = frequency_bins * mel_step + low_frequency_mel + frequency_bins = 700 * (np.power(10, (frequency_bins / 2595)) - 1) + frequency_bins = ((dft_length + 1) * frequency_bins) // sample_rate + frequency_bins = frequency_bins.astype(int) + + output = np.zeros((num_spectrogram_bins, num_mel_bins)) + output.flags.writeable = True + + for i in range(num_mel_bins): + lower_frequency_value = frequency_bins[i] # left + center_frequency_point = frequency_bins[i + 1] # center + higher_frequency_point = frequency_bins[i + 2] # right + low_to_center = center_frequency_point - lower_frequency_value + if low_to_center == 0: + output[center_frequency_point, i] = 1 + else: + for j in range(lower_frequency_value, center_frequency_point + 1): + output[j, i] = float(j - lower_frequency_value) / float( + low_to_center + ) + center_to_high = higher_frequency_point - center_frequency_point + if center_to_high > 0: + for j in range(center_frequency_point, higher_frequency_point): + output[j, i] = float(higher_frequency_point - j) / float( + center_to_high + ) + + # Expected output + # 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, + output = output.astype(np.float32) + expect( + node, + inputs=[ + num_mel_bins, + dft_length, + sample_rate, + lower_edge_hertz, + upper_edge_hertz, + ], + outputs=[output], + name="test_melweightmatrix", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/min.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/min.py new file mode 100644 index 0000000000000000000000000000000000000000..70a0437dd5750778bf61b2fe1df4b16619954b63 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/min.py @@ -0,0 +1,65 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.backend.test.case.utils import all_numeric_dtypes + + +class Min(Base): + @staticmethod + def export() -> None: + data_0 = np.array([3, 2, 1]).astype(np.float32) + data_1 = np.array([1, 4, 4]).astype(np.float32) + data_2 = np.array([2, 5, 0]).astype(np.float32) + result = np.array([1, 2, 0]).astype(np.float32) + node = onnx.helper.make_node( + "Min", + inputs=["data_0", "data_1", "data_2"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1, data_2], + outputs=[result], + name="test_min_example", + ) + + node = onnx.helper.make_node( + "Min", + inputs=["data_0"], + outputs=["result"], + ) + expect(node, inputs=[data_0], outputs=[data_0], name="test_min_one_input") + + result = np.minimum(data_0, data_1) + node = onnx.helper.make_node( + "Min", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, inputs=[data_0, data_1], outputs=[result], name="test_min_two_inputs" + ) + + @staticmethod + def export_min_all_numeric_types() -> None: + for op_dtype in all_numeric_dtypes: + data_0 = np.array([3, 2, 1]).astype(op_dtype) + data_1 = np.array([1, 4, 4]).astype(op_dtype) + result = np.array([1, 2, 1]).astype(op_dtype) + node = onnx.helper.make_node( + "Min", + inputs=["data_0", "data_1"], + outputs=["result"], + ) + expect( + node, + inputs=[data_0, data_1], + outputs=[result], + name=f"test_min_{np.dtype(op_dtype).name}", + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/mish.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/mish.py new file mode 100644 index 0000000000000000000000000000000000000000..8171976bdd903b0308958c1103fa0af2c35ea60e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/mish.py @@ -0,0 +1,22 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Mish(Base): + @staticmethod + def export() -> None: + node = onnx.helper.make_node("Mish", inputs=["X"], outputs=["Y"]) + + input_data = np.linspace(-10, 10, 10000, dtype=np.float32) + + # Calculate expected output data + expected_output = input_data * np.tanh(np.log1p(np.exp(input_data))) + + expect(node, inputs=[input_data], outputs=[expected_output], name="test_mish") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/mod.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/mod.py new file mode 100644 index 0000000000000000000000000000000000000000..a2d9fc5224febf5aa460d3a5ee357f2f39cf430d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/mod.py @@ -0,0 +1,176 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect + + +class Mod(Base): + @staticmethod + def export_mod_mixed_sign_float64() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float64) + y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float64) + z = np.fmod(x, y) # expected output [-0.1, 0.4, 5. , 0.1, -0.4, 3.] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float64") + + @staticmethod + def export_mod_mixed_sign_float32() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float32) + y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float32) + z = np.fmod( + x, y + ) # expected output [-0.10000038, 0.39999962, 5. , 0.10000038, -0.39999962, 3.] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float32") + + @staticmethod + def export_mod_mixed_sign_float16() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float16) + y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float16) + z = np.fmod( + x, y + ) # expected output [-0.10156, 0.3984 , 5. , 0.10156, -0.3984 , 3.] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float16") + + @staticmethod + def export_mod_mixed_sign_int64() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int64") + + @staticmethod + def export_mod_mixed_sign_int32() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int32) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int32) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int32") + + @staticmethod + def export_mod_mixed_sign_int16() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int16) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int16) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int16") + + @staticmethod + def export_mod_mixed_sign_int8() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int8) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int8) + z = np.mod(x, y) # expected output [ 0, -2, 5, 0, 2, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int8") + + @staticmethod + def export_mod_uint8() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint8) + y = np.array([2, 3, 8]).astype(np.uint8) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint8") + + @staticmethod + def export_mod_uint16() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint16) + y = np.array([2, 3, 8]).astype(np.uint16) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint16") + + @staticmethod + def export_mod_uint32() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint32) + y = np.array([2, 3, 8]).astype(np.uint32) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint32") + + @staticmethod + def export_mod_uint64() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.array([4, 7, 5]).astype(np.uint64) + y = np.array([2, 3, 8]).astype(np.uint64) + z = np.mod(x, y) # expected output [0, 1, 5] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint64") + + @staticmethod + def export_mod_int64_fmod() -> None: + node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1) + + x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64) + y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64) + z = np.fmod(x, y) # expected output [ 0, 1, 5, 0, -1, 3] + expect(node, inputs=[x, y], outputs=[z], name="test_mod_int64_fmod") + + @staticmethod + def export_mod_broadcast() -> None: + node = onnx.helper.make_node( + "Mod", + inputs=["x", "y"], + outputs=["z"], + ) + + x = np.arange(0, 30).reshape([3, 2, 5]).astype(np.int32) + y = np.array([7]).astype(np.int32) + z = np.mod(x, y) + # array([[[0, 1, 2, 3, 4], + # [5, 6, 0, 1, 2]], + + # [[3, 4, 5, 6, 0], + # [1, 2, 3, 4, 5]], + + # [[6, 0, 1, 2, 3], + # [4, 5, 6, 0, 1]]], dtype=int32) + expect(node, inputs=[x, y], outputs=[z], name="test_mod_broadcast") diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/node/momentum.py b/runtime/Lib/site-packages/onnx/backend/test/case/node/momentum.py new file mode 100644 index 0000000000000000000000000000000000000000..11525efc0c8657483ddee5633a9944d49af930b9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/node/momentum.py @@ -0,0 +1,161 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np + +import onnx +from onnx.backend.test.case.base import Base +from onnx.backend.test.case.node import expect +from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN + + +def apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta): # type: ignore + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Coefficient of gradient should be 1 at the first iteration. + beta_adjusted = beta if t > 0 else 1 + # Update momentum. + v_new = alpha * v + beta_adjusted * g_regularized + # Apply SG with momentum update rule. + x_new = x - r * v_new + return x_new, v_new + + +def apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta): # type: ignore + # Add gradient of regularization term. + g_regularized = norm_coefficient * x + g + # Coefficient of gradient should be 1 at the first iteration. + beta_adjusted = beta if t > 0 else 1 + # Update momentum. + v_new = alpha * v + beta_adjusted * g_regularized + # Apply Nesterov with momentum update rule. + x_new = x - r * (g_regularized + alpha * v_new) + return x_new, v_new + + +class Momentum(Base): + @staticmethod + def export_momentum() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.1 + + # Create operator. + node = onnx.helper.make_node( + "Momentum", + inputs=["R", "T", "X", "G", "V"], + outputs=["X_new", "V_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + mode="standard", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.2, 2.8], dtype=np.float32) + g = np.array([-0.94, -2.5], dtype=np.float32) + v = np.array([1.7, 3.6], dtype=np.float32) + + # Compute expected outputs of Momentum. + x_new, v_new = apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta) + + # Check results. + expect( + node, + inputs=[r, t, x, g, v], + outputs=[x_new, v_new], + name="test_momentum", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_nesterov_momentum() -> None: + # Define operator attributes. + norm_coefficient = 0.01 + alpha = 0.95 + beta = 1.0 + + # Create operator. + node = onnx.helper.make_node( + "Momentum", + inputs=["R", "T", "X", "G", "V"], + outputs=["X_new", "V_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + mode="nesterov", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + x = np.array([1.2, 2.8], dtype=np.float32) + g = np.array([-0.94, -2.5], dtype=np.float32) + v = np.array([1.7, 3.6], dtype=np.float32) + + # Compute expected outputs of Momentum. + x_new, v_new = apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta) + + # Check results. + expect( + node, + inputs=[r, t, x, g, v], + outputs=[x_new, v_new], + name="test_nesterov_momentum", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) + + @staticmethod + def export_momentum_multiple() -> None: + # Define operator attributes. + norm_coefficient = 0.001 + alpha = 0.95 + beta = 0.85 + + node = onnx.helper.make_node( + "Momentum", + inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"], + outputs=["X1_new", "X2_new", "V1_new", "V2_new"], + norm_coefficient=norm_coefficient, + alpha=alpha, + beta=beta, + mode="standard", + domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN, + ) + + # Define operator inputs. + r = np.array(0.1, dtype=np.float32) # scalar + t = np.array(0, dtype=np.int64) # scalar + + x1 = np.array([1.0], dtype=np.float32) + g1 = np.array([-1.0], dtype=np.float32) + v1 = np.array([2.0], dtype=np.float32) + + x2 = np.array([1.0, 2.0], dtype=np.float32) + g2 = np.array([-1.0, -3.0], dtype=np.float32) + v2 = np.array([4.0, 1.0], dtype=np.float32) + + # Compute expected outputs of Momentum. + x1_new, v1_new = apply_momentum(r, t, x1, g1, v1, norm_coefficient, alpha, beta) + x2_new, v2_new = apply_momentum(r, t, x2, g2, v2, norm_coefficient, alpha, beta) + + # Check results. + expect( + node, + inputs=[r, t, x1, x2, g1, g2, v1, v2], + outputs=[x1_new, x2_new, v1_new, v2_new], + name="test_momentum_multiple", + opset_imports=[ + onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1) + ], + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/test_case.py b/runtime/Lib/site-packages/onnx/backend/test/case/test_case.py new file mode 100644 index 0000000000000000000000000000000000000000..6ac006f05e5ddf807654e5bea69fd452ae044ed3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/test_case.py @@ -0,0 +1,25 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +from dataclasses import dataclass +from typing import Optional, Sequence, Tuple + +import numpy as np + +import onnx + + +@dataclass +class TestCase: + name: str + model_name: str + url: Optional[str] + model_dir: Optional[str] + model: Optional[onnx.ModelProto] + data_sets: Optional[Sequence[Tuple[Sequence[np.ndarray], Sequence[np.ndarray]]]] + kind: str + rtol: float + atol: float + # Tell PyTest this isn't a real test. + __test__: bool = False diff --git a/runtime/Lib/site-packages/onnx/backend/test/case/utils.py b/runtime/Lib/site-packages/onnx/backend/test/case/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..82b30a2e1fd3d24210c9cacce45cd177c027770b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/case/utils.py @@ -0,0 +1,45 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import importlib +import pkgutil +from types import ModuleType +from typing import List, Optional + +import numpy as np + +from onnx import ONNX_ML + +all_numeric_dtypes = [ + np.int8, + np.int16, + np.int32, + np.int64, + np.uint8, + np.uint16, + np.uint32, + np.uint64, + np.float16, + np.float32, + np.float64, +] + + +def import_recursive(package: ModuleType) -> None: + """ + Takes a package and imports all modules underneath it + """ + pkg_dir: Optional[List[str]] = None + pkg_dir = package.__path__ # type: ignore + module_location = package.__name__ + for _module_loader, name, ispkg in pkgutil.iter_modules(pkg_dir): + module_name = f"{module_location}.{name}" # Module/package + if not ONNX_ML and module_name.startswith( + "onnx.backend.test.case.node.ai_onnx_ml" + ): + continue + + module = importlib.import_module(module_name) + if ispkg: + import_recursive(module) diff --git a/runtime/Lib/site-packages/onnx/backend/test/cmd_tools.py b/runtime/Lib/site-packages/onnx/backend/test/cmd_tools.py new file mode 100644 index 0000000000000000000000000000000000000000..748eb37f3a5a2186bb186fcb7923e361422a4448 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/cmd_tools.py @@ -0,0 +1,179 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import argparse +import json +import os +import shutil +import warnings + +import onnx.backend.test.case.model as model_test +import onnx.backend.test.case.node as node_test +from onnx import ONNX_ML, TensorProto, numpy_helper + +TOP_DIR = os.path.realpath(os.path.dirname(__file__)) +DATA_DIR = os.path.join(TOP_DIR, "data") + + +def generate_data(args: argparse.Namespace) -> None: + def prepare_dir(path: str) -> None: + if os.path.exists(path): + shutil.rmtree(path) + os.makedirs(path) + + # Clean the output directory before generating data for node testcases + # It is used to check new generated data is correct in CIs + node_root = os.path.join(args.output, "node") + original_dir_number = len( + [name for name in os.listdir(node_root) if os.path.isfile(name)] + ) + if args.clean and os.path.exists(node_root): + for sub_dir in os.listdir(node_root): + if ONNX_ML or not sub_dir.startswith("test_ai_onnx_ml_"): + shutil.rmtree(os.path.join(node_root, sub_dir)) + + cases = model_test.collect_testcases() + # If op_type is specified, only include those testcases including the given operator + # Otherwise, include all of the testcases + cases += node_test.collect_testcases(args.op_type) + node_number = 0 + + for case in cases: + output_dir = os.path.join(args.output, case.kind, case.name) + prepare_dir(output_dir) + if case.kind == "node": + node_number += 1 + if case.kind == "real": + with open(os.path.join(output_dir, "data.json"), "w") as fi: + json.dump( + { + "url": case.url, + "model_name": case.model_name, + "rtol": case.rtol, + "atol": case.atol, + }, + fi, + sort_keys=True, + ) + else: + assert case.model + with open(os.path.join(output_dir, "model.onnx"), "wb") as f: + f.write(case.model.SerializeToString()) + assert case.data_sets + for i, (inputs, outputs) in enumerate(case.data_sets): + data_set_dir = os.path.join(output_dir, f"test_data_set_{i}") + prepare_dir(data_set_dir) + for j, input in enumerate(inputs): + with open(os.path.join(data_set_dir, f"input_{j}.pb"), "wb") as f: + if case.model.graph.input[j].type.HasField("map_type"): + f.write( + numpy_helper.from_dict( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + elif case.model.graph.input[j].type.HasField("sequence_type"): + f.write( + numpy_helper.from_list( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + elif case.model.graph.input[j].type.HasField("optional_type"): + f.write( + numpy_helper.from_optional( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + else: + assert case.model.graph.input[j].type.HasField( + "tensor_type" + ) + if isinstance(input, TensorProto): + f.write(input.SerializeToString()) + else: + f.write( + numpy_helper.from_array( + input, case.model.graph.input[j].name + ).SerializeToString() + ) + for j, output in enumerate(outputs): + with open(os.path.join(data_set_dir, f"output_{j}.pb"), "wb") as f: + if case.model.graph.output[j].type.HasField("map_type"): + f.write( + numpy_helper.from_dict( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + elif case.model.graph.output[j].type.HasField("sequence_type"): + f.write( + numpy_helper.from_list( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + elif case.model.graph.output[j].type.HasField("optional_type"): + f.write( + numpy_helper.from_optional( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + else: + assert case.model.graph.output[j].type.HasField( + "tensor_type" + ) + if isinstance(output, TensorProto): + f.write(output.SerializeToString()) + else: + f.write( + numpy_helper.from_array( + output, case.model.graph.output[j].name + ).SerializeToString() + ) + if not args.clean and node_number != original_dir_number: + warnings.warn( + "There are some models under 'onnx/backend/test/data/node' which cannot not" + + " be generated by the script from 'onnx/backend/test/case/node'. Please add" + + " '--clean' option for 'python onnx/backend/test/cmd_tools.py generate-data'" + + " to cleanup the existing directories and regenerate them.", + Warning, + stacklevel=2, + ) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser("backend-test-tools") + subparsers = parser.add_subparsers() + + subparser = subparsers.add_parser( + "generate-data", help="convert testcases to test data." + ) + subparser.add_argument( + "-c", + "--clean", + default=False, + action="store_true", + help="Clean the output directory before generating data for node testcases.", + ) + subparser.add_argument( + "-o", + "--output", + default=DATA_DIR, + help="output directory (default: %(default)s)", + ) + subparser.add_argument( + "-t", + "--op_type", + default=None, + help="op_type for test case generation. (generates test data for the specified op_type only.)", + ) + subparser.set_defaults(func=generate_data) + + return parser.parse_args() + + +def main() -> None: + args = parse_args() + args.func(args) + + +if __name__ == "__main__": + main() diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/README.md b/runtime/Lib/site-packages/onnx/backend/test/data/light/README.md new file mode 100644 index 0000000000000000000000000000000000000000..787c0a3dcc213a92da75b5109335ec0dd3338a66 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/README.md @@ -0,0 +1,16 @@ + + +# Light models + +The models in this folder were created by replacing +all float initializers by nodes `ConstantOfShape` +with function `replace_initializer_by_constant_of_shape`. +The models are lighter and can be added to the repository +for unit testing. + +Expected outputs were obtained by using CReferenceEvaluator +implemented in [PR 4952](https://github.com/onnx/onnx/pull/4952). diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_bvlc_alexnet.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_bvlc_alexnet.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ad972bae5ee76a02d4a651e201b74d7b8612069d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_bvlc_alexnet.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2afa78cef5a88aed9d6e3d63fb92bd330c9177ac150d19189c6b3e7204ba0212 +size 3968 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fcf1467da0a52cc7751c6f7299ac6c3cfa37e1b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97d6bcc28b6ad731bc3281a8b03068d15fa9d538769b5b24ca5448ea143db100 +size 4010 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_densenet121.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_densenet121.onnx new file mode 100644 index 0000000000000000000000000000000000000000..7e34c4b147d682266c4f36f759bdb33a94c40b4a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_densenet121.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:49ddb5712797d6164f1d864bedaad927de4f3909ad1b4ba390a92c2f8150e9f6 +size 214344 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_densenet121_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_densenet121_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6c54f8eb6394cad398b9f14ca205e2a529a02dbf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_densenet121_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6cc6130fcbf90314522678603bb3db7ed8f3a79754b37d3ac95c9a2e3f4de0c +size 4014 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v1.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v1.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d1e88acb7d747aea26a59c83273315a5768b7e7d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v1.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb7a0e6c370c709f5615eeef961b43628de13d0009ae4d6f4bfb0d5aea5d8270 +size 36869 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v1_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v1_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fcf1467da0a52cc7751c6f7299ac6c3cfa37e1b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v1_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97d6bcc28b6ad731bc3281a8b03068d15fa9d538769b5b24ca5448ea143db100 +size 4010 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v2.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v2.onnx new file mode 100644 index 0000000000000000000000000000000000000000..93622ca410b41ab13c8c314c4a98627e48bef270 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v2.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:224d77d55b26559a959db627c3f417a623fbf3b3000d25f0939327aa935d933f +size 159024 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v2_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v2_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fcf1467da0a52cc7751c6f7299ac6c3cfa37e1b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_inception_v2_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97d6bcc28b6ad731bc3281a8b03068d15fa9d538769b5b24ca5448ea143db100 +size 4010 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_resnet50.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_resnet50.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9ee7e864375e4cbed0c902c972013c2d98762c8d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_resnet50.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05e77a5c9c9ce0913f549a50d6ebaced5e0ff6817b61e09bae26e4c5bd9055e4 +size 79770 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_resnet50_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_resnet50_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fcf1467da0a52cc7751c6f7299ac6c3cfa37e1b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_resnet50_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97d6bcc28b6ad731bc3281a8b03068d15fa9d538769b5b24ca5448ea143db100 +size 4010 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_shufflenet.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_shufflenet.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8f30725f663d75936a44895ee3a109fe2f1afedd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_shufflenet.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6f406d62be36d6b4572542c0950a2abd59f56237068793290680bba89fbafe5 +size 67666 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_shufflenet_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_shufflenet_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fcf1467da0a52cc7751c6f7299ac6c3cfa37e1b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_shufflenet_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97d6bcc28b6ad731bc3281a8b03068d15fa9d538769b5b24ca5448ea143db100 +size 4010 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_squeezenet.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_squeezenet.onnx new file mode 100644 index 0000000000000000000000000000000000000000..af4c9d1982dc8f6127a8238aabfd6b08ca638a20 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_squeezenet.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:770b0f3c8623e18bf58b53754d710051b4c268248422142980a132bbe6dfe908 +size 15618 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_squeezenet_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_squeezenet_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a878d320b4f4400fd246238734107013525b1b7e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_squeezenet_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:32eee74b7e589729a8069267de65ba6aba2881d0f24041aae8e50f685303c136 +size 4014 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_vgg19.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_vgg19.onnx new file mode 100644 index 0000000000000000000000000000000000000000..f7e0eb39e38cd7116e369b65eb70c06f8176aafd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_vgg19.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e547d732b3a3d66eeb8fa64a026adb994d3db552f0bbd52e436d06300d89afe +size 9311 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_vgg19_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_vgg19_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fcf1467da0a52cc7751c6f7299ac6c3cfa37e1b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_vgg19_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97d6bcc28b6ad731bc3281a8b03068d15fa9d538769b5b24ca5448ea143db100 +size 4010 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_zfnet512.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_zfnet512.onnx new file mode 100644 index 0000000000000000000000000000000000000000..329e925929eabdad78d9a7dced4e27a4087f6d36 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_zfnet512.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6444bb58b98c3d14f551a3bdb83eea9e5db7e147790db3115c447e9c9a8338b0 +size 4506 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/light/light_zfnet512_output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_zfnet512_output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fcf1467da0a52cc7751c6f7299ac6c3cfa37e1b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/light/light_zfnet512_output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97d6bcc28b6ad731bc3281a8b03068d15fa9d538769b5b24ca5448ea143db100 +size 4010 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..17cf800c1d362a6f799e3688fc709d82790798fc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:87e8c85a3c5ac0401781fd1327a04a8eec7b8fac8df7e813b2bed5134403905a +size 97 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..58f5af5f3237bae3e4133f0888f56b1ed0292c51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0180f5665325e343077736e4903fa43513ae714ceb131deee45b842370df289a +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7822c08274018d353acfc4ff8233d7f984d80524 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8135951529d61fddab48dd748bf0e231443a818c47c5055ba1c141a4a749dd0 +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..24be2c40fb380a6cf5a4b01c868aa7912aa8e99c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2b85831618cf33187c7f035bcc8889bb1fd56f24238cc86d8a0a0d8217512840 +size 99 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..691aa143f8af9be7b79e4cf0a81853feb1fa8d0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05c023929a1b32b4bdbd7882ff5e53b9b53762ee2929c66be76d0f0ba7ca393d +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..42622b81df7143630a66c693289efc112176c01e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f756ff9e17e01930f56aacd19afccaffb0212e7da1dec7e9a8788bbaeeaa0eb5 +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b5dd89c5dc3c8dd3474f341183c125f483139e11 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0576861b8660a0f70bb75f5da782694460ab06bf727877ebd2c0c7724365cc7e +size 91 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..88128780e03bf763149dd948c9cf0d40a0bb2071 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:703de0c3be505a78596235789682bc4e6f0e8523f34fb731207b4c076701abdd +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c59bdec79fdc95952197e2dcd7b35f420419238d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2b6b3deb8a89769e130c6c6d3237b29d5d1d01c84425f70d9f15af6920fc8ff9 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..643fe43f9307eac9cc0d4c377c6eb3c70e3d4a29 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57b983aab54e9e5744a1e4ac8a4bdb8557a4de6fd7e185d2e6f09058fb0121d5 +size 101 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..843cfd0470938ceca1fe0082b5fc285329ded0f9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30ab226b20d339612014c98f4f0a3997297293bf8cb50ae15bce3d15fd42e3ee +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1140447391371b7966891cc5f151a2c1f19f66ae --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1692a5be4affd722d2c82d4e26eea97fcffeb85e067e75acb1cbbdeb1fa456a7 +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d4d8b26b18c0c08147887415caa9c7d2b0001718 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11d62640ee799a6de2a0c8acec86fafb591058b78231d3e5d8ddcad9fdb7d336 +size 93 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cfe6ba55a5763de90227723498535d80627f484e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:357200162d60efa020d67af9c220c8884ea296ca27effb74902fd07f92e7eaf8 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..331c57656769664831c1d43b37e65acfd5f34f50 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b3de92cda4a410cf189bfbdde29176f95b3919a2042ea3c80e32800e3cb3c7f +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c142651f24437eda02f83341d454134c05f7848f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5bfd337a65cfc3213420fa06841eb88a6d3b8cfbef6235099fc4950f2c94bfe8 +size 320 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d61b5b6ad90be73b7598b1872073503a017c0633 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b13087d18cf644a39bb101a66dd06a37ff95bac00e83bfbd5ff621b5168aa22 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..815b7a1a21c44a7787c0caa8b319d07fdf87b418 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c44a418da7d4f82602975579ba1cdda8fdab51f0606a3ee096c9314ea0c68be9 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..93a2c173ea96f3fceb18b4d75c750fd5989d4cf2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b6eaee0ae6356b407afdb8729f08d7d8aabe3ab262dc79f045208eb7905904bc +size 13 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..33d8167b3310c12c5fa7683668c23e8d8aaa64bb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:86b82874edcb556fcbc536d488af6d06f2c0d90ed666d5d45bd8ad3fda2a7d01 +size 13 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..526e914cef8d7c18760b019441b60231cce23b52 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91fa92ce704fea3376209b22a90d487862aa2f1f26eb36039dfaa48d7fa15269 +size 13 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6e1ee650338ef0dfdd99a6c3aaab9852cf96b461 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a022a2b019848e93f75c1dd58489ab669fa5ac27c4b92173749124ec320e030f +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..b5cf06076d1b02eb6e21c7267863b641f48a2960 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fbdda18e2257329a378bc02490c04a7e853fe88f3e6107adb9eee5cec9509de8 +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..f0d25ad0a01a03143e9eebf35801ebf701365210 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d067ca0926d16bdddc302e45d5232bd8a28757e208562001cf06823517c0f999 +size 465 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d61b5b6ad90be73b7598b1872073503a017c0633 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b13087d18cf644a39bb101a66dd06a37ff95bac00e83bfbd5ff621b5168aa22 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..815b7a1a21c44a7787c0caa8b319d07fdf87b418 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c44a418da7d4f82602975579ba1cdda8fdab51f0606a3ee096c9314ea0c68be9 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..f6a713c716572c10cc6d3e57576acba905bbb76d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd209068326e49f8d5f3d94e2a5fdef0502f69874383a52b1f69f87b2902f5b2 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..3646541999dfac3811ce5c1e8f259daf8a269bf3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:03ee3416024db9c3cd15bfd692c6cccb467e13f10857b445d033fdd24a9b6c2e +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..831514ad9ab87825c9a6415cd84764819fc16f13 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b179919a8dec2bc0f85af8c06809d3a2de75c963317d0e06c684e23022ac770 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb new file mode 100644 index 0000000000000000000000000000000000000000..4830c09b2e19ed128f9b46d183fb4f0cac7617e1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2d086bc46c15bc8ad8096e4457d699ca662af4f34932b5222e4e6640921e356 +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb new file mode 100644 index 0000000000000000000000000000000000000000..1622189c35caa4c5e435e4ee6aef7dab2d615e18 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d7e7e556bccf98aa250f419287e95dd70619c52108531d135298bfd32c1e76a0 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb new file mode 100644 index 0000000000000000000000000000000000000000..8f424da4709212346b72174b01b03e4d447afe96 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7a552299b569b3bb2ba14115833b2bee6ece125575605dbdcd5933600d184beb +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..85899ba850eb5e7a7dbeebef654daad1ea73f72a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:50a4c8438339f3fe9ba7e2c16a039efdde15470ae2b3b2056779e2d1b5a2565f +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..d84927a014148a95c49fc043a6a01a88559f258f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a95550f2372bf749abcc0d7785d5d55f5833308e582a6d6df79d1c9d3811522 +size 22 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..363aefd64bf7828339f6ae43d65a7de06c3996d4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1e89c732917f033254b7c2009c99a93529dfdfc011c39e154a146d235e434cb4 +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..7715d3216f1e5dc83ba096539a7ebbec29cad13c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d2db9fc09b516918d14c7090643afbfdaaeb946be33e1393aaf099253f57db23 +size 22 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..441d3b9d6cd3849fcce472d3711accacb58deb3f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c3d2aef1d34b6f2f22e100d36da8c93945c179131dae6bc55bd197d4c1a56b70 +size 371 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d61b5b6ad90be73b7598b1872073503a017c0633 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b13087d18cf644a39bb101a66dd06a37ff95bac00e83bfbd5ff621b5168aa22 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..815b7a1a21c44a7787c0caa8b319d07fdf87b418 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c44a418da7d4f82602975579ba1cdda8fdab51f0606a3ee096c9314ea0c68be9 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..64f0d05b50f671719de7bf339ed3ba6538e56c09 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aba5acc9dbec722e5924d8aa0de8f52aad7b4334b7c4e3d612bbae2c8828a2b4 +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..94361f573049ac9fea523cf7b03ed3f96f2e2fbf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35090aaf7ac2959a77d6019fd4eca1fc40abaf6ff900c5589ff7cd7436b34fc5 +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..53d40fb210433036d9a450baf4b1499e82564195 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eaea46455539f8efb9cca5e80eee9c46c736174dfa93a374db0fc234f1c11aa0 +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb new file mode 100644 index 0000000000000000000000000000000000000000..71ab2abf169cdba8dd021e3ac98ec4f05a2ef213 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fec400734c87eee422a5b7497bf37d115fde31524d3536f46d84ab96f7931d20 +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c871d73e639ae687a195892acc0ed6a650d8b0a0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4d545578a79ab69e3b2badb2bb9ccd7bb7a641cca8a91195a764c44fe44499dc +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..f2fc82d4e3d7c2b99a7fcf10ae365da95eb9291b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:acae9993d79ac77b549ecdd2ece6b9e4b378180feff14773bfaba24addf984cb +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..cd3725ed4bd0ba8a155a172ad81a4f961e99b099 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e7e6a4555b57797c308a5ba35377ace194e2f32568e1e8f0f017f1a8b43bd4d +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..205c2cc2dd5abea3e9557f0998dd1b0c65bdb0eb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4e5ae63e47e1f1034b74ad5fd92fe1f908dcdea805ad58a2a67993b7990270e +size 553 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d61b5b6ad90be73b7598b1872073503a017c0633 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b13087d18cf644a39bb101a66dd06a37ff95bac00e83bfbd5ff621b5168aa22 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..815b7a1a21c44a7787c0caa8b319d07fdf87b418 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c44a418da7d4f82602975579ba1cdda8fdab51f0606a3ee096c9314ea0c68be9 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..f6a713c716572c10cc6d3e57576acba905bbb76d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd209068326e49f8d5f3d94e2a5fdef0502f69874383a52b1f69f87b2902f5b2 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..3646541999dfac3811ce5c1e8f259daf8a269bf3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:03ee3416024db9c3cd15bfd692c6cccb467e13f10857b445d033fdd24a9b6c2e +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..831514ad9ab87825c9a6415cd84764819fc16f13 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b179919a8dec2bc0f85af8c06809d3a2de75c963317d0e06c684e23022ac770 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb new file mode 100644 index 0000000000000000000000000000000000000000..4830c09b2e19ed128f9b46d183fb4f0cac7617e1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2d086bc46c15bc8ad8096e4457d699ca662af4f34932b5222e4e6640921e356 +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb new file mode 100644 index 0000000000000000000000000000000000000000..c2017bdf137ed3ed9e9a094710231c415bc8be49 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45cf7416b401454942f93ccef63f1d32ba125404d2747d36ec5690cc4b417940 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb new file mode 100644 index 0000000000000000000000000000000000000000..58779051bf0ef4ab101e13c8bad2f19163a9a94f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:34f7208fff45c8c209dcb9790a15e81f16d434f13b42ab88fa09df32ae2fd34d +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb new file mode 100644 index 0000000000000000000000000000000000000000..13df967bb825f4c395e259fae6b203bb1b14d42d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:34fd4c71f3043750d42a04ed4eb2c5a97f90ea7a254bca3421d2f38bcaff62b0 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb new file mode 100644 index 0000000000000000000000000000000000000000..0b11496e9b8a89470aa2440ca137641833edb8c2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2356b1a991645e8c7d7946ef5404905a9686b677de2fb50db7890e41220d598f +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0456ba126e71dae4884d39d26a723eac37256e63 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:827fa5cd7808d610c2619dbff5940c730b3e734225ae20a04f8b4f7dd65e327f +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..bd119159e630fd34d2b3abdaf0375a67996841b0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de9a02a1f0fb37283d2ac2184c6fa92547c4b44cfe1bb24d28cbd5ab87c021d7 +size 22 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..add41a9a5a4eb01f1233d93fc02b563e200e5d2f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e112fa29eb8522bf59fc8a43988eca01fd66b6fb9a970a9089b5e2722ad82c3 +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..e86faba276f063cc018a20636b3133ccfd1ab114 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:385a22647e251cfa95e18338b0ef490144884e60d32dc14f1ac0e8ffc8379d69 +size 22 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..c40859e0c0a170fe01df2d99f086184a918c0625 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f77a721995fa3af985d5ac5e1f7789d7c8c21bd96dd57fcd7bc6843a9dad70cb +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb new file mode 100644 index 0000000000000000000000000000000000000000..70d808fe027b3fbd3ace0dada31167b3d7e20c70 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b1938ac765912c174cc73ca62378b00e6f66e073c4f2e69a78a30ebc7a6bef8 +size 22 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9b91d90e41e695db3c567c47d291f5dfa0554385 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:93cf0438706cddabf683adc8b13c8a17c4b8b12d8bccb1b041268e1f4dff0a2d +size 129 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..58f5af5f3237bae3e4133f0888f56b1ed0292c51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0180f5665325e343077736e4903fa43513ae714ceb131deee45b842370df289a +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..971c920888435745edb3e93065f33e50909e3483 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa59aeb90365dde2edc5a6ca7cd13a71b6478d8723f83ccd06bd4ce2bcfb192a +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7545b134ce9ced7eb808a6bd2faa5f499b51498f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9ff4c027c9f60fb0ffb5d125c5eb78090e9eb4ac9b1c026691833bfcc487bb2f +size 256 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..7992652872365ac91305cfe70cae4f943ad668ef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d562ef62b7e9541e2b9bf2b5ae6297bfeaa7d14a19c689388318b2dcda7a1550 +size 127 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..58f5af5f3237bae3e4133f0888f56b1ed0292c51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0180f5665325e343077736e4903fa43513ae714ceb131deee45b842370df289a +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..3af3fa0a61a4b0e8f02553740690e4abb5091689 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8d89fd14b53313d11325cc455b8f17a927a1465c9e3cf8d4a08fa0b4dca8cc1b +size 29 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..74e88be5b6d32437e99b91aed555ae7622cf6fcc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac6dfc048f596756c8c3e1bebd035a55e6b6fa21058339671ab4a4e09450ebfb +size 256 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8e82b085d56f2312b90ef85c53641d33877d794f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5a2fee709cfd7ad23b6e26559bbf6185a6a0d524b481c3d13cf4740cafc1e33 +size 135 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8513ffda60c66991bfff225f61993c1c08b041b3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c18f496f3d870f414cec933acf06c16d18461ecb3770380ee9e153829e4bed6f +size 73 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..baebffc6a1c46d9dd817b38c34ae106262dd9c93 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0611a0a39375dcc74113788d26037a81608fe06485cc96547280084f98c8ba89 +size 73 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6764edcfe5922da5a5634cb7573e035db2c2f8c7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ce905d1cfbb6a815c7694720a3c6bbc5dc65ad2dea38b240e968a9da6ffb3ac3 +size 75 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..257844fb6e4d2c326b296e67e574ba42179111d4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8aa80cb66010d1c32a9f8a799f8fcee435a8d974e2d0e7e87f1d9aa7adc6b57 +size 181 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5be9e71c259c9879477655e81e5f6caf0382d6e5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c8d34aa16af6242a5fda1ca7a2f1adc81ff76c2f2848fd8e7b277f30161914d +size 59 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..ee2417f95769245e33af26a8f65ae024e2b0d656 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9b57e2cfa142a6c4c66a61587bb6bb086279579daa585588aba93c765a5494b +size 25 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..be8dd3c069697316956e06ba78565da6f9e2a4aa --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:713ed58c32c02de0b2e9a2a0f5583b2bd6f16390a7bc51abab77b641189f00d9 +size 35 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bc6d1527aa4765d4ccc07781230587a782ef89a1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:306233d2bb7af438846aa85214ace58b5e65e15845cfdf50ff2b069f29c682ff +size 164 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c0d75ec3ce0d9e8cb40e8a38407cf70e350a5cc9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:20788723269b9582f339e281df6fa80f0da06611b90685eba3a86ba68b1d7a0b +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..82ff8eb3ce46ac7926f45174289ff40831c7a2fd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5823f10bac5af68b20e0bc4dd32f743d8712bae769833c63731f601caab02314 +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..7b7de9ced0b458d799699b53031855d36abd33f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ef8594efa26783bed9d94632010790bcc464d673e378c286950f5a6393fc9f5 +size 119 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d44c54d97134e1f8a6e35734dacce96c7f393b91 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e3369fe07f91df4e85118fe7ce57e4cbff5d1bedc4eaa0e8fc45f3d334f60b4 +size 23 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..6d26947c1a76452030b54f44a2557a4e13a6c283 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:828666c5e8221193e34535d271489053d7e9c4f9dd17812a019cbca1e4e86bc9 +size 23 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4ff4772731fcd64f790af6d7d82b991c8d9f4537 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:19c8e670cd77c1d5c046f80512e6413d6f7696ab28dbee6c40c989888668bd62 +size 25 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..2081e68050f7c4497919a37cfaa4d1aa7ff6231b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ecb22da8fa94ed2ba4a2ecd2840446b19fd3f95389667549f45c5f98009be76 +size 131 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..706737f3a71c33491b50789dfce99fccf1165e6e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0ebe24e5da6936a11a5a616c3145f0fcf6e9ed0a04a6a917bf806876ab7bccc4 +size 73 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..545449e7c1d57c00886ac42c923b83e2bc182f51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf94a94f31064228e0c69b7719076a15da43f8b0aa94382b3da71eef910be694 +size 73 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f5bc0251f6d1e62133c6f9a9a8a9c1c168fcca5b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b8290c29ebb7039165f7df70dce27416edc98d9a4d156270096fb2ba958163bf +size 75 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..796b256da73a7ea57b96ba38db5ff2ffa68109fc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c9d9ae60379d225562bd427491fe4083d7a344e60a9e8a682c45e2df7401201 +size 143 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..dcfbf19893fccf53099ed6f9934bba5d898cef6a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0c2b153980d431ea6bfcf593a4995d1009d12ef5ff04844f8c66ea1635b71e9 +size 376 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..93222ffb4f73c7c802ba73fdbeda35f38c2d9b9a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f49694bd75517ff3584d1c185ad3d8b1b4a82890f03973d9b91060158ee960f7 +size 376 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..496d93cb79632812d51b6efb710e0364c03f3a2f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef3e8372a5383d80f83411b48418c1a10b67f40014d475e8190a7f3fa1d7e596 +size 378 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a3efc5ffedbad4f30071d91c9bebef022298bce0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57e2fa30b3395022d8792906ea6f1e30ecba3b10d83f2dd7bdc1a07ac6edefa1 +size 131 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..34406f2a343751203a7e067fd1e56f4ff5cf9e36 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c05e7686f2c45c27ebc9337416f8163ca5d2c773cf96989a0bf68067921708c7 +size 73 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..1e911c08718180026da4e1647824cadc5e6703af --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1c3f490727de556e61acc895b7ae5a333cedfc610a1c49cb5ce5bb8b6acd192 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7eb42d8bfbf0fef3253d1a5887eedcdc5e631ae5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db36f9707b9d18748e58e15c8e030142d4d125ee3c85b95dd76f1a43685b0b2f +size 75 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..4bc907bdebe2e7f685c9182095156d842c284711 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ae43bc81927a51228562951680a6433952d52ab19a5c8b8753ef217955f0c07a +size 135 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a939e70df3e648db2a294df86ce1925bfe99b0e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d878b9819cc2ca4dd25ad07c761b52e6d20c8a92129cf2462354888f1d3c15ed +size 73 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..e97ad7697b2d768650e2de7a143deebda13bae88 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2759de2ec3aa6474ef19d6a0045f3fdceeac424d5bcae508300051d302710120 +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..eb1abc57fbcb4039254d38026046abd96e2821d6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99d1bedf600d8d1891aee6c6584301ba06809092ad842c3be21a9c9457948347 +size 75 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e3d32e63dc9b43e33be8b7fc19da14dd1a23f751 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d0ef51216db411bc6bdd52b70258cb40f200ef3f2dc2037c320a6444b50bbee +size 143 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a115114b3764248d5b2c721d3fa55c455ed7c873 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c6f4fa4d2415beae149dc180e99b008ca2d59cf1239ed9ed9c2c0a1768d43ca +size 376 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..a3b6489e463002b0ca7e78fd930b2c2c65c17b07 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0f824895f554ce28c2f2b935e76a643ec0d66b7dd8251966bad8ccbe44fed452 +size 41 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c7a5732105e82901ca959137f3a562a67199955b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0570d9133131df4299191957f90440bbf4dfadfb428581a2e231c6bfae12f4d2 +size 378 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8fa5d65e6a22766fb000008978c49d3ab004237e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9695b8bcb560c7d17b1482aba90d8ab8701f812de1c83acbec73638673fb1b8d +size 147 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9180a012ee5a56d8a9c0f0e350b489bafe1ad428 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d606ae9c50b0fc73b46407ffb00a7d6df730551256fda4c923092ffb659858cc +size 376 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..ceb57d97d131d52c4a239c92fc974b48156e1507 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dba80b60d23d790112a8acd6cf1d73ac4f180c308d22f7c013fd26fc5a1e4f71 +size 133 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8f9331042c399009948b63ee25637adf55c86a0a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4b89dcaf3ca790713e70faa595e6aaf14bad80e4a652fe2ba04084b1f23cbbba +size 378 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c6a5ae0b902ca8933fd8a4120587ff16b0e586fb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4df12fd01f50fb5b082a5297b8a580c1556b7498d65242ba7eb153bce1f37e93 +size 151 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..506465e1a5780c8931965183fe21613a51c5977e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7faddf1a13dc879793900bcc5c2ac94c2d053887612a76927c9f0ec7d867a25d +size 39 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..bd1745c9aa2793f3df7be05dc2c2b2266f536d33 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:882183014e87d7e587bea28a4420f8e1459e96e2ac9c50963297af6ec2790125 +size 105 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7955b2dbe531eac4f3d5fc5980cdaf83812f67d2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5804b5cbcf140bb9b446a106cf14b3c383415c452df3fd8997290d540cf25553 +size 378 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0786fc4f162832369966453adbebc233afeedc89 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e603ac37e5b8196ae08b1ef9637d4afe08687921eb55b90b679536ee04dbcaf5 +size 149 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e2b8dc44d769a59eede2ed29b098b0eb7cc642d2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:368a335c14dfb860461126aa4c0560bc1698ff6ff52a711768204aa308596207 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e4d56916d045f632575334ec8dc66d40a6559de6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb494d94fd548140d1603387916b81d44fcf75f4fc2b644b2a2f6ad6f7c9660a +size 194 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e2b8dc44d769a59eede2ed29b098b0eb7cc642d2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:368a335c14dfb860461126aa4c0560bc1698ff6ff52a711768204aa308596207 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..2c90d3ccde168e6cbe9303be6aea56eb968084ef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa2a106adb032b3d9c74314015fe24565b7fad3561104493d88a28cff668fcb7 +size 157 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..52a6484ec995b58c020e2be22fc1996e8fd68f85 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e119a1e3b3c495f0eb9f18ccb523bb34f913a84b0bca2a6112db08f8e116955 +size 114 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..fdfb5c7880f859c004e99b16c2461a4a8f747169 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f03266416470e0d9a16e064d15e99f6434b627582518daef6941407a38f532d9 +size 201 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..52a6484ec995b58c020e2be22fc1996e8fd68f85 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e119a1e3b3c495f0eb9f18ccb523bb34f913a84b0bca2a6112db08f8e116955 +size 114 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..6a6a8cd90487a877b933619490eb087c4c114078 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6bf4cc19bb568543b4eebbe00b54aa8758998f2c93c0944aabf7c6bf3e47058 +size 159 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c79ff510c4a7f3e3b3b736e9fc9eb297f63a39d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e05d3e3d1557470cc4296d74740066f50ce42cdcd5691a0c9182e2ec2bd2a670 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..18607d72b989e820bfa4b8a7e1874f5af48e4a69 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37987711b1000dd60a939702d5794c1ecc69a163d70d809bb084db01dc349bcc +size 203 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..52936052aab7fdc8016e952ceb98893e430f949d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca30782ce442025b7510b41f61ea6d7593525a8cc49d790713f630d05385e0b9 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..afd4c1c8caa46b3bfc0ce9aa7048cac491a38ff0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ad2d309385710d7fa583dcb5f674e699d8501d75c2818088204f8400d7bf3c3 +size 166 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6198d9df26a052dc7272c6155dbc7f0685229f94 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c712948f59cf972ea8677d436f56654fbee7d9630e73ddcf84696cfebe3a3722 +size 82 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..257bf7a169f022a2f754c7b93e053eb127dba3cf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c64f168361054c05707d7cbf0c02ca85d63e3021eb7505bef5f1231c3353a02d +size 210 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6198d9df26a052dc7272c6155dbc7f0685229f94 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c712948f59cf972ea8677d436f56654fbee7d9630e73ddcf84696cfebe3a3722 +size 82 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..3d7fde82008ce337e30a4e88e021524b8f8fc719 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e01bd3b80e010db5ab252fa67d51edd9b16a9e12e059f9fc1d126f724d3ae1ca +size 182 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c79ff510c4a7f3e3b3b736e9fc9eb297f63a39d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e05d3e3d1557470cc4296d74740066f50ce42cdcd5691a0c9182e2ec2bd2a670 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..519ba8bea35da0277adbeb597930e7dcff4ddec3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1a93e6012ff1e341598a72ac247a57793fb9923051d5563935907c6ddb9964c +size 226 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..52936052aab7fdc8016e952ceb98893e430f949d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca30782ce442025b7510b41f61ea6d7593525a8cc49d790713f630d05385e0b9 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..92253784937bed3196ca2bd492e86dbf8fa53665 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8cdafa85dff4e70275d1089630c2dc28e443d8793ebd4a89817dc9d156afb7f4 +size 189 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1039b1fbdf2cad0285ba2946646897c925909de0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aebd74b532e085c2e4322df494c197fb2c5493f6018baaca2fc9b75678edb222 +size 66 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..209a003b22a5711d439fdce2c959e6adb87fb2d9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0932cc042f96116ced932b956f334b2464f6409fa907ea5ebd7d92b07a332c46 +size 233 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1039b1fbdf2cad0285ba2946646897c925909de0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aebd74b532e085c2e4322df494c197fb2c5493f6018baaca2fc9b75678edb222 +size 66 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..79ed3b1be2b5742b6692c213a641029b71e3d6cb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac7b8edce4c3e5e453c86a624eb16c186cb30c2f220f0558b8b0d16cc01f4695 +size 158 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2db76e3c5577ed696fae8150a0ada9f67845974d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:539ef4826803f8528dad7f8be46e8738858e4ad4c4f3e169722cbe07ae3a9145 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e87ac658cc8f52479dd5c5c2d096bbf26674c25e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b48e1466d7d1f2cd5359296280a4ca604744c9e9a26ec7977b60717d1ed7f0e +size 202 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6bd3e0b54b777e675793297bb8e1f9da1b01ddfb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:abfa73be6ec1f45d3a0066830a6fb2a5227b88e3b8934f12a8a667216c67e585 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a654e26812e09d5f9bf212769efd62907a590106 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:68cf1d54c3c91350c8dd4a7e25590726f54f463ffb516eee353c65cbd8fe6951 +size 165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ca481bde5dc347715999d1e8118886c9557dfdb4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63883e259eefb73b78f38fd879ac45d2c1838f42140b73b0f61efedc03043b03 +size 80 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..797edfc74634bdff04f1e4ac677528df91505faf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea687052cf2cecfcd3325e199b6d94342c00423461305f776bbbbe061a945685 +size 209 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ca481bde5dc347715999d1e8118886c9557dfdb4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63883e259eefb73b78f38fd879ac45d2c1838f42140b73b0f61efedc03043b03 +size 80 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b766a034b0b40b4774e46601abf326047968596f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:89e6cb3552f57f1c61fa3dc31f96e804918536df2bd98008ffbfeb3f72c00eef +size 149 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0ad83808862368012c131551d40dd4806109323b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:063fe4376f747f74549640017d6521e68e4c42ec6733e8d7b4173ea273ae1139 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a0e6fc1ede9325b59b6b673171fee1f49926e2f8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a87608561590ffc09bb0c61ec98516ca0e7044f2b6e4741fb87b33fcd8d2afd1 +size 194 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0ad83808862368012c131551d40dd4806109323b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:063fe4376f747f74549640017d6521e68e4c42ec6733e8d7b4173ea273ae1139 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..6b6aa2c993c3c5aecb2167f8512ac6eb6143e75d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:feca5281a2ef54821a24538d34c18a1a2e654780c710071df990346d4768d8f8 +size 157 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e015eb9e4e35a3bcb672e3a280bde1be6cf84d72 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d7dc7e8386079a9f7359b51d0b7ce6467ac2fd81998825ce1fa6586adf8e2a8b +size 114 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0f26e2ac0df03b4700e5350217e5cf36df94f59b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:38d5ccc166279aceb0f5b5e6619420b67c9812d9cc6c86bc660e6641bdeb5a5d +size 201 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e015eb9e4e35a3bcb672e3a280bde1be6cf84d72 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d7dc7e8386079a9f7359b51d0b7ce6467ac2fd81998825ce1fa6586adf8e2a8b +size 114 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..6d2f5accbf3a997dbb7ca86881493d76e21d81cb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c6df22e67ce2eb967fa0d1402ad53e780919731047081de752cb6b2ed4dbef3 +size 159 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ac5bab847db10f055a3ecc4ceba5d56f14065d82 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:434c81deb13de3351c760a1989eba7c344d9c876082afecf1affbfcc83460f03 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ecd1496991b0928a947b8f7650380eee7cc7a77d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd5a56963ae97bf334cf172ba4c6204c8c42353e3f5b2fdc5c7b37c4fe448970 +size 203 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ac5bab847db10f055a3ecc4ceba5d56f14065d82 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:434c81deb13de3351c760a1989eba7c344d9c876082afecf1affbfcc83460f03 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e80492c4f773cb620b56692dcfbac0eb3422cc49 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6bc4e358192055174e4dd815578ee7b862a5aa393294ce07ffb49555adb51b18 +size 166 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ae9b6488306b34357e6f20ef7c4c6218ee0de96d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fa0f41df5f2517eb50f46ba99aec8bb8c930c847f022c40e0dc48d9e434c73a +size 82 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d0a7e7733e72edb3a214754e3369f7746ad4a1d3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c92b46191aeb77c20b7d65a749549087e9c1f63bf08f46e56474491dba50755a +size 210 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ae9b6488306b34357e6f20ef7c4c6218ee0de96d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fa0f41df5f2517eb50f46ba99aec8bb8c930c847f022c40e0dc48d9e434c73a +size 82 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8ef96737a01ffc4fc424a8019d691ffb6ffe61e1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41d730e8fe1285c8ddbb2c966b679d086061b82dbb3cdfd40210d00a60e4a9c9 +size 182 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ac5bab847db10f055a3ecc4ceba5d56f14065d82 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:434c81deb13de3351c760a1989eba7c344d9c876082afecf1affbfcc83460f03 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..4d855e3601a3ae885f0961e15ea9ff5c23df416e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9eef17eef1618fdef2120b9187f980e4188c6f289432e4b0446474ed3925a9e4 +size 226 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ac5bab847db10f055a3ecc4ceba5d56f14065d82 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:434c81deb13de3351c760a1989eba7c344d9c876082afecf1affbfcc83460f03 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..fb8d56134568e056dae6477b2975883b278fe34f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e89ecf803fe4dc58b6c147733fb768045387c44778c38127edbf49219eeb36e4 +size 189 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..15f20185b7dc0c23d7a67504477654ab61544baa --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:422694831a089895731aab0a5e9791a23e58221b384d299936e8c4da34693581 +size 66 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ac2fced1744d9d807daa275d262b4d6461023804 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2eaa3358b9738554a34a6924472e6a1386df0c7af6ce3784873d9cd1e2d0992b +size 233 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..15f20185b7dc0c23d7a67504477654ab61544baa --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:422694831a089895731aab0a5e9791a23e58221b384d299936e8c4da34693581 +size 66 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ff40cde2e5ee7c70714e9203bdc5e11bf2caa8ab --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c64d6d4278717a72eaaa23566ac4fda8fbd67f4decc481e65915a92152fccf24 +size 158 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3660190fdb924678baf00602cfc5f2eda8d8df68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fb2e68eb1b9128cd443cf8306d0e36a2efc14507305b70759830f5b1296ea62 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aeba3dd7342bc9abb733e0d14e1cd172b989e453 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a2b4e8b6d9535c99bbd9502eb88e19e169b931db334676b77ef5771c07e573ae +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..5d22e792b7d9929eb6ddb21f2619d9af13efd5bb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33d9aafcd92cf22fb489cfec521bfa9c9b78c132f485d7ca2d841df023ad889b +size 202 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aaad4419111e51ef4bb367937a9637a6598cc848 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a222bc115eab44665d54922b089d2ff4857259b5adaa0669c3e31b598836a1f0 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..aeba3dd7342bc9abb733e0d14e1cd172b989e453 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a2b4e8b6d9535c99bbd9502eb88e19e169b931db334676b77ef5771c07e573ae +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0761a1f4845e1550155eb6723d9d91c9ecffe1fc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:04fa3bb740fe0dd14235f8320d8a7a0842e3143d58ec6382d7f6f98e7a6efc64 +size 165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..436d73a79959451fdcc5e6fb9c7dc561c303b178 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d64e6d5f85f7e8ed85a3dfb8f2a16c463dde007daa2d252d4b66a5321df684a3 +size 80 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..57015e67d90c60c446a5f104da3b677ae36d11ed --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b6e265a652e51d4688475ec937d849c1fdf904ddb20389279eb65ac7839cac6 +size 209 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4c01d80dbae2686e0971795fcf142530bdba388 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bff015de9bf3d8c0c608e9f38ef7e3f85bdb6ab2ee7187b724013747f6b35e35 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..436d73a79959451fdcc5e6fb9c7dc561c303b178 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d64e6d5f85f7e8ed85a3dfb8f2a16c463dde007daa2d252d4b66a5321df684a3 +size 80 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..f7233d9e646291fda4ac84eebebb2ae279ed2728 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73e8897f49120b013356075d525cd12aaea01402e590f0c3d940449c2756dfeb +size 99 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..691aa143f8af9be7b79e4cf0a81853feb1fa8d0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05c023929a1b32b4bdbd7882ff5e53b9b53762ee2929c66be76d0f0ba7ca393d +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..74fe8112a3086abaa895044ab6273ce5e0cac605 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4ec85ad0ae260ad0ea3db52ac80fded45cb03114ec7f912c6c4b2702f371a1ae +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d76fa9fcb14ceea698885044650183c5370cf2f5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e2c0a55ed1914907af27a107c7094d276d9f9858afbd7ce7f4bdfdaed2a9d168 +size 91 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..88128780e03bf763149dd948c9cf0d40a0bb2071 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:703de0c3be505a78596235789682bc4e6f0e8523f34fb731207b4c076701abdd +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..721ef45b24499df9725ea659c338543e41d889b4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:165943d2cf4746f85aacd3c1a17504b3368893dd4c47bf53cf4b353b0cd7a22f +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..281a7858a90f9075ea2e2d582e3cf7246f57d3a2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:385cc84c2ecd6105d8b7adb5d46308f83cce493743ab4625bfae8cda97807da0 +size 101 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..58f5af5f3237bae3e4133f0888f56b1ed0292c51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0180f5665325e343077736e4903fa43513ae714ceb131deee45b842370df289a +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..50008bdd26a331f1bddf7e2d2456ba5bfafc9ba9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de042500b2705ea58da76a749d0381672ecae1d5b290ecadd95517031475965d +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9bc74dc6c6383528106160c7fd7c95176d88474d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15c564a6cc87d4d826d73c270e4d21630975c78b4c1ccd1cb414fff40c4c7b66 +size 93 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..65a6ccb2bdcb2e99bd08bd9a43a18901e7cd468f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:458edc0b73c6d8d5359ea58ee82eeb6c58933075a0d612be37c2159e3a7d5085 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e54897184bb7b348bb72d44576fa6b73ef20e6a9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f05cfad2b4770c8c438309b0ec431a934f03f72b7433a05bf69b176c7d69f24c +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..92ae4402517fed80c7c607d3408eef375b6b7ae2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a3fe977596c46bf9c085e52815f9fb6524edb2f9128e9a82362fdef5e35dfae1 +size 99 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..58f5af5f3237bae3e4133f0888f56b1ed0292c51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0180f5665325e343077736e4903fa43513ae714ceb131deee45b842370df289a +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8acbdef5e7e24a4fe77f11ac4f008972a13b5d55 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98403780970a377fa8ef991e514dcd8e8266f87c7dbc694042caa06c151c2b54 +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9bab2c2f623d42d2989a0e9e1b4af994a66f2f1c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:acf03351183366186c51883e20e2ec293808015fd481a414afb480bc64bd1c38 +size 91 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..65a6ccb2bdcb2e99bd08bd9a43a18901e7cd468f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:458edc0b73c6d8d5359ea58ee82eeb6c58933075a0d612be37c2159e3a7d5085 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..bdb4a2acaf13bc17b9e68f190f3e68269f534614 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9165a5f600de0b1936974f44d4b13e7f0f553112186313b65c380fb99cf515ff +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..71ce566d7a67185a4ddf8a70cc6daff8f3f83dc5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97ed9b92ef9ea519c739c028e4a58ccbcc9d03db46947c44cfcfc176cd4b2163 +size 101 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..691aa143f8af9be7b79e4cf0a81853feb1fa8d0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05c023929a1b32b4bdbd7882ff5e53b9b53762ee2929c66be76d0f0ba7ca393d +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f7caaf2894d24fc405b6888749e53683a32964bc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d79ee91541caf9cf3cae12fe4448290bbfd99ff68b654e8a52464b5cf1df5061 +size 254 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ed2f6e5c5e05e5b316efa4d5653077259b1ddcc0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c3aca74dbfaf05165f3b7ed7be081c48826a0d8fd0d38753c1009205ef66afd +size 93 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..88128780e03bf763149dd948c9cf0d40a0bb2071 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:703de0c3be505a78596235789682bc4e6f0e8523f34fb731207b4c076701abdd +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..16a634c716008b9b941d19fa4d2a783d4e54438c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9678e93f893f8102285a3fa9f4f3823cb42c35eee64f753d02b246ef789906ba +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bb342a5c19683bb8eb8e7b0b8996e99558279f4c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c6c555ee51925a0d86899411c9ded36361800a09ab3f17bcc1022a5655ec682 +size 145 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b4b92befc6efecc2126134e2c5e78ffc284acd84 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:65add2b5a8412fb05b8501a6e6d0486e61cbe3498f54a31ea099acd350c26e45 +size 398 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a2ecb302bd6d074b5b33ade6f5474a05420f5ccb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4d98876dde2d0105f8604a0a7e9bf81407c353c59f8f5f0bbaee60bd1e6cc90b +size 386 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b05c7f7f58763b35294b2d482a19c7964922260a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:170ff4973849e399dff5c51d02ca17c4704e7be0b6f45ece4d03b07c90309a95 +size 189 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a2419bf3623ae99f66a6d7f9db69a8adade76f5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c169d1e670a61db28d5ae729736ab019603f6f2be267100de045a99815b15a30 +size 79 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0bf2649b5a7511aba0f6c2f6b6d7bd04c5c2d992 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:27f36c1e7f6212c989007bafd87ce5416cfb57deade7412c1a28dd7d6aea99e0 +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..de14a55ba3515c33128d80b20495c4ba2e52f13a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:19344327687a40bb767971e752ff4f2a98052749a535dec27891d2a393113c65 +size 156 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2e75ff00a2c0ddcabc9899d4d6fb9ea3fb017c01 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:527cdefe87f628045a0c16e8f59dd256f94c51f68fd405127a47dd2b454d5a86 +size 12304 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..71f9e769b109f4e491b8b935a0d6224a5640b17b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5aa0effc557770c2444f6618ad3c03d5035a152d47597de5ff080d5aee5fbfc6 +size 11548 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..cc58786dc5f95e339d1643999916ae3a026a2765 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd1c3e047e6f297ca7d0cd46d75e050b0eb2c045a2bacd5ae2b76882bb7a49e0 +size 214 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a2419bf3623ae99f66a6d7f9db69a8adade76f5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c169d1e670a61db28d5ae729736ab019603f6f2be267100de045a99815b15a30 +size 79 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b8d8d16a2cf3e455b6d2c820495d6836ac5b6474 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b4c6fef36a0981f80d2558a3b33e9eb2e30e6ff2204daded24f15bc06f6ddeb +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..745a430d8bf5c57addb9a0a133b7bb37fef1cff7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2b5c3a6e4968e91973f847ff8ff43b2d61c9ae4df6bf4e8d105db92606c64fd +size 172 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a78ecf0897d81e6101e921a7478eabec08181b41 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c51a939bf24fbf792a31df0723f123a31fb59c6ea0d8ac06aa89c799fd9cdd2 +size 9424 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6766f83bc122091851c9fde6d59d49c398a35065 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc5be289731859656069bbac3041af2cc1326d94aaec2dbdeada9a3502fa91ff +size 10816 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..6b60911228cce4bd5c2e605ba48f58bce21cc16e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4dc6abf8fc6b3778103b68215e651351de474f58eaef51b7c1dbaf90763ba4c2 +size 216 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a78ecf0897d81e6101e921a7478eabec08181b41 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c51a939bf24fbf792a31df0723f123a31fb59c6ea0d8ac06aa89c799fd9cdd2 +size 9424 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9f027bbc8e4c6aa69c9b82f064477ecfd1fc11c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e54e3a456e5704a515b37518b1bb8f3ceab1c9597e06ce5ca9d966837cc1563b +size 10816 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..303d5e7ab5e063612d9489090690ef3ec3805a07 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:faf39e37a2c7300a9ca330b2fe28d80a9513aa0f460b8d93291c558cbd41017b +size 184 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3322e271fe73c0429207e3d702c54c8dfd0e87c8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39394d9a9aed24e52e2d88838371c74b00d2319f48d3b97633915cc5d40bcacc +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4de204ae053a5d61e3fddba261dadeefe785d80 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11cc68d90c4a424bb53184ebd7a84af297abbec5393f22ff7c636444e9279cff +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..cf7a22bebac1c7be36827a52ec5db0e08e8aa28b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1c253d7131a304b5ee832486438be60d9fc1f782fbd4268a91eb2b681f6adda +size 228 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3322e271fe73c0429207e3d702c54c8dfd0e87c8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39394d9a9aed24e52e2d88838371c74b00d2319f48d3b97633915cc5d40bcacc +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e7e57092062221894ffe862c179e0d5a5dd06e45 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db136d0ad0abb30777ef618345378036c4b0ae312f084043e7633823bee41bc5 +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ed4c9685fbfa82ced4168e9e93267796ff34472c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37341957bb94869e20c76b34b263035881ccb7bb3b0617e418925969aa2c57dc +size 216 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3322e271fe73c0429207e3d702c54c8dfd0e87c8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39394d9a9aed24e52e2d88838371c74b00d2319f48d3b97633915cc5d40bcacc +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..959383e62b46327f9fdd2ab1232d8917444a8b82 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d73e143036a1dd2f52d9c79283de81851b38cb9cda4f4914541332df0de7e53 +size 51 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bc4b944f42434ec6db0bede1cf68a8b61c8c0158 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:657c937a9218d2ab51eec2468c5e4a46ea50f96b311b50a26ed0ec197040e10e +size 186 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3322e271fe73c0429207e3d702c54c8dfd0e87c8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39394d9a9aed24e52e2d88838371c74b00d2319f48d3b97633915cc5d40bcacc +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2f4b34044d25b97357a6f4e45c019dcf7bbf8b70 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea4bab04bda0ad002df59287ae72647d64b764ff93a1e14251fe14e19715709f +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..300020a6c4035f23f9f9ef1d3498f8155a381732 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:148390ac213145ceff46276feca4190674523aa06ee6e20b47cc5187419bbc7b +size 186 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2e75ff00a2c0ddcabc9899d4d6fb9ea3fb017c01 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:527cdefe87f628045a0c16e8f59dd256f94c51f68fd405127a47dd2b454d5a86 +size 12304 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0294344d3ce981e267745f94288f1161571baa22 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fb96598b4b104da048d13e824354afd627f23c07072b3a582c97d56c6ca4feac +size 12304 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..5032ed93c24e0fddb8718a7995cf614894a58caa --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ce51b7b9fc7f7f79ed1d2a5883701b8f0c336d2140f27aa4e495db3291df53bb +size 186 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2e75ff00a2c0ddcabc9899d4d6fb9ea3fb017c01 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:527cdefe87f628045a0c16e8f59dd256f94c51f68fd405127a47dd2b454d5a86 +size 12304 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..46b256f069a52008d1054c98a4ee892aca676be6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1dc83df0dfbe5f328794af82f98b7f7a313c402859c611cd04e053e114e8703 +size 12304 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..48f038a4e0b397a3edfe11649505bf230ba40d9d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ad184dbe585a8d7a8909b56f9c282430936a833dc601cb341619a99ff8b9408 +size 174 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2e75ff00a2c0ddcabc9899d4d6fb9ea3fb017c01 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:527cdefe87f628045a0c16e8f59dd256f94c51f68fd405127a47dd2b454d5a86 +size 12304 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..63f061f5551d8092ebc5f89e14b35d0eacff6a3f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:211fd0ee562408c494aafed1be3b61f750ba7763b46a57d74318e83dd0ee3210 +size 1216 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..7e395d1fd817dab3c97345381a34ac8e194c763f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd79c5b1ef52b7ce964bc2a58d4e3e2de19f4aaafd1fdabff99fb618f6a27460 +size 166 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ee2aa39211d7e6f572c99efbd1891315f0f611ba --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ff73d3f9e82980ed6ccf8f2d539645ab2a0626d1891e5c463188f67a555d706 +size 393235 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..213e431c2b81a8302a9f8c0d5705a9a52018dc70 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d69fcd541ace04bbbb90fac02c80d2e8cb9338968e4b67ca8b6280bcef20ba8 +size 357511 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8c18ccaed7d3dc10a811c5fe97bef8799c7b2e18 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:703ff5b428e86648c0729222d10373aa699ba55fc01b0ff6af4de581cc501596 +size 201 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..15b11eab7223cfe29b6393639e07214911842280 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4672555872aa97ee1ce75037262093bc57beaf2f28e5b6af3a7228b4ecd914af +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..86afca9241f05bd295f9e7bd4bd08756b562e0f6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8bcb9893116c8e68788cd0f09a00ad57b8d0b45d759f00b02122d329fd423a08 +size 51 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..687b129892c6676d595550c89fb132f631375a7a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fcb43a19c6efbfe4f072def03ee08ee47937bc8cd527acc0263aac0944e2112b +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..20ce01273053ecb740b683a54182f30738dd66be --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fbd45d82fe2295740b6abf36afc4c191d6b92ccde7a2e6dbd1019905527dfa60 +size 204 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..15b11eab7223cfe29b6393639e07214911842280 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4672555872aa97ee1ce75037262093bc57beaf2f28e5b6af3a7228b4ecd914af +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..86afca9241f05bd295f9e7bd4bd08756b562e0f6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8bcb9893116c8e68788cd0f09a00ad57b8d0b45d759f00b02122d329fd423a08 +size 51 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6da55a586cf7be1a7a3148ad3af78d6e730073eb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2b8bfa3adad3f8ddd02a7901554aba873abe730b167b45054a5765f947b6801a +size 51 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..3d2625e3d4ee00950237730ce51b8c220a9fe3ef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ecfb66d932aec9c723809cb9a4d44ec46311a4803979c858d0bcaf878501ceb +size 308 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..df01b0904cb2d02fe9aed94837436e14597b55e7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7418da057ccc7c5228bc5e395454d229ad52cefc620d4d9c9eb033337b4e63b3 +size 51 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..d66d0d6bcf45111fee68ebaaa3175b3d3a7d1f6c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0a8bfbb79fff49cde76b5550a53283820d563b68fe81252a3f620a17fe7dc43 +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..8472b6e91be16bd97e0800881bac9045e2317765 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9bc65a69f0e93ce299445de7e370a04d2e6b636161f25bc953072486a578956 +size 546 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f7b776f71aba2c2dfa9ed1a117dcca3403b7a7c9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:22bbf5afe91a4889a7c2d219931c95931b04b793ecaad863ccac6a6ab8a6c139 +size 92 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..775311fa7227b87ddfd5536d7775ab3d6f0fb170 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fb6c2918b5ccf3b188183b0a81fda288a805f04d85477ec1040d58b053240b7c +size 323 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..df01b0904cb2d02fe9aed94837436e14597b55e7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7418da057ccc7c5228bc5e395454d229ad52cefc620d4d9c9eb033337b4e63b3 +size 51 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..d66d0d6bcf45111fee68ebaaa3175b3d3a7d1f6c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0a8bfbb79fff49cde76b5550a53283820d563b68fe81252a3f620a17fe7dc43 +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..3dc89f7d86077d34b33d641fe74d5568ca18fbcf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5fa8fd1cf0355e45a67eafe32c3d8bf310a1bce49869e1c2f3ae9779161c8d82 +size 165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5934f697101d808de7b5b9a71e7ecafae89f1cb4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5e249cdad13f832fbf9011a671495df13fe0f0ed951017b0c0a21e78857a33a +size 47 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..03127096c01884b64698cec50786d998a2c3a617 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:357a376dd7a29287830989a43b8e909556386c118465f2ac165444ecfc3946d2 +size 250 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..99e2b144d24c2b761cd2e82531b87d8fb08c012c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2e11ebbb9f03995247c1b80e5bc3e78f058d31ec84b77b8e2835718cc866e44 +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..71d8979b7f6303fad39b48f74e99d513220c4fc4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3811afbc35b6bd7958ae3c00ee6c0ed763acf834978aba9d6368c3d0ecba0a96 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..37e4340f3fcbb4c8028985badeaef900927c4ca6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df0135bb529c4d8a6831317ec01934d370ec5e751cf681064c5c9c214e230973 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..3b47eb281243ec24605c4c71354d7a63f67f9f92 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4fcfcbfbe5e064e75b0c65121c858636a6132d3bf5c85ab6a07e3cedf008d2d9 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..20ea60dc51d6218fe4222f9c33010d679d73a2b0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e2e82749a2d3e3fb7faff241ea93e6169cd2c5440e56dc681e6ebd651bf4222 +size 23 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..01054c15240cfdd3ca99cfef996266d63cb3659c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fa5c52085723496dc42de4c8f648a1f28fcfef8e40128e1e4a225cd5c056e2e +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a26efe200e370fe403b7ab49dc7cb67559d534d3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:480ada9b191b226af4be66913f1240fb544bad0693c7caee77cf51d16b99dc92 +size 364 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..99e2b144d24c2b761cd2e82531b87d8fb08c012c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2e11ebbb9f03995247c1b80e5bc3e78f058d31ec84b77b8e2835718cc866e44 +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..71d8979b7f6303fad39b48f74e99d513220c4fc4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3811afbc35b6bd7958ae3c00ee6c0ed763acf834978aba9d6368c3d0ecba0a96 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..37e4340f3fcbb4c8028985badeaef900927c4ca6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df0135bb529c4d8a6831317ec01934d370ec5e751cf681064c5c9c214e230973 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..3b47eb281243ec24605c4c71354d7a63f67f9f92 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4fcfcbfbe5e064e75b0c65121c858636a6132d3bf5c85ab6a07e3cedf008d2d9 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..20ea60dc51d6218fe4222f9c33010d679d73a2b0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e2e82749a2d3e3fb7faff241ea93e6169cd2c5440e56dc681e6ebd651bf4222 +size 23 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1166d4db64afbea84f84e98b02b7a40a7e4da9ca --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5937389a6e26762c8d4a6960c67c01d7bb0d9c3365c3f8bf9879d769b02c13da +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..42923aa9f9c53c9d842ebcf59766024fcee00354 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c74ccdf1adde79ede83a4f386098fe6630736b302225b01b8ae8e66a9e72a47 +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..bcc057a27c2e8fb3000b7efbe7f32dfe47d592db --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:379e79d46d15f20970e80c86e23329aac38bddd2e82e53fc51458d128cff559e +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..f68412066f3bb82b767a6f291f30eb3dddb6672d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9bebdd2ec1cd6bf91edfc57e84b490c0308178688e187f384c0a4921187ef24 +size 231 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cdde8f14502626920ce76c84326cd586ec8f220d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:49829de4f179bccf9b28dad5f284ca3c61ef604d2dc32bc759d16ddd3ebbcc36 +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..e373b1fc126cdd6f9440963de367ea5cd1f9d70f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:008fb7467aed45da985acb8bed1e3fcdb67455bef37e768310162c9b48b692f6 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..0e919eb4a7372a46a4c91038d1679832af31a6ac --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da83655f1bced169d0d282d7af44ae4303a6e04ace71af11f5d90d2f07b00cae +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..a5e8eda65879bd888af811cede4e79fe806ca874 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77ad268ea7dff736ec2c69d10fc186f5b6c4936ab257c51a61d7bb2da07f9b27 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..4acddeaa1a5ec47daf611620e44826fa7240fd47 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1321e836bbb418f21a24b029615bdb4350aa47aed17ae5f8c1dcb0a08581579a +size 23 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..49cd993b42ebea83cf2018b158567db5ed7903c2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1e5a3b846d7c03377941eadacd528321ce3a91fb658293e46df4a6cacbf949b +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c344b96ec3fc54de8bf552303c5d1bcd178b046e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c068f5bf93650e3d87ef344934d02120cf6c87b4d6e9b6d5bd929a79cf8f5c1 +size 345 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cdde8f14502626920ce76c84326cd586ec8f220d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:49829de4f179bccf9b28dad5f284ca3c61ef604d2dc32bc759d16ddd3ebbcc36 +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..e373b1fc126cdd6f9440963de367ea5cd1f9d70f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:008fb7467aed45da985acb8bed1e3fcdb67455bef37e768310162c9b48b692f6 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..0e919eb4a7372a46a4c91038d1679832af31a6ac --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da83655f1bced169d0d282d7af44ae4303a6e04ace71af11f5d90d2f07b00cae +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb new file mode 100644 index 0000000000000000000000000000000000000000..a5e8eda65879bd888af811cede4e79fe806ca874 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77ad268ea7dff736ec2c69d10fc186f5b6c4936ab257c51a61d7bb2da07f9b27 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb new file mode 100644 index 0000000000000000000000000000000000000000..4acddeaa1a5ec47daf611620e44826fa7240fd47 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1321e836bbb418f21a24b029615bdb4350aa47aed17ae5f8c1dcb0a08581579a +size 23 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4d8d1388ebdbb7438283218192d88e0b2a54d36d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7be948108643fefdbc37bf9c6cb74681029a4eab23500eed9ac737386370cfc3 +size 496 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..7330dedf13d370ab1cdc8ffa8c3408fe868980c0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:074953f727892fbe99f1526f30cdbd945cc106acd9ee27d08b49cff11ae287c4 +size 31 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..5b8551fcbffeac321a51e661f275956a63b60da9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1dbdf502734e089ed220c0e49be22e4bc589691c31075aafb9225e7489df5d46 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..18d68bb1e71b097f2fbd56cdbe3cc845aa435f8e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0df4a03dc59c734c293515cebe797878877c03f43bc9a1c8eb79d2fff0b5b6eb +size 93 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..dfbb5d70a1ab4b5259d53ca7b759f02d90cf0bdd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:872249b05aa3759e579c08da681841d18351c5bf40b86b06b017524b5b5eda2c +size 89 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..65ddc834cbdd991d26c3dd980af31cf7d3b0b84d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6cf5a0ae44c4fe407284150d128a49d48c5c9e72c0c92c92754d0f41421da8b +size 89 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c86775c6bd1ed82e3fd2ed022f89335a36cdf1ec --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c743c3c2f63f4791adbcdda933d6c695c53983683f12494d76fe734e920e845d +size 114 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e5f674ffc39247cbf821d924a873b1a27ef9163a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72e3d4b1012df2b2d25188aed8f8725cbb9d0f59ea118697aa81b5f34b3a7a2c +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..65ddc834cbdd991d26c3dd980af31cf7d3b0b84d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6cf5a0ae44c4fe407284150d128a49d48c5c9e72c0c92c92754d0f41421da8b +size 89 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..79d27586e302aca8edc024b67f951fa1e2557049 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56b264f1ce8d53ca343abdacaa3bc8564a98eb9a6a687a6671582391f79c0896 +size 446 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e5f674ffc39247cbf821d924a873b1a27ef9163a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72e3d4b1012df2b2d25188aed8f8725cbb9d0f59ea118697aa81b5f34b3a7a2c +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..65ddc834cbdd991d26c3dd980af31cf7d3b0b84d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6cf5a0ae44c4fe407284150d128a49d48c5c9e72c0c92c92754d0f41421da8b +size 89 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..f305654318daa0074bacdef53649714140e9ac7f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8b52c811abbd8e651db2ba045ddcde16c87ddaf64a38ecfa448f7e5cae708fd +size 409 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..dfbb5d70a1ab4b5259d53ca7b759f02d90cf0bdd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:872249b05aa3759e579c08da681841d18351c5bf40b86b06b017524b5b5eda2c +size 89 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..65ddc834cbdd991d26c3dd980af31cf7d3b0b84d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6cf5a0ae44c4fe407284150d128a49d48c5c9e72c0c92c92754d0f41421da8b +size 89 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..266f7178a30531c23d3f0121c14fad919b3e13c6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9ca433cce4af10d04916a45af0ee63cd5805492f019d0b3d6f5a33feea221998 +size 114 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e5f674ffc39247cbf821d924a873b1a27ef9163a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72e3d4b1012df2b2d25188aed8f8725cbb9d0f59ea118697aa81b5f34b3a7a2c +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7ff8346a87a17793a8d0eadfd51e2f563e4754b2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c034e3c8493043dda3d518978d4b582634b5e0ec242a49138a1d267454691867 +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..2b51eb16de44b730e882f48e74c439e7c1cefb62 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6185fdea2b2ce267c795c1420787fb57f59cdbd844e967c1b0486f32aa6a5fa +size 452 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e5f674ffc39247cbf821d924a873b1a27ef9163a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72e3d4b1012df2b2d25188aed8f8725cbb9d0f59ea118697aa81b5f34b3a7a2c +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7ff8346a87a17793a8d0eadfd51e2f563e4754b2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c034e3c8493043dda3d518978d4b582634b5e0ec242a49138a1d267454691867 +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..cdec8d302097cc88559abb1ce70f99b431dd516e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e765dfd23bd2f574ecda375d5728c3cd59908f444f7a2f4353fb19c94ce06d6 +size 145 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..fb854fc42b2c8b3088e3466e91a8bfabd1243204 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8d0d7bea3c4100830ee6e973ff6476b7f44c3426310615812ad110be9dd53e70 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..a06265e1a75a6080107c5dd77e3ac1607a0cd20c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77fc0544e981bc301aaf91158e21705fee4758ccfbfb75f5e5e6a8590bfc0404 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..48e57609c763c57f45f27e11c635c26fdc93965d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1488fe902e905faf6072363664b3db240798793c58843a13a61759cc11f2c6be +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1cbc7722da7b58bf900cf516fd13ffb1e0aa3ed1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5dbb2175ed700209deda90469300e72db64916c641fa71fc20d529fdfc8ab07f +size 145 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..457fc8ae2c0db7d9c91e400778b6bec6c7a84011 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f48e67c814092f866bd2b311662218a3d4d2800b6ad9d066633d4be5d0ebe93 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..b6c10c2292be1d8fab1f9a132b7c5a1cd49a598f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2cf1a07f2d2458f7f3c1b78f4badf39419c745c8e7295993361979e83413fcb4 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..89152febb002d69670c4865c8c0e33f813dc4642 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5076aed63dfad5dc0db8ebaff465429433eb12f02c10c0e753b919f4a6bd5c43 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..540faaeffab1b277eccf16b223bd4699a1bc84bf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba2b64d995ec0819d3ce358f86c1793cda22c08e440827d0be9f44191d7d30ea +size 145 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a7ab22b1e5e87d724142763a551d88c50e38d60f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:81d22da655dafa06a1de4cd8ab471be0dcbb4b09eb429363081bbd070bd15ace +size 33 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..b39be537b5d6b069677d34abf5bec39e7bd90452 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2bcd1118a9c8ee4844d5fe297fd1010dc5057c11b5be20793f7bfc27657fecd +size 33 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..120e8bec7d8bd6cefd7d4e219d4a6ca40c1e6497 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bafdbdd46d8dcf472d2cb33f663bda16c4902e407a6308f5409d9a9ba8eb00e2 +size 33 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..66935d206b0f2b573677be5f3d59cf9a5d019dba --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da1284ac29f2be79947a0501397de2ffe39661fac6c84ad7a779f8365be25f0c +size 144 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c8b2a0abb0e29536b8f9526882e6e0f05e64584b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:369adefe41dc893c239257ea1e9c4924fe81253085eb7f331c00702cb4892d57 +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..a80982baa40ca73b262dd479f297ce87678fbc15 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a65f213cfcc8fe55d29163476c5000849e37227a8967fa46923515b5ba5aa75 +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2e199dd060e48445bffa0bab931b9651144bb4ad --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:86d813d2c6c06dc28791af77ab282697a9bb40ec95fd1341199fbb05f87c5568 +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..103c67db8bc50d5bb165491d1e77bc906bff4bd2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:74cbb3b4a57955cc459a1c5843fc3dc04a1fc91362b437fa757953f0ea4e8788 +size 147 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..fb854fc42b2c8b3088e3466e91a8bfabd1243204 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8d0d7bea3c4100830ee6e973ff6476b7f44c3426310615812ad110be9dd53e70 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..a06265e1a75a6080107c5dd77e3ac1607a0cd20c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77fc0544e981bc301aaf91158e21705fee4758ccfbfb75f5e5e6a8590bfc0404 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..86724dbcbc41e69e92815cab16bfcc299f3e842a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39682ca3405de07edbd36674b7ef42e8121ed09ab164f978c79a4b0c2b87fba8 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a1736e171c40fcac9f0b5c60b911222ea0f56f4e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6525278061468499b87eb73f37a2c2fe73931df3a681c1295419680576df858d +size 147 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..457fc8ae2c0db7d9c91e400778b6bec6c7a84011 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f48e67c814092f866bd2b311662218a3d4d2800b6ad9d066633d4be5d0ebe93 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..b6c10c2292be1d8fab1f9a132b7c5a1cd49a598f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2cf1a07f2d2458f7f3c1b78f4badf39419c745c8e7295993361979e83413fcb4 +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c56164c4c28591cd650734e5d46cdc14cba7c4df --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f475bc627fcc5b63e5cbacaca7105b9764064c9c19e874dfc7b176656081f24b +size 21 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..95cf01ab5225c1256487339c1441bc46c5a5440a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd32658841a2cc190a809a2a538ee38a88c3182edad49272b7538627d7ffce36 +size 147 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a7ab22b1e5e87d724142763a551d88c50e38d60f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:81d22da655dafa06a1de4cd8ab471be0dcbb4b09eb429363081bbd070bd15ace +size 33 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..b39be537b5d6b069677d34abf5bec39e7bd90452 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2bcd1118a9c8ee4844d5fe297fd1010dc5057c11b5be20793f7bfc27657fecd +size 33 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..49600df92552fdc6c286dbc5bd4e7392d62445d4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7085c499aded62909d44861d4a217c507e0fbde1f82d2bb79817bd78ab5ac516 +size 33 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b879e669d73ab7949f6af376036172dc2d0ca4a0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:162ca12ff68387778982098cd32a9cce60bdfcae33e2bf8d542dd2a35ce85ff2 +size 146 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c8b2a0abb0e29536b8f9526882e6e0f05e64584b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:369adefe41dc893c239257ea1e9c4924fe81253085eb7f331c00702cb4892d57 +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..a80982baa40ca73b262dd479f297ce87678fbc15 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a65f213cfcc8fe55d29163476c5000849e37227a8967fa46923515b5ba5aa75 +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2ddb89cf3e27e2655e6c72da7b38ccae698bf269 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c50c1ff3f9e55fb0e93aceb58645711f571a0b81bd3ea58ebd875481008516ce +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c39fd5678260345024ebe5f3b66e26467b7d0891 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c9cf9804407e039bb5262da64a4a0d80617ced0f74d665fc5b387f0b139979c4 +size 166 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..149ea2d2e32ce832d92206871182243a71fe235f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e75fe0d749e1977a46307cc864f6fdb8988890ba2a2ed011818c416515c527c0 +size 133 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..8f484ef6577de6a0947dca32dacae6f6d1e24c68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7078c1b80aa50a771362118b6c398b475a0741b8cd7691d5b7a328ec2837d53a +size 133 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8f0c30df36c26862381fa7ceed3761a157683d8e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1e76e5c5b4be8cc524d09a4b4957b3a5ff57fea3f623f139ed5bff4d7c4db9b6 +size 142 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..87bdb7bccf1acf360c5458a567643315f986290c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:548e44e1e34becf744371891ec15874e92501f8276d93c03232628de2eb1d9fe +size 154 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1bae3772c9703229bf63509cb0be9b16039b7140 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc146d45a80f85b64693fa69df96c99e7ab0f2f6b71cb404780fa04691abfdc8 +size 59 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..d6e1a53a032e25fc83dcc940ddd3e207a6e40054 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:18b90e5acfba809c593955607821a96dbc58e14de3aa3bd16184ae9c3407c634 +size 59 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3b9539811f2bf692ea8ae042860108f41c108e29 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd26346e307a90ef2039d4da42a19526cb46b3046d4e743d8687d85f60d56482 +size 68 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..6c61d4e18d650284790f59b3278c1c5c1fff9ab3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f260150e14bcab6f7cdd40f8d939f652d61c8faa3f18ec77d417faace4279a27 +size 234 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1c9ec57b55ed1a5c0238628509f037d8f306ea83 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd5d55b7c7b8aedec104cc02593be96787b034deaeaf1ac59c4d3ea1301e6d8a +size 155 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8340555f931557cfed527afc0e8574b60c06522b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa7f737bddca29e9015075f5cdc3c53d0b338676f4c421944367148b8bfe3c17 +size 82 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..6c61d4e18d650284790f59b3278c1c5c1fff9ab3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f260150e14bcab6f7cdd40f8d939f652d61c8faa3f18ec77d417faace4279a27 +size 234 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3d57bdc0b85c7182b3cb5e71cea44c67865a5ba5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f777e17d09325b1b1511b8b09e6871e51b4ddcdb868b1af21477181ab06a8809 +size 155 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c3d7a11d85b3b8050e64a25684207c9b3d4b50b2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57df2244555569b992c5ae9140694e03b0cbb93b027ccc142c1a29a2ae4e8044 +size 82 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0131b9fdb14f82fe01e74e562ccd3299ce553fa6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c1f2c2519762213043bd154a1ac89d8c33ce45c3746153d5b57b9062a630792 +size 180 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..659f151e6775feb1b45e5949f5c1681ab0761346 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6cd2dd80b3c4827795d9d629c78e19fdc35cbbe3fed53b4b7b70711c1cef4927 +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..406eacf7d7a728e35d74f71f434bc6ee7d111019 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:178d1f0e35a575027169b33f5d890bce910c7b3ee32fa3b37899606e8b9746b7 +size 229 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0131b9fdb14f82fe01e74e562ccd3299ce553fa6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c1f2c2519762213043bd154a1ac89d8c33ce45c3746153d5b57b9062a630792 +size 180 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f6343181cdb47a86f73b145cf4eabcaccbec8d16 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e90cf8acc656069f9f20e760a02781c0b059be06c7e323012ccd341c4d5f32d +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5de694fe0afa13afd6946c1ca8518f2bbb74dc4a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63f72c871380f41ff5c5508c6384819f40a6b7f36e15fde02f9b6687ebcdbcf6 +size 229 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..89c1620fc7d69c863096a1c685422e8ef79bedd3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4946b543220c959ec5e1794c3497c0c4b022371fe03d135172b6def6d5212f4 +size 196 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..74f60d066b26a1c4e047c3cf6e788147709b407f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fed8606684b0f4c5f7ca3e8279167141116d6407468cc997444ff19689fc3a4 +size 1551 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..87167a9a9ef33ee0d294fadaaa043279e6d11e5e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15285cebd3b7765076834990f3e8c8da41a93324f259d300f13005a2cacfc90a +size 207 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..dd963a11aeac7e4c281e688a63473ef84ddffcd6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b80276bbf2f4e3e031bfeef5a8f5342aa7cad1d52b0c250ccd3ed119b6771d6 +size 196 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b7e2f9690775bd4d5ca41c903937a3cab72b500d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbf4e5fe5af9ba815faff983395a75d28d51ab0b68ddd517eeecaa6d9a61b656 +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..85a266942a0a64f5635dec27876dc24427a78e74 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7422e8702d212f9724b043389744aa6506872334446f2ff520fd056f02d67b1 +size 207 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8778364e2e0a49d48c1c664f61482e58789a7b1a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:edbb2cf2c959d75ff13e1e9e90b9db3eac12c7ed96ee7cc195f48dad682e1ffb +size 196 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..788f0fb56c3fc7b7270bd3f0d96fc8628491f302 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8497a5c52894960fe8f122fb1a72926f0ccad714c9985c0e19b627ca650b73ad +size 1551 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5779b3b4f25cecf3c6bca3c8a3128b38d579ac2b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d19ae234298ff644f42db56b47f2620103bd406f554b47ae41a8adaf9aa3d74 +size 207 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..206146475382fe455c94e088b82e1174c28378fe --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:29abcf99a4feed8997af5caff39b9e52d7a6bab8deb320799e80f4bf731ced17 +size 378 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..09a27e2380aac9572e23ccb1f13e5010b336bafe --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:59499822f69cbd4c4ebfc678e15b79a161cfdd1ab49518d7574b9346b541e0ef +size 251 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c0dfc7778c9ecda036fe037d2fff564883bc5962 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17c8577f8ba36b0f7090a5c9387db6b32f5df827c10cba75df2d7a84ff3f420e +size 251 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..4cb457e59973f98ba171343e66d91e76bbae82cf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f187749e55da7ed28169e9638a6098257316f7d314eaba3a0c33243454336752 +size 354 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7e2f2e5d321f7e6bb544db64248f011ce528ea68 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:59922c97c81d4d2a64c9b55d336782f940dd9f051c949a6fe828b3d5d25ad95a +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..abfe299cadb6f74747e1cf8f13450ef2a70511b0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6b326b09b3ce9ef6a01f22c8a4f5ae042196c223f62075c79b3bb987e7bd4a2 +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..808fdea75200f3ddf2ef216b409af0ccbeb194db --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4e27a43a45f8dacc42910c71b7b5f925de23e07feed7cc387535d5bacf5cc80 +size 354 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..33adb55c6c3991ba05ff4d1f0d7b43ffc012a0cc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e5fdbbb9c90eec03a85e5c11f4002d7273038a2b3ef1f32c839d7a862ac34a3 +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cb6f9fa6852429f4b792db55d2a9122ce1895603 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d144d278eca9e0080cd414aa7d7f05d73b78031c60e5e5a9c69ad04656febf44 +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..27a42d1801c78ed30b9d75b575b3b4a3dfc803cb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1008501548ffcbc33f180ffc3742183df6caad9c9f943c4485561c9f9bf67cd +size 362 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5c1eac0547d755199a12890299a97bec476bfcb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c5670e94b4b6d716ef4ad5cae55cae40eaa13e39581c95725e5eec6fa0e13b0a +size 1551 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f7f833868b174902d5b0ad5766eb93e77f047073 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:40bbd328716a26c20868a37224fc62dd0079feb42d43b549fdcbd0d6c74f38aa +size 1551 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..abe1da5bc520686d00863e9029e24f298e46192f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca30f9f606c114c8eece702964fb093b10e8c8a93571ef267a84f8cb568fba7e +size 362 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..81027da6c646bc270321c362a2c40b14be2c9117 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:288c9a6c44c98f63e44b40a4ef2e483c08445eb3d0dd02ec425b2dc19bc20a76 +size 1551 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..620ba243b05fdf7078d557d11be051955d7c0b55 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ade124ac423eb248e713f6387c4e7cf04c689c9b29e055969fa899d6434abee +size 1551 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..21350a15222a21617e37356d6ef98b3fdf569d71 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d12b040bf6740eb10b4151eb6971ba07344f7eb76b23bf1e0fdde7778d205d73 +size 177 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..890da5390fecb1d0559c1efda1e2b4cc9b1defd3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:428394333ec2226efd562efe16a16b347fc5a66da9c238894c9e4a1c6b01faec +size 397 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ec178b68ea6a3ae569861d7941859562bb2ae5e3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72b1e95e8e05fd33cf927883b95629805dd37ee6d52d915e4842afaa14e4be9a +size 1861 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ca18a4d28d4b2719dabe502d8559d5107f20e374 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6784029f6f72d5d8c9dc9667b858f838882c02aa92663e3b8c9f85a50a9cf10e +size 525 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..da528f7cae1f056d172c76abbc0cd93b6def9c97 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:335a771df5f7b7208dc4c3945f2b5dc7972ae00505af7f0c19df02e62e8f4c71 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..50a337900304ca56585d2279842817205589709e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c6f15ce3daa142241c12d73939925d7a9ad0d95ecdc68e44ea5fb9181c836a3 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..cf1eb0da8bfb26abed2458c694c3e48b679600bf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:096963d90634e312f4577f517ff43f132cbdd245545cb2ba956202229113d8a1 +size 525 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f2d96ec31ba44d07c7847a06caa37dea1410598a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc4d996072ea3c469507b1d143936f2655f00b696e131c69fddd56d976148712 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..562c23a5dfbe38ecb2d18017b05fbb7f4ec69e18 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46ceb2b4c11099b5047ce2c35fbe98010ea10d2f89c54dea478bff962b20c9de +size 251 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1127c73fa84c66b7cf0c8de1beca2605b5cc9284 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:442f258806824a6df94ccc4146736b24a20c6a6f364245b52647343bfa918b9c +size 433 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c4f52c605019ec7fbc63a27dc85290f16ae853b0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b65c22420c44ac106a9c649881a41b6efa344f57387b2b587d3de72302d5cad +size 203 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ec0318e4d72d079c119e965dd534aed95f3dacce --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e8d308d9ab17ca6c50ac662ae7d4834ab574d848dd3aebd567287c95fbbc2fc +size 203 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..edb7c82174c729d4c7b5f7bb8e25279b27d6feb6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c04576b8b1a0d55ffea26134abfcddd50161a3021eb96a55309898b6edd3818 +size 525 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..eefc9ffd762a57fe82cecc90358f332042575e04 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc2b37f24957817bcc538c5a408036e2b8748ebae583267e2649e50faba4ff4c +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..92082c77f2013b57d744364d8aad3312cd6e71b1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e65ee1ba0ecea1aea5ff5a58efe04f24040f7b4d5811a9e5dfb50a11a95cb6f5 +size 411 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0db293637047d1032003e44b7a78f4ba7f639921 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44f2689b09450bed99316db0c25ea8e987d802dba9ad8b9582f9cd13e34cb26a +size 473 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ccc68470e033faf2d79ce3e039f4e82aaee560b6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:055f4bf74f8c8f0fe1285268d4a0ec7244ecf4a35f0c46183733ad1031006c46 +size 26 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..30cb9478a4ddda8d089d960fd63886e282939066 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42b84f52453522269a406f5ca3a69e07b3cf9fa23cce0aa3446e03cadd71734c +size 26 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a57220edbbe79fecfe37a7816951fa2265e7a53c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e81b5f92462708e1ff39d75006bd9f8ba35b6f08e8f585823caa271710815bb0 +size 685 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a88ce3dfbbf2047fef2819f97f16784bde8ad4b6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2b02153a44147d942cc958b858e926c5043a8ebb6a71b542f479eeeb76686e54 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4db1a456872fa23215e550c6f2e432e13392b06b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fc2370839a5bd4562879eb3e02047be8fe1c2afc53f802d4da6f89d889e3f86 +size 411 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..11dbf841114f55944fcb9b8fbb38a571b3bb85c4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:65645f48212b3a34cfd6f1d96109421ccbf7a680aa1cd757948650d908556a46 +size 601 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7df21a5ff73c17751a71f7664f2e9a559eb2e4ba --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b92fdfbfff19258ca9a1ee5df8404b38b85a3d0e004c4fca3c73884371aa7ada +size 26 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..939d4d2b8bfac72d72d49811cd84ad0f71d21d08 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a0af238013056ee244f3bb9259d6bb98c2830e3141984d15b6cd7bc76f60dc37 +size 26 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..76b8e58da4d1c0ea3793425a7d09263e5698df29 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6d8e22558acd9e17f71883bc09b90cb4d6449d6772d98eea082e5da149d9d1e +size 525 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f963d176847f4b0c07003be12f4abdd88506c850 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f421cb144abf8a4fd5e4b6aa4fb99ccfa48d78738886e22ebff8efc9335246b9 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..69b707a88eac6ae6b84b2ffb98e94580dadd9c37 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d29361ed8d237ae03f4460b5deb6828a9675aa2a99bbe633edc2f58c084e9448 +size 171 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b7126ab14f7a09fcb1debad56ab5a4aa1cea5772 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb8df62b22401aa644e46e13b55b7ac5f3c3814e002ff939a4bbe112720fc066 +size 593 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d67a0a2316c2f6ad5b2215ee81a60ee0502fbc51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d4e066b8dac7d27dadf0d18760045c8db6ad2488da2b9b4d437af9449f6d7795 +size 853 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5d3ae14acba23c7395142c60bf936636ac0f954c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:26593b3a6d313f14df4c3dc44649b5540a34c7f9563f5334d6fb4343e30e1870 +size 653 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a1d438e564271a5d9318119e98e405685f86eb3a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:89f453d1aac82099bdeb72eef7656f499190a12d8e427421df91b00d9545fc15 +size 449 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d12d879486e0b1f9e3cd9437564812d414b6205f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a083c77fd517fd532dfeb36baf8cbe5b06c27f73dad6b8bd773633c8fb430809 +size 1165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4dbdd5ab694bdd605ed72690a402e5c9022ffad8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd13e6427aa4a23e1a55cf5b40884789a4938204c4deddc0b5411f2f50e175d3 +size 525 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d96078087bcf015503fa06e1ba662fe88ff756ff --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e91a334e84ec5e532732b3c8a4323d3ae6294cef7fcb5b6c906f3da1f59aa84 +size 449 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6bfa3f6fb1c9ad08f00fbd380b9a4666995f3f26 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f118af2993a3d8f5a3fffe7b9856ecf6b9c65d1cb2752f6e31708aeff0f5fa1b +size 1165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a9b54e444dabcf5070de83fc0aedc75d596a834e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c73bbba981d2a7548cffec8d1a37ea07d69ac56c40e858a1e1514b83e6e9cd0 +size 1165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..966168acdb3835b0fb91ac7fc1f08e4cf222d0d4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f4164370dfc5438879f86bb22a7b2b162a8596e0c1855cf1cbb663418018bfd6 +size 449 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..858083efde005594562359ba6dfec9a8ef1886a1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf8c52c69446d56c0225d787d5dbd447707ef29ce1b4283b22d003413c24a0db +size 1165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6e4e119b6507302e4f59196a0e381ad582969fa5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84a30a3f316a3332505bf519ad6114e2eb63c87ccf6af494ae333f40b71c081f +size 141 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..cde815b92a11f9c867054209e558d57276196b6d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a74ce65ac65a324b29d2a52fe5d4ec35ae1bb7e2cb3c85a469439e077f10fd81 +size 609 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d70e50ce2e12ccafdb644e28215833e9368314c2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e103ad686b0bd49ced278ea064dc53a0d2adfa1cef0bf6fe81abdb53e253aef7 +size 1165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7cfee0cbbbef70900c408031a4cbe99aaa3c0dab --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77f1a0f0fc22f9410897264f208675688a4516fd70862e947e397afa3eb8cb1c +size 1037 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bb7a8f8b430890de42efeff7a5e80132ec9b4734 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3384e8834947a897ab76ef63702b8a3630ae115396d21f44ab8bb7e93ee18f04 +size 513 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0d24712220fd5444fbda473de7161ffdcd0a228c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:47a18a7b21299a3077fab44727b9a78c6ad345f2821497e0b8b8c1127662187f +size 1549 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cc600bd6fb7652dcc5cf29b8b0744f1111a34d8e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c34da36bd4318d8183c3ad3a69693bfe84abe65502a12b66cad6655667b57afc +size 157 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..16ed9d1b02514da006e059fa3c261936ed28b973 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba1fa246bcd26c5eabf7a26ae0d4c69ca57bdba1c10e7bfee69863a778a21092 +size 601 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ee226f55c028d687bc7b40baa3e2c2d0b3c32e24 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:013cc774e28717b58b8c45922664ae5bfeafda7132848da2c51076afc95b7efb +size 973 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d87d9b8423232cc82638a45e5846be8709cabd2c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c4092923a2c39422200270d42b6e667dc12b9ad74c355e2bee6d327d1312f91 +size 781 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b1c754ee80b0c0cff778a38f1a1ac75a58671d0e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e31fc9569a5c9b5c41d84b3464a752bb9e084f75f551f37aa45d8b4ddb115590 +size 601 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..950d1a241a1efef5e622f038ab235bd7b569e354 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b6ad13ef4861ac3f32a9515a45070d9e4756dfb1d32ee2fa3aea6c9a7006f43 +size 973 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cd98a781b7faf0d6b68757537b32680ec5103b01 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7d1a23c2ff27ae1ea300e25f9f5873b736b7e9b6a9f587aca2c87e558728f8d +size 781 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..aa021fc0a496bbc0c931ab1fa79f012d545838e3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:66c2ee5a70dae7f8ba9acd68e7c44e7fa35e05ff36247abc27283a64ad233714 +size 546 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3c5f771274f244008f1a3f624d7ebbcf2901f4a1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e408d720feb472f84076f2a552fd4c7f476767b60e1128b21a1607e00df3ccc7 +size 733 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d850e81209bbbc5f5421d94f6e8ac6bfbccca690 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c7f991938036d018e9d27dc36afa8ad5e92d82f31d75c733c35549275022ef8 +size 525 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..dd4239fa090ed66fa808fccd7a9f048ade8b988b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed1ddb4594fbaf1242ea597fa5aa47f4bab10bac4b3172df8e331b392caef0d5 +size 737 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a602ab7de57f370188dad4663add07ef4b65744c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b2f97b0f64f9072a269f649f58ee247bce3eec5552f78b84402236ff1cdd34a +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..635c6a05db14dbe83d93f9bc89184e865c82a53c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61907fedef6ea80f04475e6ad507a71dfac8517b767d09cf80e4db2d7f0217e5 +size 301 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c0bacff326bfd5b8796c7cb1aee64a73b79bb5b7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7a067ef80bf9ad828224c1841869ecfa96ce56f1f9b6ac884b1c7a050a9978e2 +size 737 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..972e1e9cd4d474072a33795a2fad6b3f91bc88a2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c895e7ec7d22fd3d56c69f8299491e989da8c9ef5bddf1d5b5348deb957450d +size 877 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..df0f4d80a6e2d485255b679cd5b5cb40c5914b74 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fce395275b74ee506c0f73a6c8c8e10850ddf6241e330d7d8255440b894e21a5 +size 141 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..01f4ef26ec61759f2854d98b03d60bc421880a4f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d7a2643307ad773209a837bd20de6bb03e82d9f08d65459ab78abb90e5bdbd80 +size 1481 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f7a78f0642914732645c9cde51468935799d462e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e087f4b71a027f4d92c726fe4cab154a69dfc8f782c89525d2f94372385bff76 +size 1455 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ce761baf740391242dc26d6e3813ed20f7bca52f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8bba44bc357e6527b24b6ad4f7a61a14afca2ca18f32dba514b409c7b1113703 +size 271 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..fbeb60b38543b2f14d1cb4e9746f1ea5bad982b3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:809a11e78f1a126417ee4130f837a02f5f25e961bd3d98911b89b20066492cb0 +size 713 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b9de1156666e1ac5180f295bc2bbf690b70d957e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2053ec05ecba39974770157fc581757607aa4ee8f064f02e90f15b98977ec9a +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..04b7970deb14245f22e10659fbefe1737e9996d0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6555e6ecf6ab107be30f415170bc83c34b024ad8f0360f4bcf27c1d9814b6992 +size 879 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..63877f57c886504536b340f7f116aeddf3f9501b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:305efe8553722b1a5239808f3ad32a8f83cf2ee999bc4c8d2e928a747d1567c5 +size 713 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..bf646caae345b0a32987efe2047a31bfc5b2d408 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12416934f234b95f8f12d66aaf99c9e032f1864f782a2a7c28da731c42f452ae +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e706b351621fb0a2b7c363d4195ae7e11baa4061 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:528c5c02a23d1c73844452a46167f6ec6f41dbcf8c15a90102d200a18850881f +size 271 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1b26be46e416edae998f9582b521050c21d0967f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bfd202874c3886a639b27313c83f768131e15b583b550e96567610a0b49ad36a +size 1633 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6486373447a5cb4f1b7019d39f65c8f550b764a9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33f3d14bdb3aa33e44e51e211a34891bb3ad25d7c62d6196e39167fd4656618f +size 2575 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..edd584c97ea0ee62d01abb7ed2c4fe55148e9678 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9e93da49609ce30ff9c41138bb25c1d984711966bf8639b14dd382ae4de46fe1 +size 591 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..abcea49d7ef49d4e6371098359162e838ba19a55 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33e21992067ff81af56288b042fbadd941455dfb54145e54baa70d9e2aa7fd39 +size 1434 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a25a10681603c014111edaac5d27966754dd566 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fcc1d2a91d6b17f5d46e513fe076e322735f10ce35ee29de8b4e6ecb570f21e0 +size 1455 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4e1c467c9daf996034dd74c440e1d9472f2236a7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10b9d466ee93b9bdcdb7e49ba809ee67f6c5d7aeeda56aaac43f13136aec6b79 +size 271 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..220ba83b98c37d8241bbc295583ea12180ab2ed5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1196f59fa6d825c88795c64f033574f168bbab51dcc6f2570b2e5a3ce7f29d0e +size 713 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2009353dce4b3f2a9a835089d63afdf837d5d3d1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d29385285f62a97069578354a79e7588d6250a8783e43d7c5d18b971e9f5d07 +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a3da6fee730efe984d70d2688468b147cd28dfd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:401a6bb16f11ce656b0282d5334550f43d4338166a87d62696ea0db830253ca5 +size 271 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..4045279ae635e47a5e74872dc2e8e648d3b582f2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c33d6d095c325e667858235d912affc8c0876b4b5537187afcb98118fc8be2f +size 713 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..db58b80fbc5c262243af030abe37486c43ad2511 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4acc121a8c18908fdc7cfb24d60f61115b2eadeacdfc9da014927f68f8862b08 +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b7fa44164cacc95a1220e71b2299f139f1de338a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e68b433ba94ebbbd9ca0e7485d44ee3a414df92d3a764a6ca4c849ebde32b56 +size 879 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ada985df8e0540806bb484446da9fc74aed90652 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba26b02adad99f5aa585a2958df0fdecc783e70a563f8f8181fb205aa00702a1 +size 772 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2c0bebf450ec8ea29bfda77fdf969ae3e148d182 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d38576c232a6479be9297b240e0c97fbd10f6ec3da87f8faa673e0767e66e70c +size 517 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b3dd5629ab98d77fce642e9b040b3877713ea366 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dacc56b95f1562eb365f9d52856de44465d707f62049a3f8a456cf915c56beda +size 3853 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..94811f4d66105f36a2c90d0e79992e3d309d0997 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e29cc361f4ea0ce6e934a2d00e73683b849fe150b300b9219e3ea0fca31b6574 +size 725 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..24738049c379d46304d052aa5989878927703bd5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:703ada80743b852fb1b4dd5f308196c8c5c9d8d7ab6709ff2520fc08d6521802 +size 517 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b0ef72510778abad814385cc99e21848f70d82f1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:200d0bdabdb5e4eefac4cefad56fe29d6241215d9d2b84af29bea0ba3efa92dd +size 3853 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..190b08ccd45e9a51c6f4226ea380230adb678f6c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d927976b1d0c2339216bc1dadfd71cd9b40b5cc4cb214c008289ab1a1f716da2 +size 120 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4e7568bcd30b05c9f3d790a166f91dcda59687e7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:96ebd365539a8102806c18c1f7e1fb4c195810523652abb7153411313c9b9a99 +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5bf261381f11b2a2f1ef2d69f81eabbc920901e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de9dd7efe99168b2fdb2cb1cb1dafd987718dfe1e7f9bd1b6c027ae2a2a15b2a +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9715208d1501bb8fa00c32620a023f2c9e72c7c9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff4a3e2cffc38cfc1b056d03c5aa79069ae3ee37651e35f851f6e62a7e1d67d4 +size 188 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..86b10f76760aee04a3f4a85e8515e22dbf26fe1d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff4adcebe31cb6232f5b2f0ce8d49656c9b86d5c4b0032c58ce86c4eff3120cc +size 40 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..763f31de2406a7e1060e0beee2a371675f637c41 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8f583e01e392d647095d12fbd8ff141d9b2e685b765220a35175283432a76512 +size 58 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..09cb81a3dee9b33b47744b47743adcfe470f2294 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:179bd4f6f4d062aaee42795d277f1048c30b3ae2d02440df9b0cb65e50cede16 +size 188 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..86b10f76760aee04a3f4a85e8515e22dbf26fe1d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff4adcebe31cb6232f5b2f0ce8d49656c9b86d5c4b0032c58ce86c4eff3120cc +size 40 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..67b867488cdac777f595008525596e564b7b56c6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a685f01e2bcac20824b531da7b7e953394261bc76bc975f648eb4d01552cb2e3 +size 58 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..470a07af9c98c241e3854afad97df29da260562d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d09a105a897b5ebbde7a0473fda31780c22a8c941a83c125fab44b2b0476aef +size 156 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ea9cc928359ebf76cb581823feb6dbdbe9fc5d38 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4b7c06408c186f018dd09a2943e49808caa7224050ec46eac04e4e411501279d +size 128 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5c7dceaa1666c38b6f3b866204ca043cacc8a2b2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:285cdbdf161e15e03dc4798a94d848e805ed7d80b3f7d38df035731b5a228661 +size 68 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1c6484f396095c593a249c2a465d8e1711f8378a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5ebcb7132d4e866c31d0ebb82659dc0e86cd6c9552a24909d82c86e6a8fa0ec2 +size 155 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..207936e80833e9771e64c312a04306869767feab --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa06819703dc94eac1a11a4359a4502a8e3b310cd4ad7707128268f68a7dbe73 +size 851 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c83b67fb5178cb3cab803106bec4e153ade8ebae --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1041a6ce9d670bdd5038ca4edc15cfbac48ac18481a5aebae0b48e90ecc2247f +size 431 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..040602a984e4d887c34803d8d7a9c50fab634eef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:890a6d8a3ea0779d838a02bfc15664d4f3594a4805c20ccec74c3a89e3cb79e1 +size 126 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..584bf629b24a6c00d9300d91bf7a140abde9044b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:48aef0448f20fa8d66bd23630d2f6eb57b441bc01359733676bd5518e5b707b1 +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c589832d33ed84dade8f7e4134ca1f04d536bd2e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:abed185b01eda5dcfff4359a9fd21ba24855d69f6d8bbdcc3289e4149a49ef5d +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ae0dc5cbac8515f62bac38827552ba8b3f80109b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:34ce09526f79bd9bdd333013d85e43dbfab55f27e6b5c0aca1c445e887290be3 +size 126 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..adf526be2e89c58397ca002ceb1bbcf27fdabaab --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:763617c7449e8d37bd8b9c0715c284a3669bb38cdfa4c6dc44bb54c629024891 +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..12f2efe6266439600421fd1c63b800708a55e958 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:042bc3bf628343a8fe2ed916cf965c4acffa66037255806c4c4a58e6cfd2c584 +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..cc341c7efbdf93746b7dc935b97aa4c7587bea26 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:60a3546925d832686c788d3ea22732feaef5bc527e04691c32ec9f677c81f612 +size 585 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..fc060dc83ff19ad2bf1c52f88055d48a231f9d40 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11504362c0fa099cec3e80034c27aa1c99966ab493be7a92524b9c06a37c61e6 +size 169 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f5d536a7e957140caabf6d5272349f4f88378fa0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63631630f831239f084c258dbfd475a647d1f88e352402aa220773c6f4e3a314 +size 137 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e485330dc41211a1b74ec9f8566a08cceb6dfb75 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:071ce49b698635b090487697ece6d1822cd025d0902f4a39f9711bb9bd433e8e +size 492 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4b1be3c4c09968451464bd87109fa31fc1596786 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5d4d4fd48dc94b5da890bfcd5f72dda17f46b3322c3e90452bbd1e18ede7806 +size 169 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..eb63f24dfdad5e47125c5680eca678befdf76763 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:18ba13745d2637359625293b121d5d5037748c9b4661166ff75e45bbee30ad8b +size 137 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1d3bb1c738a2d8bccecd50ce724fddc01b96fc83 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ece1bf87cacddd80dff54ddf083671484d6c9dbc2b919138a83cad94e9cb9b47 +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..db0c65b2872e2779770d8dc407cd733f4ce5ff5f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:688bc46f385aeb3556a0e3320d09345f4f85ef271598e4d040f0cfcc22bf7dd3 +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f319d1dd5ab58b06ea34d090d3ee857a9dedad4b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91c2df10525d3a4e3a627247d8029f0fd6bd51ea0cdf94d928e2d9dc7d564dd5 +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1ee22256c16bffab6ce70d4eb25a330a88dccb0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:204b5c894d67495d151596eb21fe7927a95fa59ebfdd55cebe0c8f6dd4ad9ebe +size 160 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0aa585241ddde87572a360963ffdab52701d8578 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:346b8f9cab3a8087256e4b782112f5cfb5af6cf9bc0341aed9f5fe49a35578f1 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f538042c19e08377e62544aa97ef731b224a84ab --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:efdb220cd29ef3ae83d1f0a1f715a009ab7f225b71be6ee7f82fbc87a1cadaa6 +size 90 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1ee22256c16bffab6ce70d4eb25a330a88dccb0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:204b5c894d67495d151596eb21fe7927a95fa59ebfdd55cebe0c8f6dd4ad9ebe +size 160 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6b3979c7297edbf27f05267c9b01ee401dbe759d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:53a7e3d0a090e2c820183814b6ab0fafcd5bded86ec520df21802e20adead1a7 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..636b0b893d999f588775e85adaacdf8a7cf4ea08 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f65eaff0f88c328d9422c03d998a1972e4bb7b0c5db2ba9f6103f0a775c3900a +size 90 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..528a2d3d8b23a27a82963f19ccc96266658dfb93 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e55328f92cc0ad554cc9bda789196d71901e7bee980457860871ccdd18f3556 +size 165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..590979a501f7943c3d1cc63e7ff6191caa65e3c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e2a26f50e594a377fdd68f0975d39311133a3137288662ab212c849de7c87a23 +size 880014 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a76007056d497edeaffd7cc34cf6bc80fb0d330 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4e831f4939253f7beda74b90d9a5a6ae245f4da5405c0e337d3936325658002 +size 87298 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..92086ee58d142b17e6115d5d423a0b64ccc572fe --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eaac34265d1d2597205177609276ec2973c4b5bc483c1c414a6b9653b4d60660 +size 176 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8777cab21460764145515981e46d147677611010 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b3e2276af48d653ea007a533aeb0843f85f4de66f704c34a57c1d9c589bba68 +size 601 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..09c1d300854363e22982b0245ad69a60c6b525e3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e4aeab61341803bd821a566fdbbfa836768f2fbecfb400c6ec2822f17fb0c98 +size 205 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..79aec42e088a6c1a4adca001b40726856ada5ef8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:07d74ed26c95a5990f39335113f29258d199d1adb300ba8fa112292048c15a0f +size 180 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a9e215b4219a1b0ca108a9d9aebe56f1a948a7fe --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:28444dcd7d1d3a1d9d6564dfd1d561ddfb6e6abd0dd5a4d81fd917252b888df5 +size 4000017 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ca8ea6f4ecce464ae14fe84cd41e1396f929b145 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa681dc60c527639be817a75ebf586fdb1909fa536f5745998bccd37cb258e2b +size 4313 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..95175072891413c0c9d7d811089d3102d17a07ef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:124548c54d86bddfb4dce2ef87343074ff60338f0895ad78a4d9acc921e54c9f +size 192 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a61138a3193311c4594f6f45f2720e3306446322 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:749e4d5145052c80652a003c088c6cd94d427537a515033a19a39572375f5c7f +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3b3c6165a8812a7be55b6cf8cb3381292a3bf463 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3314986cae66c39f04c2e733ea89a691549cc4b05b6921f18672286986c8a2f1 +size 207 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..95175072891413c0c9d7d811089d3102d17a07ef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:124548c54d86bddfb4dce2ef87343074ff60338f0895ad78a4d9acc921e54c9f +size 192 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2fbe7614fecd78d93369305ec8cde8cfc51e04ba --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3167f333970b64ada34b7c10cc0e394d1d1f3b7117822b868dea32824af7e27 +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a613046a791b4727539b0e14ad2aa3e02ed94ea1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e47af8693e16b69e55ce86963353a6cf86288d862c566c3749cf9621e964f8e +size 207 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9cc48230a8a3759bd9a82f8806ea1adfffc3a8a9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63ed68a3e9628f4ea8a587ca130bbae437bf13fc27d7f335d2cc91c990fe3ab5 +size 192 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7939339253985cd3c55fb9a1ce0b361fbf522905 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc5662f7cf66ba3e37036da9f3ae0dd32d937ae2c88ab1754045a97a8d20d1c4 +size 3015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8d91969e52d3b272a846f1e93f07f37d356ea6ca --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41633821dca76774de04458996b59c9a22ee47317cf86503b088d4f1145a7913 +size 663 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..2f954dca227e754438864cfbfea354abe7b6ebd6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e268ef13688982483bcd14d2d18d0cc268b7adbc43ccf3405c5ea5c36916d010 +size 140 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..33f33ddf95ef9c5fa6d24b47b213bc25511e00ad --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7700a3e5d3a8d176f42d6a0511ad363178cd08129e93531bee9f65a2a9fea816 +size 106 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..282a523078136b47238e164455bd400339583e38 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:59555fc3b94de1b50ef7596326e382ac5d1a02c01578eed5c4c58b2423cf7f6e +size 106 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ad19f8c1b1847e042882c1cd0eb423fd83c2d798 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:22f63cb6948493484995b46db7927f233ad0b080eb6d8bc67519878ff9008328 +size 148 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c8e3bd0525cb50ad21a70c48b75a8a08325d755a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a94825136b7d4e5186d8f38308daf297de886423094679f6b3690528fb6276e8 +size 106 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e2065cd67cadb0d66117aa1d7c9f402fc1450c84 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:913c1d0ee63425ac255c3b50c8a6daf1a95ff3b3cebcb5be1f4b2f722259211b +size 106 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..874a3181a257a09d58ad0c792f12dc2ac8890329 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c2df9a380dd056908b0e54e9acbbfee504d7282f71a85a0017dd06ea6fc3d4bb +size 148 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c2188da5d33a18d8f57f5803465ec79d9a7b6f33 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0f59244e7311babd88052926097b2138c5c1337d53ae9de072c0671cba31c0f6 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..013c555122d8cef0b94d30de2d2a089ced3658a3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1bf0e9e8fba2136db930362524a9da8de89894c0b0593c26ff712f1633b37eda +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1bd17587ef855109f8436bdb8a37c845cf6aa225 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92e920bed8f828c5116321ba6717996fbb8f901972a257cf0920c8d8ef7d264f +size 157 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c9fae5c4c0ad181ddc071216db87c85986b26a27 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3552b9cf7041fbb7cccd2a440157bd289f3fb235bafe8b5e43e945b34ed83260 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a42f418000e77925370a649a60d1d9e74ce4e68a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e523e4454fe79323d2a966b01cffece48e6716719771e6bb8baae2841fef5876 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bcf37ddc75a59636851e2f80bac1204f3184924a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56f66df2d06fae1d6fb9a5d871adc3c5e54e0cec69b33d88692456b4f821fe34 +size 157 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..fc3a2381a0dc0e6fedb894e5cf02f0675f79ce75 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9233487531057dbd7aa0c47fdb58271f4fb1d72b9f436d2bd09270b44b7ee27a +size 2895 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..dd029aba7a3f59f9835a7e08db7d1ab2547e0e1e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:93a57c84d6941172a76425132a5c827000db3ddc99c1a6eef7b0f8ab3c94eb71 +size 2895 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..7a4397ca6310de0b557884151ee886f1361f93c8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e88e381630d135d3a09aec1d79ec2dccd6506db4d8b8fb39d02c724b6d510c85 +size 165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..552cbd9a43aa199afbfbbf5388ba32df52eb6574 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ec22db847811f6385febe7d2c7da155433e4c81dea549c91a90555b2333c4e70 +size 2895 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..44737e4623ea335086d708e1a5828d7271b4aa01 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6faa503f34b7f5bae1833fc7919b10688535aef4593fe38d825dfa9f6bc688a0 +size 2895 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..54783b740bedebc98bfb0ad916f85c05290f47d4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0912a957ccd84ac2a9e268b08e592152b9e59fb8e9fb55b6852abe362881ca0 +size 331 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d49e23035d390c2623098c8448cf4dbbd3f423e7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:039efa92fb46bb159c808f3bd96e7e73cf463015758904edafa673b2285f25fe +size 589 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9e080deb7361d56344cdaf918753c7a28cd21e42 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e9b075273812c8a180fb7992b6576430aba85a0cd550235fe98388c9679666f +size 589 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..08bbc88d168f87c3e6de44c20162c4c9447b255e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b425a3f9ae177a598eef2d9228a86604acad45af60cd61f4e0beb8071a180463 +size 569 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b9f34887906fc2a439b5a92c4acfdd1bd418f3d6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:50a343bc36cc0031cceb7205f2dc06f50203ea94c9dc276c77701acf309eb2f9 +size 409 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8f98f2b2d7eb247d212f4893e627331b5fbd8b72 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b6832c53d1883d5318679b2b0513d973ac64ffe85e19cb0224f4de6cc64880b +size 409 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..37c026d529f212fac16aab8bbc0333c0afd106f3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e786d816f737440d4b8ec7faf2b156a686b3c88d1ba3fe15f273b316791114a6 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f444d87b5d260a95e8b973e48f1ae7669953973e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:132da94694a056f661029fdf5dd24b215022764a6287fed74cc6acd9a53fc776 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1dce3e12363d55254cfef4b853e39a4791301b96 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a752e31026e3dc21edcdcddd22bd396c1ac3fc678bcd639dd31355b2d020fa92 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..06b152a68146e68d625418693e0835d0445a6f44 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad18f5806ab0b52956775e04e63a53b7c8b881747e82c1e4b4e147d9579c9696 +size 159 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..49f2282aeb5adfe4c674631d971414c109c2144f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:19dac24e73ebf6545563f5cf44378c0e0efa6d60cac5cce66cba6b6e1173f350 +size 1549 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..848dcff82a63f83fb17097d07ecc4aa2d8d458f4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:308b4a7a7af1b1f7a7d10a9b025dcf231f4c4e1d97f14b15b3355a6266d318d6 +size 3973 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bfccabf8f0b319823230cf1d2d842d0916029fe9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:896ae776de6beb2f711fdb4959547fb2bbd6777a87448f98cdf30b80721eff1e +size 156 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d733ab197a0182c9dd36a9c5a3e184e873b0d492 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aefa6b08007cee626acb97362b8edd5cacfa95788083a564d0f09234821ff1f8 +size 397 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2b743aa970fb676e1fd2315213c58e532177cf2f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0a91b296da1b4a9f23e4f89327510b0de91dd01bcfdd81bd54b681df889b29db +size 1861 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e7de91ac29cf5d9d7c5d3a0b235dc550d5be5b35 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91b617d81ad8bd304d82a67f14d371e667a2397c82bbdfbbb45950bf3bf651f4 +size 104 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6dba94f03864e9b8d6acc14900874201e0c54fe4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7b32d5dd4969a4f2b577efe825fa679abcc005acd9352355358d1b519df42fe +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..637b29a8cc4a88e4057d7d5f9e1d55a1ed04e3ce --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd4be99621f7969b8b771c507132e6e3b38ec6e167912944946ce971b6dc4e59 +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e0c35c6eb0da9b01597f0b22c9475a3e08b800e4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:afe8d7bd3bb6381d6ea07484737c1e5017e2a56fa3f9ba261c44e888b4677598 +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..79355fa0a59f521e876460dde05af74ceb602882 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c46aa18a89508f501717f27d0c8e91b217251dd913b6f51f8c0f5435ea07df88 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f95e10fd7195e68e0dd1edbf2a9418b8362d53cd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fdab9df3faa0cbc9b22a8b72e36a2e0c6bdcf0ba81f4fd30ce2335593f5476fd +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..3b4882343cd681c919c53f351d227706adf9756f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33c614f8f96bf15a31fb1be0db2b48f5dbceb554667eb140d5616daabcf546b4 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..63be0faf515b0777b4edb5d032e276932594b23e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:31cd93d802919466cc9fd2612900aabdd36130e778cafe9ea22cd1238ad0dc4b +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cc69d1ac8ea72ec312ff8c6a1e1a95647632b588 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:70405c37203e50eecfbc93f4e413453e0df83b46fdc6e236a081f41ee8db2420 +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..f26b1dc6f95640c4ae070dedc1deb615ee650bd3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e4cdc2d57f499598a955d50ecb691cf6ae8a9955458e4a1a8b03417b092deac +size 125 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a3f726d3991179e30a142873071114718e01fb9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e84be45e0b0cd6a7aacb8c57beb3668f31604087d48352c00ef2ae8eb921bad1 +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..fadff17f453c108449b31e9bab8ad4f71617d2a2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:74cd19ceebb00658c2602979830b73e9dca5ef16f03ead3a3922696d9cf7ae5d +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..06770688b9f7d7ac74c2b4aff58d9c7961023bc2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d6edeab57c386acd351ca6b78533c316d4ff925cc53a47ffba4eb2346d279e6 +size 100 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..bf4e5e3ce77301eee148ef3ea2a92bd19b3f5c81 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:447096bdb649da9b8972c92b932a7e50eed52578096dbb5f9e0bf9d26f9706b4 +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1037d1cdb15bcefb61693c47ecd66a25cb0d0e8b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4fcdc154264dce020c25e3bf2a39cb1429777ef3baa48dacc0c9fb01c1efdb3e +size 809 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bf7b06f7f6098f49909e56b34509003f6d5f28cd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:efb02fe36f0865ac12df5e609eb1709d0a319b34b173ccb2be31af6e9720f08e +size 191 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6bb2a4506d1b6bdc8bc8167e6addd9f269266aff --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a047ba2fd2937900154cafa04270dc203b92c8336903dda642f1c6a4a4af895 +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e628874cf7598f5affe8c888d7bc643ac93d4bf2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:760b176c53929f4298b5b55efc6e1d27ef98c2d286639d26e4bda1732f3c9602 +size 130 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..2362279e85daa7f86266b94110ac03a45393ccea --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:83b4446d8a440d02a4f87144513aff79dad3a842733fba7a538d6a03245ef698 +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..661216331e2853a2df3695ad3630d514d6a5d6d2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:87ec984ba2ef678c9d00cfbdf73202a3a55e413eced7cee59070dacf12289fbf +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a73d641c5b2886c911a31c445da15067ae54eef6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:185a818f8306ecf022ba3c4c47abb3713a90183f18ba6c05ef94b3aafbac49da +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1ddf94f6832a10e2847a970dcd15b8ed2e49f3ac --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a28c21f42f5ddf77e5dfa53a30faf3cb8eec7362ba6aa5ec029a271afe6e112 +size 177 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..30c5b6f2178f19cdfb8e82adfe6080e78a67eab6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6b6c64a4b1818021e42b7e82879cfd98c40cc1a7a8e3a8184adffde50ed5894b +size 397 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c91b069d7344989429ef90c84f3b40f4baa6f623 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9a1aad510e25c9a08f34e47005b46d2bc9391b399e8abf38dea0d517f1956e1 +size 1861 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..188e77b60133af62b8a876fde6ced8fa54060b7a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8956b4c1ef7789f5d2a7525aa55463f079baf262e95971764103a68dc059f6bd +size 131 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..352bf93be84565198861ff81def2456714953d4a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cfda7a4dce021837dc31ebcc6f7588e91f672952d2ae676c3e7c02cc1fd8473d +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..98ebebd52d3c9e4c7f6a3f9cda2a015235d71e19 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e4d5d36fdf64fde6c3659f1076f36dd996d58484441fd738e78837ea16571dc6 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ba6c46d047357c8a8163d4e40a8c079e563b5b6c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9bd6ce0cee451394b4e1a85261ae9b3f1c4103186311c260dcbe0dcb70c93bc +size 126 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..29aee34b1fa9b4b1f27520a734530b81402ec25f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bcce89e5c9b6619441e2d099c2e3d6b40e08b45f28e07825862efc8b248382c6 +size 1034 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..abe9ffb9079ce1d128cebe78a63e29f3086045b4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c2a84582dd41fa5b70157866a88543cd53c049d10868fc2db9f61e9695437d5 +size 1034 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..457825ede64559043d374d98b786f7246c4f5213 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:716f35416a512cbe2059b6262b3a3872b35f48fde8e64bfb479f579f53533ad6 +size 128 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..540e8a8d2da555f7133acecc11d78bd237c2d538 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d53ed2da67c0dd5c93c3f52eff14752993a493a7d1f201f595186a7bbee408a7 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9237f982ea91f2e15b861d46d09b31aa7aad519b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b7ad7133004927055c8f23bb99f5bff7aae2537d47d046586b1c93c3ceb23a5 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..2f92ab8cd63ec100d177c368c95f154bfbe122fd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:016597f084a51e47e37c126bfbc70e3c2548569943ad943cd66061d5883fdc44 +size 114 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..12455e3818e3319c9ef75b794e189ee97b8bc485 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:208fdce8d77c1d6e90d92f306fdf6337afffa138e43aad0b56b7ed03dd8ad097 +size 1034 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a370794472f683ce8c0edfbe80595d20211ff8bd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2fc64e1eda6470d3fe97ea75ec17265932ba6540c0180e8eb60a52c23170c5f6 +size 1034 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..91e1448600c0d053192a7b70c165e61a8df6c096 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e32a28e969e4ba81388720c78b9caade5df1b3bdcf3dd1890439fcb6c0ad6e68 +size 146 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..bad6fe24b10445b62f29e13f42466ac0d74cad77 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:59e2931766b480b4a015213b44fbbbb2e0bc05a90b239270c512207180513291 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..5dddd2281d603b9ab5de5e0151fbb69e65559537 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1a527a60ef96fa797a5bc467ecd880dd5401ca79c3730d021d4d0aeb48403f14 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6778b2a3379c3ee588ed47ed856edb4904e70916 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc058fb1e2a988b860e716cbbf86eb0fae8f1ae8d50a8c0058fcb9c477fb30db +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..2e887cdd7c8a78489614e6b496fa7daf4b0323b3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:43fdd40bdc58814f99d45083aa8c1782d4181394c533776ffe7bf0e67016dc63 +size 151 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5df9e2264b43c460d8cbb8d2df3dbd219367b423 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7416634ba7f4619abe3c09aeb5fd8a57273921cf2591b6917aa02374b288bfd8 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..d30fb08bb24f16de956843d677850823e179357b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:266de418b18c2df08b763b6589dcedad152d55ccf81da1ca6296688edec56c7a +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9122ac0202473e7ff807e08151c7ad73596739fe --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6ee170f791f30828f693312cc85c4ee956ced35fa57bbb93aa48b76229de021f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..91e1448600c0d053192a7b70c165e61a8df6c096 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e32a28e969e4ba81388720c78b9caade5df1b3bdcf3dd1890439fcb6c0ad6e68 +size 146 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..464a64b66f3e99e333dd99e10053f7fb44a2b37a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b5c895101ac1b6b962895fd3d44559481d523518b6cac2af282d69b7bfd9440 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..8b13b4c6ef8af8e844fe51175684f97ef3a0b6a2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:987fdd6549bd2b74748e0be3a9db16bdedaa20e9a1e46bbca9542f780d224322 +size 30 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c90c6ba3957b5b0d265127c490b3dc146bd90e75 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:29a0c88ed17c7494ea566c5b9bb6e5f9e36219933edf3e0da9d857f0c157ea68 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..716152d09462b770353a92370abb629dcd8dffef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b4bba28c4211265077b668c2ad11dd4b3fc4617583c4e36657d21e14d735374 +size 151 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9e290b343d66e409a1c96dc97c3a72d315cbc61c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1e0c7d043be3cc02aff6e7a5e5ad53a8f813fd48270e67f4582edff1ddd00db2 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..910d35966bc40f5d3ff41033e90478b4193abfe8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0ef595df5829db9e0a9c19389bde46c1d72f2c8f1eec62343c81d5ec56f86a44 +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..652e0a823071d9209577ab4de83c1adaaeb59ea6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e84618a16650ab9be91650b9ba3d9b8cd42cd3ce14f9fc8025d6f9ccb8a98597 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..6e2b494bdde5ac3975d3280543aa22899d2545e9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c6b202f12d5c44e81f989d3e5d4e281f80efb455406e0e437168b1d0229cc83 +size 158 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..52b9af9ab38845da3696d36e6758638514f49fa2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69e02108c80938d21289814b113306c289669c4594be207ed2bd39c780e3fd01 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cb4685fbf32128ce4041ae8e32d2c59834126034 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dea4b3411238113bccb144d75350bdd5a52aa885afcf6d7588f711105d6334be +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..084afde18d6a1659db8bb0c21da2fe05db495610 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a645ec71f16a780ebdb6ec3eb3ee47d79628f0ce7f6bbfafc1fa14175136923c +size 245 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5b97a8c02c998130588bd88c7f8341f32f2df552 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17c1c8c6e32f2f3758a8d054d563a14aef4135bf5ff2c136361e0b49c8e40afe +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..025406d6e8df1eed661503a07240a91a2ea81891 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c117964fb86ed70be9cd56ddcb8390dd12c79881a5796b9d8d7b4dcd0c4ddf3f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..6f56fee09b1cd5d7d3ab42d913e35f2fb3a9e167 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8923ded003eacab08169bdc97d04efb9758ac585b58eadf030cd2775a5477a94 +size 22 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6ec50c952ea3c123d6eb1a71770fd7692924abc5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d90d0df5bfc55fafc4962d34ec902bd330eedc558228b9a24eda89a89249e806 +size 40 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..5eeed2e677b85add38d8969ced41b26149cb115e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8fc4a80060eb7faf3ed13cb6cc1f42b826d5a513f4580de0d5e60fcaac30b619 +size 168 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8686b32153fb0dcd47696f899f0c818b27493b7e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:66cb29e392752d93ef4ba8c0ce514ec8b139f91eabe226fabb4946c1d82bae5b +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..a163309cd16447e997e6df11389a759282dbbb93 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a21f96395a4dd2d6754cdb726ce7bd0ff82191e3c7d0ac84369d43434f2d54e +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9e244860a4a990f355861478ac5cc194cf93cfd9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64541217698e5e14a5a4b5774a25e9953071e298418d177addb84872f4b4b1c8 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8ff12a6230ea03a5f8be090a4d4e07e451ab6ea7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3efe57ac9ab9c8322733b62c35b61217175b640c564fcb386b5c8ae6e5fa956c +size 138 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5603f1524c18cfed0bae4f148f8b7c31e8d4920b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e144240bd9b2d4c651ef24be8315312e11e80cf71947138a56f3cb3a617a2366 +size 18 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..3fb5c7fed7954534ded7401b770606eafeec5f1c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bdc4fa56de648e23d09ffb95337d3ebd1aac299bdbd041ed487400f997def1d5 +size 14 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..76d076f955c240176257636b2fb8d87c19244a6c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:452735224a917452cc0660c443b273982eb681306689a9df27effd974e5ebf71 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..adba92e2c561a96a139cc3747611bc97ae219bc4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:778fc5195b9d5db7f9e9885194a2a8efbe3d5edb55ac8a874ed1e78a19adc06b +size 126 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5319a675cc614adf964cc1ff2c2dc7c51349998 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:944e1a296dddb9b6c0941e2b70351c96d5972084abe077803752d69e3706970f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4ce7f0573dcda36ae8f2f1f867b51d833dca0fdd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e1a92a67c157f8728da953f66a7a384018a3b59b60d572ab5c15f61cb9036182 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..7f3cf1aaf21912bc69462c4600ea24c661c743c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd04dc7208cbcbd10f5fd505f895674ef906676431ccef960900957ac823e46c +size 135 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5b97a8c02c998130588bd88c7f8341f32f2df552 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17c1c8c6e32f2f3758a8d054d563a14aef4135bf5ff2c136361e0b49c8e40afe +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..209062c26aec5da257ae2442fe1396f06a69472e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c76b841a3f25cbc02eeaf38d07975bdc1d991ec7f395eea57235af701b2b9bad +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..edb693129301c6dd4c2c01401091758a14145232 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6a600c30de787f3909fd9789081bdfe75c70aca9e81ece22d1f334891d7aca96 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1196a966d7bd5cecd414e1dae10b3b27afc82df0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8686672d9ed2b539b5c9a670d93ce007c569314f6d74e33b4b10118a3f33d656 +size 7746 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d60009db6f493f99ae5f9ffd9625e9e26a2b7fbd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52f2215b35016c85c17a5ad4d471c71ebedbf49140a881af0f7f80f023ebeb70 +size 2560015 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4649f17a8f1d08f24c9bd78dad8d31fc808a1bef --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fb558f63a7fb8e9193c98103f279861c389d171edeab5e0d4d82a5926824d5ea +size 1896974 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c481bedc29c3cff138a2575c372be2ad6587547d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57fd5707733f1e7473322d19963781d318f42c8cef22041c30b93d04e4ace86e +size 617 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b895c0fd1d091a7216a4cbe7ad82e76d1bd6e8ba --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4457fa4f9c95d9c71d11e0c4a4a397d5091ae99c34253e44dc0e3972dd332517 +size 493 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..54ea5ef434898396a7179e29984c3ff7c71569f6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddeaf41fe4dbafbe9821c4d3ef49b081b738f1bf50a0cc5324a4c98207b9bae3 +size 4333 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b856d52e50112cf4665a56aa57e3780e93b1ccdf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:60b5c2af9b0856877d830ecb3b440325bb96fbac1958e2e0ae2a5b0940a770a5 +size 95 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5319a675cc614adf964cc1ff2c2dc7c51349998 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:944e1a296dddb9b6c0941e2b70351c96d5972084abe077803752d69e3706970f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f1980b88d464cdf17babf9f068943e728f8a72a3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10dd6c7aeb8cff55012458d7a33eb1957d4505ea5ff0dd01e66ec14e458cf155 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0ec7a4895d9b2a3d2782d8a59f8f370ecd575720 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ebaea8a9d56651b8ba0454f29dad1e1e4725ae8a54549b6abfa13cf93aa39ad0 +size 120 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6e19184370981214007c6fa14604ed47496d674f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c14b75588dbe28a94c3a0802f704b9f6f645f05fd138009d237b3b826a2dc3f5 +size 104 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..456f5b9dfdc5a6f83dbafdea12aa484e15de3276 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:275b72eadf19cf0c94848cfc478ce673ad2b4aa51ad3f264b7ed1358b96e2a6f +size 165 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..45a94b35c9ec6bc5579fcd35a87bbd6d8b3ab638 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:872e582cf3d9df93eedcfa10415a86b3116912f38e7137b5dbbb540a239ffb24 +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..60cd32bc685a60421e8e6f0efa54f2bba1edfdff --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dba4178c03e74ec137429a898dc3fe3e4485551fbc8a66133e4430cbda9d1293 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..daa1cd9bc0aeb5c1e4801f69d959e9d0493c8552 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4499da62783819a04e944de2a37b071ce0b13901f0448fc526406f5db6715687 +size 119 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5319a675cc614adf964cc1ff2c2dc7c51349998 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:944e1a296dddb9b6c0941e2b70351c96d5972084abe077803752d69e3706970f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..1b86459025188256d506e4c40844b55ef9c2aa22 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1f8008ba09ff2b9fabdfb05edbf198a5a9488bb6c9fe82b8844765338641a98 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..36f5537e1131869de37b4e2000ef0c872ad25a9c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a62cba1b93cf0b7aa55ebfb457acc71b4cef800ae5b51df4b4f5464bd955ada3 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..dee4d4d8e9f84683015b41c0cbf12f487b90d709 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7baffdd5ed1be0431dce6456181e4936d28719177288b5dd4ff741f187e1628 +size 160 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cd868192c2889a0855d865a6152af2675562c63e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69afe403394b677ae6dc29d19bd3fb06164a3391c550900a65672926a8d32a16 +size 64012 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..86f7f041b473a54db0c5756feec3d52e12219a7c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a0bb0864762a1813781eee67b5346088f3540f875a588e6c792dda89d3575ae +size 30732 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1b2e1402d5daafb2a3d306acc91691a15046fb3b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3ebc29a395593453c5a039e44a64435f33067ad3e1fd6070138b40e98c93132f +size 119 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5319a675cc614adf964cc1ff2c2dc7c51349998 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:944e1a296dddb9b6c0941e2b70351c96d5972084abe077803752d69e3706970f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..1b86459025188256d506e4c40844b55ef9c2aa22 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1f8008ba09ff2b9fabdfb05edbf198a5a9488bb6c9fe82b8844765338641a98 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c595a8b588c6fb1a109f9944f3b7a4742dc851b6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9273b65cbda18dee810af9e30bb28c0060b834d993b0a1ddb7ef768d2f48e5cc +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e20d6714100844f4ab6a9c6bef66fa5faf57444c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd53be4a44cdf737123b37620cfec0ed4c47e8d5042cf727bdeb10d83706fdb8 +size 214 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..5b97a8c02c998130588bd88c7f8341f32f2df552 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17c1c8c6e32f2f3758a8d054d563a14aef4135bf5ff2c136361e0b49c8e40afe +size 32 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..025406d6e8df1eed661503a07240a91a2ea81891 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c117964fb86ed70be9cd56ddcb8390dd12c79881a5796b9d8d7b4dcd0c4ddf3f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5af018c3c78b82bbc7939e2f5eabe04c6250619 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea9959b921bc5c15c8671f3af66a38088b7fbe4d7f61a99fb0a35ea820b187bb +size 40 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..dd19453546fd86e01b8498c47239c8049acdbbc2 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:485c66a0c1b5abdf83d03a351f0761e86b9aa44e821787d4bc5145ccbfda5465 +size 181 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..44ac8cd01b5629289b452fb192118c047fe8d976 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2bbd2dc2044046f51d689985796e81fb9a7e5cf78e9d223b5078a4302a86a39c +size 40 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f200c714beafaf9f23f5cf5fc1fa8cc58e3d5972 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:83fab6fd56acbb4a476a49755e4a9e1aa6779b15e2ca483eb435aac7cfd5433d +size 40 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..94059172d5cd70da22b43923eeefc7c181febfa4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8176991317b9ac1f5e9ee1a18a89231102086b8f74a44a051602b1a0e1294aa0 +size 159 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f208ca6d59f979646b2310f92c404636d89f53d3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0f9f2fab2c3f55cc6d50af5534ddf730ab2bd41cc81326fd4308cc36b88384a +size 44 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..cc245536a07c50d3d78a2e5d48f50b33c1b17f2e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e49eb16e63c84f9dbb5422e9ed58042fa28f20c10a2a4ad2bedc17387d965a6a +size 120 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..5f2c44c7587aa717916504e0b920329d47d1db29 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4618f50b075490691d11a75161905d979de1b3e12f20f892255039993cb4e0eb +size 209 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..68eaacef9ba89b958006899bba09af456f6281fc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9e839fc56e801da9b602fddfe6b9c65f1fffa28da6ab3721d38d9fa580d2b952 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..418789b6eceb218badd7cc411875bfce183b0b38 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b56a8748b6ca45a8a4550531a8e494218b1ca8dca85dd8a288c769c98a30947c +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..90f060074568233a028c48f26ed7a7393d9aa662 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0aac91f4e4b02c2fefcbefbc18ebbad361c2a5ecee02dd80bba13bcf107ad35 +size 157 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..76b2d1906a6d0fa34ca0213cb264a1bcc3f92083 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ff34379c6ece81e777fd0c7de45516f9260ef7de66f3cf5a8b262e9ac905123 +size 20 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..76b2d1906a6d0fa34ca0213cb264a1bcc3f92083 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ff34379c6ece81e777fd0c7de45516f9260ef7de66f3cf5a8b262e9ac905123 +size 20 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..ff046e07c320afcfe1e4cd48c46de668c71713c8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33b5cd9141807d9e44da79058d65bfed25ef2bd5076f725270e6828b1f10bb21 +size 143 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..4e1aa81748ce990f96ca93d89e2f230a37bb2c32 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d0b7e8ef88dce493e1bdbe5a310e53860b2f0a4825bb53adcd4c1c209ecfc3f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c5ec3cfdfcdffa731e5dbb26a247fa6ae0cac7d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c437b01b140337678ffc22d8dc9261750cebe621a4333c72d15ae9e40444843 +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9e460748aea0701925bd6f02d160d866d1d5fd6c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b520425abc7a0320ff2475963531e99f2dfbc469b3d2db5a19e70a07a945a40 +size 144 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d2786167e8e7f7f98a7d1443fb45bb1a8b6dc9d6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0646eb204fa965a7d2f8c516abdd6b31d77e6591185e1dd93fc8b8ea3f3e99e +size 42 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8f28725fffab4624a1ca8a73cbefcbd24f28db53 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f1a714899ff20760af3a6844d95f8b30fbca0b7e577d2fbf07e8ca3ededddefa +size 148 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ab12b106e4cda2092f9a9ed9d29bf685a1300889 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:253e3914a2fb7d0a7dde749c38b347e57573a5ee7f2d2774244468124f996e14 +size 44 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..4018e011c59c49c06c4172463e6a5517c7cd5922 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d494ea7d31091b05d409799923d5a82df8db56e9c290b536ad283f0e53fa7df +size 143 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..a6bf999053103559e6027566ac765ed93fb1be16 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52d9678b6f1f5f705759d5570dcb8bb7472efee9601e3a7fae0babdff950cb36 +size 42 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e40da729e542a416e414df4532acd8fa25fac4e3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2fadbf7176846be0b2930f0b54ced7bc668a45b21dac12b889a9935b187c3818 +size 147 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6ad3314834c407bbf8256f89d1ab16c4ec4ee8b1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e4cbd3a0c1b05baa454e208bb8524fc7191f61b14083dfa4c0579ab98c383217 +size 44 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b7f71e4dc0d93326e2b205af367a4313eca20f06 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45024e66e34011dc16e8f942925c4a94686d676da617c902a68bbc1402255b25 +size 183 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d92347cc0c5b3c9aacb407ac8326044254caf753 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9894e282d63106e64582f3a3b0ce39d628595ace004650f6ebcf8c2e3863597 +size 2317 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..29f04edaa11ab47c993ccd9d237a3f2bea1f6c7e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:988af83b725e7dfdc78cd70b3ed46074da3cb2acb78a3fc4991c2d934fbf2e29 +size 262 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ea35ea3a9b3dbf33f46552dba9ab490ce1a781f3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3de7968d997ab3ad7841ac292a54f369ad8cfea0ca92e3bc0416b3faa7e4f2cb +size 16 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..357658d364f4468d78fdb24f9f1622e0d161cc52 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7dca7d969fdad14155aa62508cebabb3ae64dc8111c7e6eb367c9044423100df +size 205 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..cb0b674b354f88fa42923691dd0f22baba511e65 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de6a8a5c3b792b00480f9a35d470ed332a082ed591d78ffda0f1ad38dc83b9ac +size 112 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..62563c46e546efed55746645afafc2a0bd75d0f7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bc3e62692125d1db6c9003ffc87c131af57d753699bc19ff0f0366b2662045f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..827deada870fb735f206ef0ec9ed5f2634c14ba7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:81dffb4efb1f2bac33245d5cb56728500afbfc40228bc780af5030d3ca80ad4f +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0a4a32c3846b33aa674de0c473965e152d3d0cfb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73e9a3f0a7f0bd21baca809908bd515953c2e1812c16af66f47ed4439fd879cf +size 96 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d5319a675cc614adf964cc1ff2c2dc7c51349998 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:944e1a296dddb9b6c0941e2b70351c96d5972084abe077803752d69e3706970f +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9ff7678877f03fc96b9b1a413ea8a2fc51990704 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7761216d6701e85081eb26a93b78e31c03bcdae4d695f7bba8af7db9f7187a2 +size 56 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..463328928325eca38a4bd8b4c9f55dd60fb7b603 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4dcba4239490d9808912d8dbe82fbd4b54e983ddc145656199425c2ef406c819 +size 291 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c9697345162bc101f56d4c61ebb6c1266fde0f0d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7b56f70c52f4016af37eb818083d99fed9aa506ceacf55c47ef2c6ca75e293c4 +size 81934 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b169a94d55178adfd75d331f857e2f30cbe7ccb8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6eac75cf668adad2964c7c94dcedc4167fbed2a78282abe4c1f6649b5f42d564 +size 81934 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..066b587d6d3b3859ae434b6c630f8a7d256897fd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6391e658fd3db2a43c0fceca282b8dcda7030054d7bd3f5ddaaad3d5442a085b +size 188 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..ccfa1510698e1263f2dcdcf2a3ccf80ff4fdacb4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:83817f048d5d2fd670eca44d6bcda1eeaadcda286b68fce894432b6922373eae +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..76d076f955c240176257636b2fb8d87c19244a6c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:452735224a917452cc0660c443b273982eb681306689a9df27effd974e5ebf71 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..9bf70d1f497256a66ad77c3d89a1d9d800a9ff17 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:166431a361ddfddda5930282813b9b1d1ef87c81aa4837abc94adef19cf65db0 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..4fd17120be750faa2789183904138d927d1ac392 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddddac1752917511df0a6473fe013a69e5b7537157763e9ae62259d7a19ba8f1 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..0beada33227dfa5621342eac834ce9f2041b6f3f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dbb0d646caa7bd9abd9bfddd072f9a3b0fd6175e97074c10466413837605b2a7 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..0d557463d4196e4804f6fb86921df141c945c28a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:62099674f5d96ff6a75cd79ab1b036019e6fa5de6d281003c6c3aec12064e963 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d87d8e2d7d9f27de1d1ffee4ce784f3a9975b67d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d3ed32ba38fbfaabb3b76f7f3df0c174976fabeff635a851bc0bc4c21ac339b +size 108 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..60cd32bc685a60421e8e6f0efa54f2bba1edfdff --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dba4178c03e74ec137429a898dc3fe3e4485551fbc8a66133e4430cbda9d1293 +size 10 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..45a94b35c9ec6bc5579fcd35a87bbd6d8b3ab638 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:872e582cf3d9df93eedcfa10415a86b3116912f38e7137b5dbbb540a239ffb24 +size 12 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_bvlc_alexnet/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_bvlc_alexnet/data.json new file mode 100644 index 0000000000000000000000000000000000000000..8172a83e232426f99dfdb8c82ef4d31f724999e0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_bvlc_alexnet/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "bvlc_alexnet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_bvlc_alexnet.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_densenet121/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_densenet121/data.json new file mode 100644 index 0000000000000000000000000000000000000000..69bac6cd284a5e8cf3279587be659f49cecfc252 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_densenet121/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "densenet121", "rtol": 0.002, "url": "onnx/backend/test/data/light/light_densenet121.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_inception_v1/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_inception_v1/data.json new file mode 100644 index 0000000000000000000000000000000000000000..50272a3b542a351e6dc57ddca865c68d7a6c6ba1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_inception_v1/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "inception_v1", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_inception_v1.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_inception_v2/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_inception_v2/data.json new file mode 100644 index 0000000000000000000000000000000000000000..7c26928046f8b082445bf489cc9f68d1e0ac8b41 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_inception_v2/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "inception_v2", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_inception_v2.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_resnet50/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_resnet50/data.json new file mode 100644 index 0000000000000000000000000000000000000000..f5a100e528f0233e080012a7887bcdff648050ec --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_resnet50/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "resnet50", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_resnet50.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_shufflenet/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_shufflenet/data.json new file mode 100644 index 0000000000000000000000000000000000000000..6bb5a0b9d45eb520b93e23bfba869d49068e60bb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_shufflenet/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "shufflenet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_shufflenet.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_squeezenet/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_squeezenet/data.json new file mode 100644 index 0000000000000000000000000000000000000000..fb0e7f252a18ed9c836c916f5ae076642fbac9bc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_squeezenet/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "squeezenet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_squeezenet.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_vgg19/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_vgg19/data.json new file mode 100644 index 0000000000000000000000000000000000000000..2ad3c4f647dc6df6353b097e2a76e81de8f00565 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_vgg19/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "vgg19", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_vgg19.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/real/test_zfnet512/data.json b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_zfnet512/data.json new file mode 100644 index 0000000000000000000000000000000000000000..4fabcd5aa0d169f4e576925471ba08ade1c83e47 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/real/test_zfnet512/data.json @@ -0,0 +1 @@ +{"atol": 1e-07, "model_name": "zfnet512", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_zfnet512.onnx"} \ No newline at end of file diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..07c1ff9c466ff1be9fe7db4cb8cb6f6e18669e13 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4635688307af248c7e17f34246b07bf2edf0cfc278de58b08bfe155d9e734f73 +size 132 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..419a378c8accc12e94e38a000aab441990512a14 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15e69c4f4256a5137c278fb44972fabb9205abcaeaa733624e0e63e7e537f685 +size 25 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..0a318017282ed9c0a76d5724572e92a1866df3ce --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa41683544eb3ce75c5000445edcfc63426f4d8c9a40a0d636822586575175ed +size 29 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8a8e2612363da0351b10689aa011f44256cfb521 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3abcb456e21b5a8c5042514dbaf7c72b1b12b6c5d4c7df031ed5752fed25ffc1 +size 25 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..5897cf28d086d968719fff2d270414d9787064b1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2f3017c74d3b1a92f1186001d18b1d11c395252cb5f660b1ff2c721ab90fdd2 +size 132 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..419a378c8accc12e94e38a000aab441990512a14 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15e69c4f4256a5137c278fb44972fabb9205abcaeaa733624e0e63e7e537f685 +size 25 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..a529a91413e0f904c1a4abd6994b5c7fcf935c6a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ed123191690318d9a5da9f1e6dcca495d5a419a82313cff7807be3404ae5ef2 +size 29 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..58c27a912dedcb4c167e9c40a4a45bcaabbc8b14 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35fafe638847302c7b45977acee1ad86f58e9d3aaae81d3601e28e4dc35489b0 +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e1f851d1d2c121155880813910cdf2858bcb5a86 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b65bb3af8af5658e446e632afbaa04c986878c27e0d96984ce61c13912b8683 +size 132 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..419a378c8accc12e94e38a000aab441990512a14 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15e69c4f4256a5137c278fb44972fabb9205abcaeaa733624e0e63e7e537f685 +size 25 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..88e84a67b3ea272b9a74eea248698e85358005d1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f74264f2ebbc5be664f882a860363533dca70e275aa5d3a01a50ec9fe361cecd +size 37 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6c035da6a7ce297f3b5b09ebf9f38435bcb944cb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f7875fc93279927da4b9bdedcd67af21c58b3dab9eaccb3408ad9c011b86327 +size 121 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..9834583a415a15b4a996931da67f3efe2c693780 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8b0adea1c6c1d7eb38fb06160870556279abdbdf1244395860cac35ced0fc83 +size 136 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..419a378c8accc12e94e38a000aab441990512a14 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15e69c4f4256a5137c278fb44972fabb9205abcaeaa733624e0e63e7e537f685 +size 25 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..74f87f06fc2f88c687e3e5c8512872277e3ee474 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4f3b935cf7f69287d48ac5f1c6c3c88ecf6419db8ec7b9142a8d062ba3347359 +size 45 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e7099dc2759aeee8ec4d7e7585a9185dce29fe0d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fb9e33fae9dc3761385e9e860a8d0915d27436f8e0ce586bf35daebe4d18ae78 +size 340 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1bf776268e9ee56aef8c2d8a5b8a7f5e386674c4 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:86ac4a77e14aca10b18ef794257624ec05c45ef647cb468a1b481fe80cd8cfbf +size 264 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..eba0fb76defda58baaaa904529711510a14ab135 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3592a1813d96f7ac3a4f03d4f9e82bd95ecdb2698b210141b837d0e7976e4cc +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..e96db45deb00d3a7a7bfe0184dd26b9759554caf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c0fef2d265fc51c3413cba28cc50fd008e4b138687d6e877d6666655d9ae7d6 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f24677ec5d944b1cc40f374db1ff8a3b932ced6e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:328a2912aed8be6948896a7e50b9d943b72060bc9e4d3c6a3b57aa54d9fd2908 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..338b1530965d0e1180afc76c8b0bc22e2658bd04 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:628e2a70ca237069362593d246970a498fc15a46ca719a11b82fa74f93a50993 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..d0afd187fc01e877b572a0a455b950fa04bab640 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d71c756a6abd3f5f9d3cadf4b4da6711d367f9276e3ab7a671e3b0f2e5bc0b79 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0da4b034dc8491b4189a7fa59d2039ddeffbdb10 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58dc697eea329aedd0d5292bb2c550001ab9e5e6b71a809c196c62eda48c1c97 +size 297 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..eba0fb76defda58baaaa904529711510a14ab135 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3592a1813d96f7ac3a4f03d4f9e82bd95ecdb2698b210141b837d0e7976e4cc +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..e96db45deb00d3a7a7bfe0184dd26b9759554caf --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c0fef2d265fc51c3413cba28cc50fd008e4b138687d6e877d6666655d9ae7d6 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..fe9f66d4da8ff423ec6f72a15188c7361f1493b3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:93f4a57187b16403ade1f3fa5f682177eedc86250c5cea32bc226f788dcc4d67 +size 11 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..91dd84403aab9263c81580fbf9bc8f634fb8481b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64852bd25350c683afc88bdd16390a364ff1d74274fc497604a842d553b90aab +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..6c28614043c0df2b56e9d8c1d8d3c419812debb6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d7c99be696eb028cfb6b893020721c179e5c071788403856cfa80f30cf3d4f9 +size 15 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d3952f49eb6123aaae789e666a8880d23e108e51 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e71145a28844efac2df0598f0b96a86cc0a7cacf5901b36d657c09d72075ce19 +size 371 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7cc8de9e5ba4d3b9b6fc8858da202a83fa6db5d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c11d889aedb20c2047b85397d60ac5ce6f94dfee4ae23a3a0d3a26f4b64529a +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..e3cbb6a4570afdbf3bdc1e5477e74b56b8ebb40d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69c5942492648da7a01f25995e4d53ce652fecf8f603a163e0a6aef8b0faf304 +size 61 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..b960c25bedf2e62e0677ae1831156a6299ecf350 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2373eca6563c96e303e79c81e1679fc129a5b2f163acaab01afe66c9ad19da2 +size 158 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..388e37c90f7075111a76315ff06bccec9caeb15a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ee606df9b33b12e901190cd4beaa32c4bf77e1bd8bac2903c7f237f8f01a5996 +size 63 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..3e410ec763a201061ce1f4f4469355753c65cc29 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:299cd904657eb43bff6e45a8d8a3a38b1afc60a6c75d2fe8ae7c2cb1d3cfa636 +size 322 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7cc8de9e5ba4d3b9b6fc8858da202a83fa6db5d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c11d889aedb20c2047b85397d60ac5ce6f94dfee4ae23a3a0d3a26f4b64529a +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..ddec2d5685dfb557875128e4b1c4dab132ae5406 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:418b83405698264fef64e949bceac58a118d470621408bf15b9f62fdd0c56af0 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..593a352db68a5c0ea3da20783ae8ccc39934f7e6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb2213e065346a2e637ebacc5b10d8967442cddc9da901ef8fd026cd79f46aa8 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..85a56e2652c3572e5408cc5857ab6c5a24af21c1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d157e1a990c2c64330c37905f021ccb1d3d0d9a7baff71c7ad619f514521731b +size 111 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..c97c61b45b5619d928682e7de6422e1ade76e8b7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:27daaf8fb59a6174df24959bc2568e66aeee0926357a69d6bfc3ade1b5735668 +size 437 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7cc8de9e5ba4d3b9b6fc8858da202a83fa6db5d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c11d889aedb20c2047b85397d60ac5ce6f94dfee4ae23a3a0d3a26f4b64529a +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..ddec2d5685dfb557875128e4b1c4dab132ae5406 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:418b83405698264fef64e949bceac58a118d470621408bf15b9f62fdd0c56af0 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..593a352db68a5c0ea3da20783ae8ccc39934f7e6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb2213e065346a2e637ebacc5b10d8967442cddc9da901ef8fd026cd79f46aa8 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..85a56e2652c3572e5408cc5857ab6c5a24af21c1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d157e1a990c2c64330c37905f021ccb1d3d0d9a7baff71c7ad619f514521731b +size 111 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8e612227b5f7798162eabab23431f7d24d8765d1 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d5d67c440a8bd82e0ce6ab766a70052f45e45b8abbdff92b1ab381faf47421e0 +size 219 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7cc8de9e5ba4d3b9b6fc8858da202a83fa6db5d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c11d889aedb20c2047b85397d60ac5ce6f94dfee4ae23a3a0d3a26f4b64529a +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..ddec2d5685dfb557875128e4b1c4dab132ae5406 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:418b83405698264fef64e949bceac58a118d470621408bf15b9f62fdd0c56af0 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..593a352db68a5c0ea3da20783ae8ccc39934f7e6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb2213e065346a2e637ebacc5b10d8967442cddc9da901ef8fd026cd79f46aa8 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..e3a4cf7990b14b2664df75acf573f8c65645d152 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c67e4018fcec362c14ef3bce18cc30dc62b42ba9a36457b272db880890c3fe39 +size 304 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..8e25a4f4403e93be0f451e9f96932bff16d255b5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d58a967fe27c96880158631097dc181ec97225ea33035f68dd42d5de016b21e5 +size 251 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7cc8de9e5ba4d3b9b6fc8858da202a83fa6db5d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c11d889aedb20c2047b85397d60ac5ce6f94dfee4ae23a3a0d3a26f4b64529a +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..ddec2d5685dfb557875128e4b1c4dab132ae5406 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:418b83405698264fef64e949bceac58a118d470621408bf15b9f62fdd0c56af0 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb new file mode 100644 index 0000000000000000000000000000000000000000..593a352db68a5c0ea3da20783ae8ccc39934f7e6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb2213e065346a2e637ebacc5b10d8967442cddc9da901ef8fd026cd79f46aa8 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..bf48af7b66576c8e22c2b237a123c5bf1451ccb3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3346d3d018be3262bbeaaee0fcd1876411ad06a0884643841db67043138c4b83 +size 306 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..70ae381c3ce43b44ee502b7be09cdaa0103979b6 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:240368624bf2dca1f0bb4390a7bfc939e6e4daecb2c179c5d643a1021f2ff80f +size 156 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..7cc8de9e5ba4d3b9b6fc8858da202a83fa6db5d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c11d889aedb20c2047b85397d60ac5ce6f94dfee4ae23a3a0d3a26f4b64529a +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..97590181c4b64a310998bee3561299e22616083a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:59085bb1db26b263d11dba6a7d9d8c892d0300a7dd7fee5ab51889dcf4126bc2 +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..efc319043d21a64086ef3af02c08154be3afa3c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f16d080a63c7e08f916f23e0d6c500a92f20f345632376f5c3a2b05fc2d2b612 +size 209 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..26056515251a89d4afb0a3e4c13dc12dfa41a118 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8836f604417aaf5b3f22f9b695a9a2d827799ae9ab007fa20ae7dda93599b558 +size 206 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..d31fb4f30886784b3a64b61d24602c2836a5db0e --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8510e4e3dcd428afb3c7a915842c8f6d45bc1806c7da81e77b8501119f9a6cf9 +size 109 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..e7707b79585bced3296c16c2f23f895f659aa567 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b911bee0f943336e3e485d3110c8a09959d17bf793a294e1e623f00264499e00 +size 157 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..9af372f7a2a74a4914574109df73668cbe714c0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:32772570c50137ce977517422210db8b0f225c135563d9b6ce6c8552794c2ccf +size 9 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb new file mode 100644 index 0000000000000000000000000000000000000000..6bbcc2bb5739af00da55f04aaf26ffe01ac17add --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ec426005ebfc242ed5d11c3f83062fea9fff5a7ea7b47a22b0f80e5e62e5ebcd +size 38 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c9df237917a188a7c1593cd3904d0ec23514aa0b --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d0c4b325adcb2005a5f258b9b99b9416d4f8757b5c41f15a0bb139e9f86f532 +size 17 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..1e8bc6679384a2df59d3e2bc6ef148916f830fb0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c36d1e7550cbb85611ca0fe64c54de5f6f1f0c8bdfe44bb60e47e65f49d51b30 +size 115 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2c56143cafdeb64a2e902c0316121075e14e0f96 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6fa786d09a1268d7c567db8de831ee56579b1b88729f9ae6f68db1cd4db0d3e6 +size 29 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..8c67b073d174cf4ef85ba3086ca857664f0bc79a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01b429957279155bb62da373182d2ddc6f446616540ac77efdf9f25d10fd4f62 +size 29 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0f29690e8db6cfb0460fee374c39ba2fbbc9d586 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c7e0ee53737e98863dd01e2e471ba1a20285559abc9c75f126b16ce62f9f0ca4 +size 90 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..521daff72f69508a53313904c255da98d22ad67f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:398a0fc7a1ede855dd7e9b335339df387707637e2bb1c53cdef82494994657f0 +size 37 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..939daf2ad891e6f1ab9713e367159a0303e94073 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:09e2b0525408f6d1f2cb310d3f2ab8deff83827690873a911709c84e2a40ed26 +size 37 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..67182b4193ae137b3e0b453a3eac058f25b74863 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f35b768e076a0cdda9c7dcf3a0f3ecbb849396b2f715fd442c7705c7d1fb473b +size 98 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..022f78462ca025fd7d58c8318bada6d20eaaef19 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf73c8c03bf97a56ec4f29558c4226ea4cea6400f0ca7ef05c538a6b39063c3a +size 19 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..53435adb47df7ab764abe1ffcf16b72319dd3e24 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a3f28d5710fb67ae20bbb33ff19076483edc6e305083b65c4e2774a1993f95c0 +size 19 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..0ccce556c294646c9dab3277675894268adfa1a0 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:604278554856080e7c393b85eeb7390986b34b0c83be6fe174d6614894523ac1 +size 185 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..af9e40c3e33302ee98103cc12c663c3f4f3b0e85 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ac5cb8ad56d2b68d7675fcbafe590a34273cb3511a6dbcbe4d935f6f4174abf +size 45 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c6fde3a67d4a1e598645d767d3c4d061e0e94375 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ffe986459ec6f48f62031d8ff65324dda1d46b03f65ca8cef619f67e947ab696 +size 37 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..a42c308e097542d2049032c2870ece974994f28a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:721af59c24e1a7a638579db30b65ab4d6509d0664920928238941307aaabba20 +size 153 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..af9e40c3e33302ee98103cc12c663c3f4f3b0e85 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ac5cb8ad56d2b68d7675fcbafe590a34273cb3511a6dbcbe4d935f6f4174abf +size 45 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..c6fde3a67d4a1e598645d767d3c4d061e0e94375 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ffe986459ec6f48f62031d8ff65324dda1d46b03f65ca8cef619f67e947ab696 +size 37 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d8716587f8960deb1ddeb6c6c60a4d70f4d1f4bc --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99390c7502fd90ac8583ec17ad119c1998e9fc9904c0b641f96bf86d3b5e5766 +size 185 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..af9e40c3e33302ee98103cc12c663c3f4f3b0e85 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ac5cb8ad56d2b68d7675fcbafe590a34273cb3511a6dbcbe4d935f6f4174abf +size 45 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..1f43cbe8143bcfd309d8c35f25484046a8d620f8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed993e21e09aa8709fb39675cea1e9e4444a30006ef1e31155560d4cc2dd15ce +size 37 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..444a6aa57658a9b114b2c3c873a9511595d359bb --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eeb4233d261f80ae3d8bd35748fd7065b663b0a29a1d072ec9a65795fc5b9490 +size 185 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..f01070f8b9cc90e8280bb6d82d55022577a9c5d5 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c6a24ea9cee99e598996eb561c13680ee3d1593f81e13b92fb55089aa1fa284 +size 23 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..b4c577a8755d9daebf3e6a20c5c53f8218fc98d7 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ef7b8d66a93235d48ee45287fb05ecba46d93b4afdb78fcc55f716892cfcd0d +size 9 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..4bec97c9ca7539d64015e24218bf017e44bec2c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a00fc455335e727394d5ea799fd3981115398aa85a11763b261992404eb2703b +size 167 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..2fc15b6db50d99cd2a430fc339c219572ea348e8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7f72b47a746d25e8f13765fd26d02d5678fbf676c2ae51449e4811c3e3e7f1f +size 65 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..da2f0599714b06c12c594a1b0d6d9d0abb0c60bd --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ad3fe4796c271e991b7e46bcd02bb30f8d7390c2a6c405e64271899ad496fb3 +size 49 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..3d09dbc982cd44e7a9fdf032d665f9849784c512 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d59a71ed61f4d50d3d83bf1f382b2aed11611ab5353749f9e53c65c3486846c +size 128 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..03f4e1303622f8cd1734bab2bdcf608d0b8738f3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b811eae0cf9a95e015b3f667c90b72f98cfce726bbc0ae83a7b4635e4d1b519c +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb new file mode 100644 index 0000000000000000000000000000000000000000..6a1714d914d33a0235851f03330a1e73642d4c0c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3618c65a33d5c66911d1fdf98217f1e98426dc8b3612e7bd2d6082f8d690a906 +size 24 diff --git a/runtime/Lib/site-packages/onnx/backend/test/loader/__init__.py b/runtime/Lib/site-packages/onnx/backend/test/loader/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2b67bcb6fb60018bddfeeef630c930323a324485 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/loader/__init__.py @@ -0,0 +1,62 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import json +import os +from typing import List, Optional + +from onnx.backend.test.case.test_case import TestCase + +DATA_DIR = os.path.join( + os.path.dirname(os.path.realpath(os.path.dirname(__file__))), "data" +) + + +def load_model_tests( + data_dir: str = DATA_DIR, + kind: Optional[str] = None, +) -> List[TestCase]: + """Load model test cases from on-disk data files.""" + + supported_kinds = os.listdir(data_dir) + if kind not in supported_kinds: + raise ValueError(f"kind must be one of {supported_kinds}") + + testcases = [] + + kind_dir = os.path.join(data_dir, kind) + for test_name in os.listdir(kind_dir): + case_dir = os.path.join(kind_dir, test_name) + # skip the non-dir files, such as generated __init__.py. + rtol = 1e-3 + atol = 1e-7 + if not os.path.isdir(case_dir): + continue + if os.path.exists(os.path.join(case_dir, "model.onnx")): + url = None + model_name = test_name[len("test_")] + model_dir: Optional[str] = case_dir + else: + with open(os.path.join(case_dir, "data.json")) as f: + data = json.load(f) + url = data["url"] + model_name = data["model_name"] + rtol = data.get("rtol", 1e-3) + atol = data.get("atol", 1e-7) + model_dir = None + testcases.append( + TestCase( + name=test_name, + url=url, + model_name=model_name, + model_dir=model_dir, + model=None, + data_sets=None, + kind=kind, + rtol=rtol, + atol=atol, + ) + ) + + return testcases diff --git a/runtime/Lib/site-packages/onnx/backend/test/report/__init__.py b/runtime/Lib/site-packages/onnx/backend/test/report/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1843a96338e034e373618a3db3b70a6aff8285be --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/report/__init__.py @@ -0,0 +1,44 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Dict, Sequence + +import _pytest +import pytest + +from onnx.backend.test.report.coverage import Coverage + +_coverage = Coverage() +_marks: Dict[str, Sequence[Any]] = {} + + +def _add_mark(mark: Any, bucket: str) -> None: + proto = mark.args[0] + if isinstance(proto, list): + assert len(proto) == 1 + proto = proto[0] + if proto is not None: + _coverage.add_proto(proto, bucket, mark.args[1] == "RealModel") + + +def pytest_runtest_call(item: _pytest.nodes.Item) -> None: + mark = item.get_closest_marker("onnx_coverage") + if mark: + assert item.nodeid not in _marks + _marks[item.nodeid] = mark + + +def pytest_runtest_logreport(report: Any) -> None: + if report.when == "call" and report.outcome == "passed" and report.nodeid in _marks: + mark = _marks[report.nodeid] + _add_mark(mark, "passed") + + +@pytest.hookimpl(trylast=True) # type: ignore +def pytest_terminal_summary( + terminalreporter: _pytest.terminal.TerminalReporter, exitstatus: int +) -> None: + for mark in _marks.values(): + _add_mark(mark, "loaded") + _coverage.report_text(terminalreporter) diff --git a/runtime/Lib/site-packages/onnx/backend/test/report/base.py b/runtime/Lib/site-packages/onnx/backend/test/report/base.py new file mode 100644 index 0000000000000000000000000000000000000000..b59683fb9bd5a6ef82bb98d47aa550c5728ebd37 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/report/base.py @@ -0,0 +1,7 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + + +class ReporterBase: + pass diff --git a/runtime/Lib/site-packages/onnx/backend/test/report/coverage.py b/runtime/Lib/site-packages/onnx/backend/test/report/coverage.py new file mode 100644 index 0000000000000000000000000000000000000000..ddac8e085b3f01bbbc0b6abb5dd53256bcd878e9 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/report/coverage.py @@ -0,0 +1,264 @@ +# Copyright (c) ONNX Project Contributors + +# SPDX-License-Identifier: Apache-2.0 + +import csv +import datetime +import os +from collections import OrderedDict, defaultdict +from typing import IO, Any, Dict, List, Optional, Set + +from tabulate import tabulate + +import onnx +from onnx import GraphProto, defs, helper + +_all_schemas = defs.get_all_schemas() + + +class AttrCoverage: + def __init__(self) -> None: + self.name: Optional[str] = None + self.values: Set[str] = set() + + def add(self, attr: onnx.AttributeProto) -> None: + assert self.name in [None, attr.name] + self.name = attr.name + value = helper.get_attribute_value(attr) + # Turn list into tuple so we can put it into set + # As value can be string, don't blindly turn `collections.Iterable` + # into tuple. + if isinstance(value, list): + value = tuple(value) + self.values.add(str(value)) + + +class NodeCoverage: + def __init__(self) -> None: + self.op_type: Optional[str] = None + self.attr_coverages: Dict[str, AttrCoverage] = defaultdict(AttrCoverage) + + def add(self, node: onnx.NodeProto) -> None: + assert self.op_type in [None, node.op_type] + + if self.op_type is None: + self.op_type = node.op_type + assert self.op_type is not None + self.schema = defs.get_schema(self.op_type, domain=node.domain) + + for attr in node.attribute: + self.attr_coverages[attr.name].add(attr) + + +class ModelCoverage: + def __init__(self) -> None: + self.name: Optional[str] = None + self.graph: Optional[GraphProto] = None + self.node_coverages: Dict[str, NodeCoverage] = defaultdict(NodeCoverage) + + def add(self, model: onnx.ModelProto) -> None: + assert self.name in [None, model.graph.name] + + if self.name is None: + self.name = model.graph.name + assert self.name is not None + self.graph = model.graph + + for node in model.graph.node: + self.node_coverages[node.op_type].add(node) + + +class Coverage: + def __init__(self) -> None: + self.buckets: Dict[str, Dict[str, NodeCoverage]] = { + "loaded": defaultdict(NodeCoverage), + "passed": defaultdict(NodeCoverage), + } + self.models: Dict[str, Dict[str, ModelCoverage]] = { + "loaded": defaultdict(ModelCoverage), + "passed": defaultdict(ModelCoverage), + } + + def add_node(self, node: onnx.NodeProto, bucket: str) -> None: + self.buckets[bucket][node.op_type].add(node) + + def add_graph(self, graph: onnx.GraphProto, bucket: str) -> None: + for node in graph.node: + self.add_node(node, bucket) + + def add_model(self, model: onnx.ModelProto, bucket: str, is_model: bool) -> None: + self.add_graph(model.graph, bucket) + # Only add model if name does not start with test + if is_model: + self.models[bucket][model.graph.name].add(model) + + def add_proto(self, proto: onnx.ModelProto, bucket: str, is_model: bool) -> None: + assert isinstance(proto, onnx.ModelProto) + self.add_model(proto, bucket, is_model) + + def report_text(self, writer: IO[str]) -> None: + writer.write("---------- onnx coverage: ----------\n") + writer.write( + f"Operators (passed/loaded/total): {len(self.buckets['passed'])}/{len(self.buckets['loaded'])}/{len(_all_schemas)}\n" + ) + writer.write("------------------------------------\n") + + rows = [] + passed = [] + all_ops: List[str] = [] + experimental: List[str] = [] + for op_cov in self.buckets["passed"].values(): + covered_attrs = [ + f"{attr_cov.name}: {len(attr_cov.values)}" + for attr_cov in op_cov.attr_coverages.values() + ] + uncovered_attrs = [ + f"{attr}: 0" + for attr in op_cov.schema.attributes + if attr not in op_cov.attr_coverages + ] + attrs = sorted(covered_attrs) + sorted(uncovered_attrs) + if attrs: + attrs_column = os.linesep.join(attrs) + else: + attrs_column = "No attributes" + rows.append([op_cov.op_type, attrs_column]) + passed.append(op_cov.op_type) + writer.write( + tabulate( + rows, + headers=["Operator", "Attributes\n(name: #values)"], + tablefmt="plain", + ) + ) + writer.write("\n") + if os.environ.get("CSVDIR") is not None: + self.report_csv(all_ops, passed, experimental) + + # This function writes the coverage report to a set of CSV files for + # the Backend Scoreboard (onnx.ai/backend-scoreboard). To enable this + # feature, set a CSVDIR environment variable locally with the directory + # where you would like the files to be written, relative to the + # directory from which you're running pytest. The format of the CSV + # files is a column naming each op or model and columns for each + # backend with indications of whether the tests passed or failed for + # each row. + def report_csv( + self, all_ops: List[str], passed: List[Optional[str]], experimental: List[str] + ) -> None: + for schema in _all_schemas: + if schema.domain == "" or schema.domain == "ai.onnx": + all_ops.append(schema.name) + if schema.support_level == defs.OpSchema.SupportType.EXPERIMENTAL: + experimental.append(schema.name) + all_ops.sort() + nodes_path = os.path.join( + str(os.environ.get("CSVDIR")), "nodes.csv" # type: ignore + ) # type: ignore + models_path = os.path.join( + str(os.environ.get("CSVDIR")), "models.csv" # type: ignore + ) # type: ignore + existing_nodes: OrderedDict[str, Dict[str, str]] = OrderedDict() + existing_models: OrderedDict[str, Dict[str, str]] = OrderedDict() + frameworks: List[str] = [] + if os.path.isfile(nodes_path): + with open(nodes_path) as nodes_file: + reader = csv.DictReader(nodes_file) + assert reader.fieldnames + frameworks = list(reader.fieldnames) + for row in reader: + op = row["Op"] + del row["Op"] + existing_nodes[str(op)] = row + if os.path.isfile(models_path): + with open(models_path) as models_file: + reader = csv.DictReader(models_file) + for row in reader: + model = row["Model"] + del row["Model"] + existing_models[str(model)] = row + backend = os.environ.get("BACKEND") + other_frameworks = frameworks[1:] + with open(nodes_path, "w") as nodes_file: + if "Op" not in frameworks: + frameworks.append("Op") + if backend not in frameworks: + frameworks.append(str(backend)) + else: + other_frameworks.remove(str(backend)) + node_writer = csv.DictWriter(nodes_file, fieldnames=frameworks) + node_writer.writeheader() + for node in all_ops: + node_name = node + if node in experimental: + node_name = node + " (Experimental)" + if node_name not in existing_nodes: + # Also add Skipped for other nodes + existing_nodes[node_name] = OrderedDict() + for other_framework in other_frameworks: + existing_nodes[node_name][other_framework] = "Skipped!" + if node in passed: + existing_nodes[node_name][str(backend)] = "Passed!" + else: + existing_nodes[node_name][str(backend)] = "Failed!" + summaries: Dict[Any, Any] = dict() + if "Summary" in existing_nodes: + summaries = existing_nodes["Summary"] + del existing_nodes["Summary"] + summaries[str(backend)] = f"{len(passed)}/{len(all_ops)} node tests passed" + summaries["Op"] = "Summary" + for node in existing_nodes: + existing_nodes[node]["Op"] = str(node) + node_writer.writerow(existing_nodes[node]) + node_writer.writerow(summaries) + with open(models_path, "w") as models_file: + frameworks[0] = "Model" + model_writer = csv.DictWriter(models_file, fieldnames=frameworks) + model_writer.writeheader() + # Consider both buckets + num_models = 0 + for bucket in self.models: + for model in self.models[bucket]: # type: ignore + # Both analyze and run the model on the backend + num_covered = 0 + for node in self.models[bucket][model].node_coverages: + if node in passed: + num_covered += 1 + # TODO: Identify if there are models that are being + # skipped/not loaded, but that are in other frameworks + msg = "Passed!" + if bucket == "loaded": + if model in self.models["passed"]: + continue + msg = "Failed!" + num_models += 1 + if model not in existing_models: + # Also add Skipped for other models + existing_models[model] = OrderedDict() + for other_framework in other_frameworks: + existing_models[model][other_framework] = "Skipped!" + existing_models[model][str(backend)] = str( + f"{num_covered}/{len(self.models[bucket][model].node_coverages)} nodes covered: {msg}" + ) + summaries.clear() + if "Summary" in existing_models: + summaries = existing_models["Summary"] + del existing_models["Summary"] + if str(backend) in summaries: + del summaries[str(backend)] + summaries[ + str(backend) + ] = f"{len(self.models['passed'])}/{num_models} model tests passed" + summaries["Model"] = "Summary" + for model in existing_models: # type: ignore + existing_models[model]["Model"] = model + model_writer.writerow(existing_models[model]) + model_writer.writerow(summaries) + with open( + os.path.join(str(os.environ.get("CSVDIR")), "metadata.csv"), # type: ignore + "w", + ) as metadata_file: # type: ignore + metadata_writer = csv.writer(metadata_file) + metadata_writer.writerow( + ["Latest Update", datetime.datetime.now().isoformat().replace("T", " ")] + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/runner/__init__.py b/runtime/Lib/site-packages/onnx/backend/test/runner/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b435a44a444bb6562888948feb950eb5b182657d --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/runner/__init__.py @@ -0,0 +1,496 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import functools +import glob +import os +import re +import shutil +import sys +import tarfile +import tempfile +import time +import unittest +from collections import defaultdict +from typing import ( + Any, + Callable, + Dict, + Iterable, + List, + Optional, + Pattern, + Sequence, + Set, + Type, + Union, +) +from urllib.request import urlretrieve + +import numpy as np + +import onnx +import onnx.reference +from onnx import ONNX_ML, ModelProto, NodeProto, TypeProto, ValueInfoProto, numpy_helper +from onnx.backend.base import Backend +from onnx.backend.test.case.test_case import TestCase +from onnx.backend.test.loader import load_model_tests +from onnx.backend.test.runner.item import TestItem + + +class BackendIsNotSupposedToImplementIt(unittest.SkipTest): + pass + + +def retry_execute(times: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]: + assert times >= 1 + + def wrapper(func: Callable[..., Any]) -> Callable[..., Any]: + @functools.wraps(func) + def wrapped(*args: Any, **kwargs: Any) -> Any: + for i in range(1, times + 1): + try: + return func(*args, **kwargs) + except Exception: + print(f"{i} times tried") + if i == times: + raise + time.sleep(5 * i) + + return wrapped + + return wrapper + + +class Runner: + def __init__( + self, backend: Type[Backend], parent_module: Optional[str] = None + ) -> None: + self.backend = backend + self._parent_module = parent_module + self._include_patterns: Set[Pattern[str]] = set() + self._exclude_patterns: Set[Pattern[str]] = set() + self._xfail_patterns: Set[Pattern[str]] = set() + + # This is the source of the truth of all test functions. + # Properties `test_cases`, `test_suite` and `tests` will be + # derived from it. + # {category: {name: func}} + self._test_items: Dict[str, Dict[str, TestItem]] = defaultdict(dict) + + for rt in load_model_tests(kind="node"): + self._add_model_test(rt, "Node") + + for rt in load_model_tests(kind="real"): + self._add_model_test(rt, "Real") + + for rt in load_model_tests(kind="simple"): + self._add_model_test(rt, "Simple") + + for ct in load_model_tests(kind="pytorch-converted"): + self._add_model_test(ct, "PyTorchConverted") + + for ot in load_model_tests(kind="pytorch-operator"): + self._add_model_test(ot, "PyTorchOperator") + + def _get_test_case(self, name: str) -> Type[unittest.TestCase]: + test_case = type(str(name), (unittest.TestCase,), {}) + if self._parent_module: + test_case.__module__ = self._parent_module + return test_case + + def include(self, pattern: str) -> Runner: + self._include_patterns.add(re.compile(pattern)) + return self + + def exclude(self, pattern: str) -> Runner: + self._exclude_patterns.add(re.compile(pattern)) + return self + + def xfail(self, pattern: str) -> Runner: + self._xfail_patterns.add(re.compile(pattern)) + return self + + def enable_report(self) -> Runner: + import pytest + + for category, items_map in self._test_items.items(): + for item in items_map.values(): + item.func = pytest.mark.onnx_coverage(item.proto, category)(item.func) + return self + + @property + def _filtered_test_items(self) -> Dict[str, Dict[str, TestItem]]: + filtered: Dict[str, Dict[str, TestItem]] = {} + for category, items_map in self._test_items.items(): + filtered[category] = {} + for name, item in items_map.items(): + if self._include_patterns and ( + not any(include.search(name) for include in self._include_patterns) + ): + item.func = unittest.skip("no matched include pattern")(item.func) + for exclude in self._exclude_patterns: + if exclude.search(name): + item.func = unittest.skip( + f'matched exclude pattern "{exclude.pattern}"' + )(item.func) + for xfail in self._xfail_patterns: + if xfail.search(name): + item.func = unittest.expectedFailure(item.func) + filtered[category][name] = item + return filtered + + @property + def test_cases(self) -> Dict[str, Type[unittest.TestCase]]: + """ + List of test cases to be applied on the parent scope + Example usage: + globals().update(BackendTest(backend).test_cases) + """ + test_cases = {} + for category, items_map in self._filtered_test_items.items(): + test_case_name = f"OnnxBackend{category}Test" + test_case = self._get_test_case(test_case_name) + for name, item in sorted(items_map.items()): + setattr(test_case, name, item.func) + test_cases[test_case_name] = test_case + return test_cases + + @property + def test_suite(self) -> unittest.TestSuite: + """ + TestSuite that can be run by TestRunner + Example usage: + unittest.TextTestRunner().run(BackendTest(backend).test_suite) + """ + suite = unittest.TestSuite() + for case in sorted( + self.test_cases.values(), key=lambda cl: cl.__class__.__name__ + ): + suite.addTests(unittest.defaultTestLoader.loadTestsFromTestCase(case)) + return suite + + # For backward compatibility (we used to expose `.tests`) + @property + def tests(self) -> Type[unittest.TestCase]: + """ + One single unittest.TestCase that hosts all the test functions + Example usage: + onnx_backend_tests = BackendTest(backend).tests + """ + tests = self._get_test_case("OnnxBackendTest") + for items_map in sorted( + self._filtered_test_items.values(), key=lambda cl: cl.__class__.__name__ + ): + for name, item in sorted(items_map.items()): + setattr(tests, name, item.func) + return tests + + @classmethod + def assert_similar_outputs( + cls, + ref_outputs: Sequence[Any], + outputs: Sequence[Any], + rtol: float, + atol: float, + ) -> None: + np.testing.assert_equal(len(outputs), len(ref_outputs)) + for i in range(len(outputs)): + if isinstance(outputs[i], (list, tuple)): + for j in range(len(outputs[i])): + cls.assert_similar_outputs( + ref_outputs[i][j], outputs[i][j], rtol, atol + ) + else: + np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype) + if ref_outputs[i].dtype == object: # type: ignore[attr-defined] + np.testing.assert_array_equal(outputs[i], ref_outputs[i]) + else: + np.testing.assert_allclose( + outputs[i], ref_outputs[i], rtol=rtol, atol=atol + ) + + @classmethod + @retry_execute(3) + def download_model( + cls, model_test: TestCase, model_dir: str, models_dir: str + ) -> None: + # On Windows, NamedTemporaryFile can not be opened for a + # second time + download_file = tempfile.NamedTemporaryFile(delete=False) + try: + download_file.close() + assert model_test.url + print( + f"Start downloading model {model_test.model_name} from {model_test.url}" + ) + urlretrieve(model_test.url, download_file.name) + print("Done") + with tarfile.open(download_file.name) as t: + t.extractall(models_dir) + except Exception as e: + print(f"Failed to prepare data for model {model_test.model_name}: {e}") + raise + finally: + os.remove(download_file.name) + + @classmethod + def prepare_model_data(cls, model_test: TestCase) -> str: + onnx_home = os.path.expanduser( + os.getenv("ONNX_HOME", os.path.join("~", ".onnx")) + ) + models_dir = os.getenv("ONNX_MODELS", os.path.join(onnx_home, "models")) + model_dir: str = os.path.join(models_dir, model_test.model_name) + if not os.path.exists(os.path.join(model_dir, "model.onnx")): + if os.path.exists(model_dir): + bi = 0 + while True: + dest = f"{model_dir}.old.{bi}" + if os.path.exists(dest): + bi += 1 + continue + shutil.move(model_dir, dest) + break + os.makedirs(model_dir) + + cls.download_model( + model_test=model_test, model_dir=model_dir, models_dir=models_dir + ) + return model_dir + + def _add_test( + self, + category: str, + test_name: str, + test_func: Callable[..., Any], + report_item: List[Optional[Union[ModelProto, NodeProto]]], + devices: Iterable[str] = ("CPU", "CUDA"), + ) -> None: + # We don't prepend the 'test_' prefix to improve greppability + if not test_name.startswith("test_"): + raise ValueError(f"Test name must start with test_: {test_name}") + + def add_device_test(device: str) -> None: + device_test_name = f"{test_name}_{device.lower()}" + if device_test_name in self._test_items[category]: + raise ValueError( + f'Duplicated test name "{device_test_name}" in category "{category}"' + ) + + @unittest.skipIf( # type: ignore + not self.backend.supports_device(device), + f"Backend doesn't support device {device}", + ) + @functools.wraps(test_func) + def device_test_func(*args: Any, **kwargs: Any) -> Any: + try: + return test_func(*args, device=device, **kwargs) + except BackendIsNotSupposedToImplementIt as e: + # hacky verbose reporting + if "-v" in sys.argv or "--verbose" in sys.argv: + print(f"Test {device_test_name} is effectively skipped: {e}") + + self._test_items[category][device_test_name] = TestItem( + device_test_func, report_item + ) + + for device in devices: + add_device_test(device) + + @staticmethod + def generate_dummy_data( + x: ValueInfoProto, seed: int = 0, name: str = "", random: bool = False + ) -> np.ndarray: + """ + Generates a random tensor based on the input definition. + """ + if not x.type.tensor_type: + raise NotImplementedError( + f"Input expected to have tensor type. " + f"Unable to generate random data for model {name!r} and input {x}." + ) + if x.type.tensor_type.elem_type != 1: + raise NotImplementedError( + f"Currently limited to float tensors. " + f"Unable to generate random data for model {name!r} and input {x}." + ) + shape = tuple( + d.dim_value if d.HasField("dim_value") else 1 + for d in x.type.tensor_type.shape.dim + ) + if random: + gen = np.random.default_rng(seed=seed) + return gen.random(shape, np.float32) + n = np.prod(shape) + return (np.arange(n).reshape(shape) / n).astype(np.float32) + + def _add_model_test(self, model_test: TestCase, kind: str) -> None: + # model is loaded at runtime, note sometimes it could even + # never loaded if the test skipped + model_marker: List[Optional[Union[ModelProto, NodeProto]]] = [None] + + def run(test_self: Any, device: str) -> None: + if model_test.url is not None and model_test.url.startswith( + "onnx/backend/test/data/light/" + ): + # testing local files + model_pb_path = os.path.normpath( + os.path.join( + os.path.dirname(__file__), + "..", + "..", + "..", + "..", + model_test.url, + ) + ) + if not os.path.exists(model_pb_path): + raise FileNotFoundError(f"Unable to find model {model_pb_path!r}.") + onnx_home = os.path.expanduser( + os.getenv("ONNX_HOME", os.path.join("~", ".onnx")) + ) + models_dir = os.getenv( + "ONNX_MODELS", os.path.join(onnx_home, "models", "light") + ) + model_dir: str = os.path.join(models_dir, model_test.model_name) + if not os.path.exists(model_dir): + os.makedirs(model_dir) + use_dummy = True + else: + if model_test.model_dir is None: + model_dir = self.prepare_model_data(model_test) + else: + model_dir = model_test.model_dir + model_pb_path = os.path.join(model_dir, "model.onnx") + use_dummy = False + + if not ONNX_ML and "ai_onnx_ml" in model_dir: + return + + model = onnx.load(model_pb_path) + model_marker[0] = model + if ( + hasattr(self.backend, "is_compatible") + and callable(self.backend.is_compatible) + and not self.backend.is_compatible(model) + ): + raise unittest.SkipTest("Not compatible with backend") + + prepared_model = self.backend.prepare(model, device) + assert prepared_model is not None + + if use_dummy: + # When the backend test goes through a test involving a + # model stored in onnx/backend/test/data/light, + # this function generates expected output coming from + # from ReferenceEvaluator run with random inputs. + # A couple of models include many Conv operators and the + # python implementation is slow (such as test_bvlc_alexnet). + with open(model_pb_path, "rb") as f: + onx = onnx.load(f) + + test_data_set = os.path.join(model_dir, "test_data_set_0") + if not os.path.exists(test_data_set): + os.mkdir(test_data_set) + feeds = {} + inits = set(i.name for i in onx.graph.initializer) + n_input = 0 + inputs = [] + for i in range(len(onx.graph.input)): + if onx.graph.input[i].name in inits: + continue + name = os.path.join(test_data_set, f"input_{n_input}.pb") + inputs.append(name) + n_input += 1 + x = onx.graph.input[i] + value = self.generate_dummy_data( + x, seed=0, name=model_test.model_name, random=False + ) + feeds[x.name] = value + with open(name, "wb") as f: + f.write(onnx.numpy_helper.from_array(value).SerializeToString()) + + # loads expected output if any available + prefix = os.path.splitext(model_pb_path)[0] + expected_outputs = [] + for i in range(len(onx.graph.output)): + name = f"{prefix}_output_{i}.pb" + if os.path.exists(name): + expected_outputs.append(name) + continue + expected_outputs = None + break + + if expected_outputs is None: + ref = onnx.reference.ReferenceEvaluator(onx) + outputs = ref.run(None, feeds) + for i, o in enumerate(outputs): + name = os.path.join(test_data_set, f"output_{i}.pb") + with open(name, "wb") as f: + f.write(onnx.numpy_helper.from_array(o).SerializeToString()) + else: + for i, o in enumerate(expected_outputs): + name = os.path.join(test_data_set, f"output_{i}.pb") + shutil.copy(o, name) + else: + # TODO after converting all npz files to protobuf, we can delete this. + for test_data_npz in glob.glob( + os.path.join(model_dir, "test_data_*.npz") + ): + test_data = np.load(test_data_npz, encoding="bytes") + inputs = list(test_data["inputs"]) + outputs = list(prepared_model.run(inputs)) + ref_outputs = test_data["outputs"] + self.assert_similar_outputs( + ref_outputs, outputs, rtol=model_test.rtol, atol=model_test.atol + ) + + for test_data_dir in glob.glob(os.path.join(model_dir, "test_data_set*")): + inputs = [] + inputs_num = len(glob.glob(os.path.join(test_data_dir, "input_*.pb"))) + for i in range(inputs_num): + input_file = os.path.join(test_data_dir, f"input_{i}.pb") + self._load_proto(input_file, inputs, model.graph.input[i].type) + ref_outputs = [] + ref_outputs_num = len( + glob.glob(os.path.join(test_data_dir, "output_*.pb")) + ) + for i in range(ref_outputs_num): + output_file = os.path.join(test_data_dir, f"output_{i}.pb") + self._load_proto( + output_file, ref_outputs, model.graph.output[i].type + ) + outputs = list(prepared_model.run(inputs)) + self.assert_similar_outputs( + ref_outputs, outputs, rtol=model_test.rtol, atol=model_test.atol + ) + + self._add_test(kind + "Model", model_test.name, run, model_marker) + + def _load_proto( + self, + proto_filename: str, + target_list: List[Union[np.ndarray, List[Any]]], + model_type_proto: TypeProto, + ) -> None: + with open(proto_filename, "rb") as f: + protobuf_content = f.read() + if model_type_proto.HasField("sequence_type"): + sequence = onnx.SequenceProto() + sequence.ParseFromString(protobuf_content) + target_list.append(numpy_helper.to_list(sequence)) + elif model_type_proto.HasField("tensor_type"): + tensor = onnx.TensorProto() + tensor.ParseFromString(protobuf_content) + target_list.append(numpy_helper.to_array(tensor)) + elif model_type_proto.HasField("optional_type"): + optional = onnx.OptionalProto() + optional.ParseFromString(protobuf_content) + target_list.append(numpy_helper.to_optional(optional)) # type: ignore[arg-type] + else: + print( + "Loading proto of that specific type (Map/Sparse Tensor) is currently not supported" + ) diff --git a/runtime/Lib/site-packages/onnx/backend/test/runner/item.py b/runtime/Lib/site-packages/onnx/backend/test/runner/item.py new file mode 100644 index 0000000000000000000000000000000000000000..1ec362b2e01176fa29704e17818c0bbb5b8e9b12 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/runner/item.py @@ -0,0 +1,17 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import dataclasses +from typing import Any, Callable, List, Optional, Union + +from onnx import ModelProto, NodeProto + +# A container that hosts the test function and the associated +# test item (ModelProto) + + +@dataclasses.dataclass +class TestItem: + func: Callable[..., Any] + proto: List[Optional[Union[ModelProto, NodeProto]]] diff --git a/runtime/Lib/site-packages/onnx/backend/test/stat_coverage.py b/runtime/Lib/site-packages/onnx/backend/test/stat_coverage.py new file mode 100644 index 0000000000000000000000000000000000000000..5607523e7c5a19bcc97480d2ec9907d377ce33de --- /dev/null +++ b/runtime/Lib/site-packages/onnx/backend/test/stat_coverage.py @@ -0,0 +1,291 @@ +#!/usr/bin/env python + +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import os +from typing import IO, Any, Dict, List, Sequence + +from onnx import AttributeProto, defs, load +from onnx.backend.test.case import collect_snippets +from onnx.backend.test.loader import load_model_tests +from onnx.backend.test.runner import Runner + + +def is_ml(schemas: Sequence[defs.OpSchema]) -> bool: + return any(s.domain == "ai.onnx.ml" for s in schemas) + + +def gen_outlines(f: IO[Any], ml: bool) -> None: + f.write("# Test Coverage Report") + if ml: + f.write(" (ONNX-ML Operators)\n") + else: + f.write(" (ONNX Core Operators)\n") + f.write("## Outlines\n") + f.write("* [Node Test Coverage](#node-test-coverage)\n") + f.write("* [Model Test Coverage](#model-test-coverage)\n") + f.write("* [Overall Test Coverage](#overall-test-coverage)\n") + + +common_covered: Sequence[str] = [] +experimental_covered: Sequence[str] = [] + + +def gen_node_test_coverage( + schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool +) -> None: + global common_covered + global experimental_covered + generators = set( + { + "Multinomial", + "RandomNormal", + "RandomNormalLike", + "RandomUniform", + "RandomUniformLike", + } + ) + node_tests = collect_snippets() + common_covered = sorted( + s.name + for s in schemas + if s.name in node_tests + and s.support_level == defs.OpSchema.SupportType.COMMON + and (s.domain == "ai.onnx.ml") == ml + ) + common_no_cover = sorted( + s.name + for s in schemas + if s.name not in node_tests + and s.support_level == defs.OpSchema.SupportType.COMMON + and (s.domain == "ai.onnx.ml") == ml + ) + common_generator = sorted(name for name in common_no_cover if name in generators) + experimental_covered = sorted( + s.name + for s in schemas + if s.name in node_tests + and s.support_level == defs.OpSchema.SupportType.EXPERIMENTAL + and (s.domain == "ai.onnx.ml") == ml + ) + experimental_no_cover = sorted( + s.name + for s in schemas + if s.name not in node_tests + and s.support_level == defs.OpSchema.SupportType.EXPERIMENTAL + and (s.domain == "ai.onnx.ml") == ml + ) + experimental_generator = sorted( + name for name in experimental_no_cover if name in generators + ) + num_common = len(common_covered) + len(common_no_cover) - len(common_generator) + num_experimental = ( + len(experimental_covered) + + len(experimental_no_cover) + - len(experimental_generator) + ) + f.write("# Node Test Coverage\n") + f.write("## Summary\n") + if num_common: + f.write( + f"Node tests have covered {len(common_covered)}/{num_common} " + f"({len(common_covered) / float(num_common) * 100:.2f}%, {len(common_generator)} " + f"generators excluded) common operators.\n\n" + ) + else: + f.write("Node tests have covered 0/0 (N/A) common operators. \n\n") + if num_experimental: + f.write( + "Node tests have covered {}/{} ({:.2f}%, {} generators excluded) " + "experimental operators.\n\n".format( + len(experimental_covered), + num_experimental, + (len(experimental_covered) / float(num_experimental) * 100), + len(experimental_generator), + ) + ) + else: + f.write("Node tests have covered 0/0 (N/A) experimental operators.\n\n") + titles = [ + "💚Covered Common Operators", + "💔No Cover Common Operators", + "💚Covered Experimental Operators", + "💔No Cover Experimental Operators", + ] + all_lists = [ + common_covered, + common_no_cover, + experimental_covered, + experimental_no_cover, + ] + for t in titles: + f.write(f"* [{t[9:]}](#{t[9:].lower().replace(' ', '-')})\n") + f.write("\n") + for t, l in zip(titles, all_lists): # noqa: E741 + f.write(f"## {t}\n") + for s in l: + f.write(f"### {s}") + if s in node_tests: + f.write( + f"\nThere are {len(node_tests[s])} test cases, listed as following:\n" + ) + for summary, code in sorted(node_tests[s]): + f.write("
\n") + f.write(f"{summary}\n\n") + f.write(f"```python\n{code}\n```\n\n") + f.write("
\n") + else: + if s in generators: + f.write(" (random generator operator)\n") + else: + f.write(" (call for test cases)\n") + f.write("\n\n") + f.write("
\n\n") + + +def gen_model_test_coverage( + schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool +) -> None: + f.write("# Model Test Coverage\n") + # Process schemas + schema_dict = dict() + for schema in schemas: + schema_dict[schema.name] = schema + # Load models from each model test using Runner.prepare_model_data + # Need to grab associated nodes + attrs: Dict[str, Dict[str, List[Any]]] = dict() + model_paths: List[Any] = [] + for rt in load_model_tests(kind="real"): + if rt.url.startswith("onnx/backend/test/data/light/"): + # testing local files + model_name = os.path.normpath( + os.path.join(os.path.dirname(__file__), "..", "..", "..", rt.url) + ) + if not os.path.exists(model_name): + raise FileNotFoundError(f"Unable to find model {model_name!r}.") + model_paths.append(model_name) + else: + model_dir = Runner.prepare_model_data(rt) + model_paths.append(os.path.join(model_dir, "model.onnx")) + model_paths.sort() + model_written = False + for model_pb_path in model_paths: + model = load(model_pb_path) + if ml: + ml_present = False + for opset in model.opset_import: + if opset.domain == "ai.onnx.ml": + ml_present = True + if not ml_present: + continue + else: + model_written = True + f.write(f"## {model.graph.name}\n") + # Deconstruct model + num_covered = 0 + for node in model.graph.node: + if node.op_type in common_covered or node.op_type in experimental_covered: + num_covered += 1 + # Add details of which nodes are/aren't covered + # Iterate through and store each node's attributes + for attr in node.attribute: + if node.op_type not in attrs: + attrs[node.op_type] = dict() + if attr.name not in attrs[node.op_type]: + attrs[node.op_type][attr.name] = [] + if attr.type == AttributeProto.FLOAT: + if attr.f not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.f) + elif attr.type == AttributeProto.INT: + if attr.i not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.i) + elif attr.type == AttributeProto.STRING: + if attr.s not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.s) + elif attr.type == AttributeProto.TENSOR: + if attr.t not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.t) + elif attr.type == AttributeProto.GRAPH: + if attr.g not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.g) + elif attr.type == AttributeProto.FLOATS: + if attr.floats not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.floats) + elif attr.type == AttributeProto.INTS: + if attr.ints not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.ints) + elif attr.type == AttributeProto.STRINGS: + if attr.strings not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.strings) + elif attr.type == AttributeProto.TENSORS: + if attr.tensors not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.tensors) + elif attr.type == AttributeProto.GRAPHS: + if attr.graphs not in attrs[node.op_type][attr.name]: + attrs[node.op_type][attr.name].append(attr.graphs) + f.write( + f"\n{model.graph.name} has {num_covered} nodes. " + f"Of these, {len(model.graph.node)} are covered by node tests " + f"({100.0 * float(num_covered) / float(len(model.graph.node))}%)\n\n\n" + ) + # Iterate through attrs, print + f.write("
\n") + f.write("nodes\n\n") + for op in sorted(attrs): + f.write("
\n") + # Get total number of attributes for node schema + f.write( + f"{op}: {len(attrs[op])} out of {len(schema_dict[op].attributes)} attributes covered\n\n" + ) + for attribute in sorted(schema_dict[op].attributes): + if attribute in attrs[op]: + f.write(f"{attribute}: {len(attrs[op][attribute])}\n") + else: + f.write(f"{attribute}: 0\n") + f.write("
\n") + f.write("
\n\n\n") + if not model_written and ml: + f.write("No model tests present for selected domain\n") + + +def gen_overall_test_coverage( + schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool +) -> None: + f.write("# Overall Test Coverage\n") + f.write("## To be filled.\n") + + +def gen_spdx(f: IO[Any]) -> None: + f.write("\n") + + +def main() -> None: + base_dir = os.path.dirname( + os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) + ) + docs_dir = os.path.join(base_dir, "docs") + schemas = defs.get_all_schemas() + + has_ml = is_ml(schemas) + fname = os.path.join(docs_dir, "TestCoverage.md") + with open(fname, "w+", newline="", encoding="utf-8") as f: # type: ignore + gen_spdx(f) + gen_outlines(f, False) + gen_node_test_coverage(schemas, f, False) + gen_model_test_coverage(schemas, f, False) + gen_overall_test_coverage(schemas, f, False) + + if has_ml: + fname = os.path.join(docs_dir, "TestCoverage-ml.md") + with open(fname, "w+", newline="", encoding="utf-8") as f: # type: ignore + gen_spdx(f) + gen_outlines(f, True) + gen_node_test_coverage(schemas, f, True) + gen_model_test_coverage(schemas, f, True) + gen_overall_test_coverage(schemas, f, True) + + +if __name__ == "__main__": + main() diff --git a/runtime/Lib/site-packages/onnx/bin/__init__.py b/runtime/Lib/site-packages/onnx/bin/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..de8e3a385434d6c541b8b544342983b60f8eb0c3 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/bin/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/runtime/Lib/site-packages/onnx/bin/checker.py b/runtime/Lib/site-packages/onnx/bin/checker.py new file mode 100644 index 0000000000000000000000000000000000000000..b11f283d7c0add199079fbc84bcf4cab127afb4c --- /dev/null +++ b/runtime/Lib/site-packages/onnx/bin/checker.py @@ -0,0 +1,26 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 + +import argparse + +from onnx import NodeProto, checker, load + + +def check_model() -> None: + parser = argparse.ArgumentParser("check-model") + parser.add_argument("model_pb", type=argparse.FileType("rb")) + args = parser.parse_args() + + model = load(args.model_pb) + checker.check_model(model) + + +def check_node() -> None: + parser = argparse.ArgumentParser("check-node") + parser.add_argument("node_pb", type=argparse.FileType("rb")) + args = parser.parse_args() + + node = NodeProto() + node.ParseFromString(args.node_pb.read()) + checker.check_node(node) diff --git a/runtime/Lib/site-packages/onnx/checker.cc b/runtime/Lib/site-packages/onnx/checker.cc new file mode 100644 index 0000000000000000000000000000000000000000..83abc57aebdf50b30d691c4f3c1c2681e31daa47 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/checker.cc @@ -0,0 +1,1066 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#include "onnx/checker.h" +#include "onnx/common/file_utils.h" +#include "onnx/common/path.h" +#include "onnx/defs/schema.h" +#include "onnx/defs/tensor_proto_util.h" +#include "onnx/proto_utils.h" +#include "onnx/shape_inference/implementation.h" +#include "onnx/string_utils.h" + +#include +#include +#include + +#ifdef _WIN32 +#include +#include + +#else // POSIX +#include +#endif + +namespace ONNX_NAMESPACE { +namespace checker { + +#define enforce_has_field(proto, field) \ + do { \ + if (!proto.has_##field()) { \ + fail_check("Field '", #field, "' of '", #proto, "' is required but missing."); \ + } \ + } while (0) + +#define enforce_has_repeated_field(proto, field) \ + do { \ + if (!proto.field##_size()) { \ + fail_check("Repeated Field '", #field, "' of '", #proto, "' is required but missing."); \ + } \ + } while (0) + +#define enforce_non_empty_field(proto, field) \ + do { \ + if (proto.field().empty()) { \ + fail_check("Field '", #field, "' of '", #proto, "' is required to be non-empty."); \ + } \ + } while (0) + +void check_value_info(const ValueInfoProto& value_info, const CheckerContext& ctx) { + enforce_non_empty_field(value_info, name); + // Relax constraint for subgraph input/output. + if (!ctx.is_main_graph()) + return; + enforce_has_field(value_info, type); + const auto value_case = value_info.type().value_case(); + switch (value_case) { + case TypeProto::kTensorType: { + const auto& type = value_info.type().tensor_type(); + enforce_has_field(type, elem_type); + enforce_has_field(type, shape); + } break; + case TypeProto::kOptionalType: { + const auto& type = value_info.type().optional_type(); + enforce_has_field(type, elem_type); + } break; + case TypeProto::kSequenceType: { + const auto& type = value_info.type().sequence_type(); + enforce_has_field(type, elem_type); + } break; + case TypeProto::kMapType: { + const auto& type = value_info.type().map_type(); + enforce_has_field(type, key_type); + enforce_has_field(type, value_type); + } break; +#ifdef ONNX_ML + case TypeProto::kOpaqueType: + break; +#endif + case TypeProto::kSparseTensorType: { + const auto& type = value_info.type().sparse_tensor_type(); + enforce_has_field(type, elem_type); + enforce_has_field(type, shape); + } break; + + default: + fail_check("Unrecognized type value case (value_info name: ", value_info.name(), "): ", value_case); + } +} + +void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) { + enforce_has_field(tensor, data_type); + if (tensor.data_type() == TensorProto::UNDEFINED) { + fail_check("setting data_type field (tensor name: ", tensor.name(), ") to UNDEFINED is not allowed"); + } + + int num_value_fields = 0; + + const char* value_field = nullptr; + +#define check_data_field(field) \ + bool has_##field = tensor.field().size(); \ + if (has_##field) { \ + ++num_value_fields; \ + value_field = #field; \ + } + + check_data_field(float_data); + check_data_field(int32_data); + check_data_field(string_data); + check_data_field(int64_data); + check_data_field(raw_data); + check_data_field(double_data); + check_data_field(uint64_data); + +#undef check_data_field + + bool stored_externally = tensor.has_data_location() && tensor.data_location() == TensorProto::EXTERNAL; + if (stored_externally) { + if (num_value_fields != 0) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor.name(), + ") is stored externally and should not have data field.", + value_field); + } + + bool has_location = false; + for (const StringStringEntryProto& entry : tensor.external_data()) { + if (entry.has_key() && entry.has_value() && entry.key() == "location") { + has_location = true; +#ifdef _WIN32 + auto file_path = std::filesystem::path(utf8str_to_wstring(entry.value())); + if (file_path.is_absolute()) { + fail_check( + "Location of external TensorProto ( tensor name: ", + tensor.name(), + ") should be a relative path, but it is an absolute path: ", + entry.value()); + } + auto relative_path = file_path.lexically_normal().make_preferred().wstring(); + // Check that normalized relative path contains ".." on Windows. + if (relative_path.find(L"..", 0) != std::string::npos) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor.name(), + ") should be file inside the ", + ctx.get_model_dir(), + ", but the '", + entry.value(), + "' points outside the directory"); + } + std::wstring data_path = path_join(utf8str_to_wstring(ctx.get_model_dir()), relative_path); + struct _stat buff; + if (_wstat(data_path.c_str(), &buff) != 0) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor.name(), + ") should be stored in ", + entry.value(), + ", but it doesn't exist or is not accessible."); + } +#else // POSIX + if (entry.value().empty()) { + fail_check("Location of external TensorProto ( tensor name: ", tensor.name(), ") should not be empty."); + } else if (entry.value()[0] == '/') { + fail_check( + "Location of external TensorProto ( tensor name: ", + tensor.name(), + ") should be a relative path, but it is an absolute path: ", + entry.value()); + } + std::string relative_path = clean_relative_path(entry.value()); + // Check that normalized relative path contains ".." on POSIX + if (relative_path.find("..", 0) != std::string::npos) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor.name(), + ") should be file inside the ", + ctx.get_model_dir(), + ", but the '", + entry.value(), + "' points outside the directory"); + } + std::string data_path = path_join(ctx.get_model_dir(), relative_path); + // use stat to check whether the file exists + struct stat buffer; + if (stat((data_path).c_str(), &buffer) != 0) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor.name(), + ") should be stored in ", + data_path, + ", but it doesn't exist or is not accessible."); + } + // Do not allow symlinks or directories. + if (!S_ISREG(buffer.st_mode)) { + fail_check( + "Data of TensorProto ( tensor name: ", + tensor.name(), + ") should be stored in ", + data_path, + ", but it is not regular file."); + } +#endif + } + } + if (!has_location) { + fail_check("TensorProto ( tensor name: ", tensor.name(), ") is stored externally but doesn't have a location."); + } + return; + } + int64_t nelem = 1; + for (auto x : tensor.dims()) { + nelem *= x; + } + if (nelem == 0 && num_value_fields != 0) { + fail_check("TensorProto (tensor name: ", tensor.name(), ") is 0-element but contains data!"); + } + if (nelem != 0 && num_value_fields != 1) { + fail_check("TensorProto (tensor name: ", tensor.name(), ") should contain one and only one value field."); + } + if (has_raw_data) { + if (tensor.data_type() == TensorProto::STRING) { + fail_check("STRING data (tensor name: ", tensor.name(), ") should not be stored in raw_data field"); + } + return; + } else { +#define check_field(field) \ + if (nelem != 0 && !has_##field) { \ + fail_check( \ + "values of data_type '", \ + tensor.data_type(), \ + "' should be stored in field '", \ + #field, \ + "' instead of '", \ + value_field, \ + "'"); \ + } + + switch (tensor.data_type()) { + case TensorProto::FLOAT: + case TensorProto::COMPLEX64: + check_field(float_data); + break; + + case TensorProto::DOUBLE: + case TensorProto::COMPLEX128: + check_field(double_data); + break; + + case TensorProto::INT32: + case TensorProto::UINT8: + case TensorProto::INT8: + case TensorProto::UINT16: + case TensorProto::INT16: + case TensorProto::BOOL: + case TensorProto::FLOAT16: + case TensorProto::BFLOAT16: + case TensorProto::FLOAT8E4M3FN: + case TensorProto::FLOAT8E4M3FNUZ: + case TensorProto::FLOAT8E5M2: + case TensorProto::FLOAT8E5M2FNUZ: + check_field(int32_data); + break; + + case TensorProto::INT64: + check_field(int64_data); + break; + + case TensorProto::UINT32: + case TensorProto::UINT64: + check_field(uint64_data); + break; + + case TensorProto::STRING: + check_field(string_data); + break; + + default: + fail_check("Unrecognized data_type (tensor name: ", tensor.name(), "): ", tensor.data_type()); + } + } + +#undef check_field +} + +void check_sequence(const SequenceProto& sequence, const CheckerContext& ctx) { + enforce_has_field(sequence, elem_type); + if (sequence.elem_type() == SequenceProto::TENSOR) { + for (const TensorProto& tensor : sequence.tensor_values()) { + check_tensor(tensor, ctx); + } + } else if (sequence.elem_type() == SequenceProto::SPARSE_TENSOR) { + for (const SparseTensorProto& sparse_tensor : sequence.sparse_tensor_values()) { + check_sparse_tensor(sparse_tensor, ctx); + } + } else if (sequence.elem_type() == SequenceProto::SEQUENCE) { + for (const SequenceProto& seq : sequence.sequence_values()) { + check_sequence(seq, ctx); + } + } else if (sequence.elem_type() == SequenceProto::MAP) { + for (const MapProto& map : sequence.map_values()) { + check_map(map, ctx); + } + } else { + fail_check( + "Sequence ( Structure name: ", + sequence.name(), + ", elem_type: ", + sequence.elem_type(), + ") is not have a valid element type."); + } +} + +void check_optional(const OptionalProto& optional, const CheckerContext& ctx) { + enforce_has_field(optional, elem_type); + if (optional.elem_type() == OptionalProto::UNDEFINED) { + return; + } else if (optional.elem_type() == OptionalProto::TENSOR) { + if (optional.has_tensor_value()) + check_tensor(optional.tensor_value(), ctx); + } else if (optional.elem_type() == OptionalProto::SPARSE_TENSOR) { + if (optional.has_sparse_tensor_value()) + check_sparse_tensor(optional.sparse_tensor_value(), ctx); + } else if (optional.elem_type() == OptionalProto::SEQUENCE) { + if (optional.has_sequence_value()) + check_sequence(optional.sequence_value(), ctx); + } else if (optional.elem_type() == OptionalProto::MAP) { + if (optional.has_map_value()) + check_map(optional.map_value(), ctx); + } else { + fail_check( + "Optional ( Structure name: ", + optional.name(), + ", elem_type: ", + optional.elem_type(), + ") is not have a valid element type."); + } +} + +void check_map(const MapProto& map, const CheckerContext& ctx) { + enforce_has_field(map, key_type); + if (map.key_type() == TensorProto::UNDEFINED) { + fail_check("setting key_type field (map name: ", map.name(), ") to UNDEFINED is not allowed"); + } + // Check if key is a valid type, specifically INT8, INT16, INT32, INT64, + // UINT8, UINT16, UINT32, UINT64, or STRING. + if ((map.key_type() == TensorProto::FLOAT) || (map.key_type() == TensorProto::BOOL) || + (map.key_type() == TensorProto::FLOAT16) || (map.key_type() == TensorProto::COMPLEX64) || + (map.key_type() == TensorProto::COMPLEX128)) { + fail_check( + "setting key_type field (map name: ", + map.name(), + ") to invalid TensorProto key_type ", + map.key_type(), + " is not allowed"); + } + + // MapProto will use either keys or string_keys, so only one should be > 0. + if ((map.keys_size() > 0) && (map.string_keys_size() > 0)) { + fail_check("Map (name: ", map.name(), ") should not contain more than one keys field."); + } + + int num_keys = map.keys_size() + map.string_keys_size(); + int num_values = 0; + + enforce_has_field(map, values); + check_sequence(map.values(), ctx); + + if (map.values().elem_type() == SequenceProto::TENSOR) { + num_values = map.values().tensor_values_size(); + } else if (map.values().elem_type() == SequenceProto::SPARSE_TENSOR) { + num_values = map.values().sparse_tensor_values_size(); + } else if (map.values().elem_type() == SequenceProto::SEQUENCE) { + num_values = map.values().sequence_values_size(); + } else if (map.values().elem_type() == SequenceProto::MAP) { + num_values = map.values().map_values_size(); + } + + if (num_keys != num_values) { + fail_check("Length of map keys and map values are not the same (map name: ", map.name(), ")"); + } +} + +// Check that the index data stored in a SparseTensorProto is valid. +// indices: a 1-dimensional tensor; indices[i] represents the +// linearized index value for the i-th nonzero value. +void check_sparse_tensor_indices_1( + const TensorProto& indices, + const SparseTensorProto& sparse_tensor_proto, + size_t nnz) { + int dense_rank = sparse_tensor_proto.dims_size(); + int64_t dense_size = 1; + for (int i = 0; i < dense_rank; ++i) + dense_size *= sparse_tensor_proto.dims(i); + if (static_cast(indices.dims(0)) != nnz) { + fail_check("Sparse tensor indices (", indices.name(), ") has ", indices.dims(0), " values, but NNZ is ", nnz); + } + + // Check if indices appear in ascending order, and if they have valid + // values. The i-th value in index_data is the linear index of the i-th + // non-zero value. + const std::vector index_data = ParseData(&indices); + + int64_t prev_index = -1; + for (size_t i = 0; i < nnz; ++i) { + int64_t curr_index = index_data[i]; // linearized index of i-th value + if (curr_index < 0 || curr_index >= dense_size) { + fail_check( + "Sparse tensor (", + indices.name(), + ") index value at position [", + i, + "] out of range [0, ", + dense_size - 1, + "]"); + } + if (curr_index <= prev_index) { + fail_check("Sparse tensor (", indices.name(), ") index value at position [", i, "] not in sorted order."); + } + prev_index = curr_index; + } +} + +// Check that the index data stored in a SparseTensorProto is valid. +// indices: a 2-dimensional tensor; indices[i,j] represents the j-th +// index value for the i-th nonzero value. +void check_sparse_tensor_indices_2( + const TensorProto& indices, + const SparseTensorProto& sparse_tensor_proto, + size_t nnz) { + int dense_rank = sparse_tensor_proto.dims_size(); + if (static_cast(indices.dims(0)) != nnz) { + fail_check("Sparse tensor indices (", indices.name(), ") first dimension size does not equal NNZ."); + } + if (indices.dims(1) != dense_rank) { + fail_check("Sparse tensor indices (", indices.name(), ") second dimension size does not match rank of tensor."); + } + + // Check if indices appear in ascending order, and if they have valid + // values. + const std::vector index_data = ParseData(&indices); + int64_t prev_index = -1; + for (size_t i = 0; i < nnz; ++i) { + int64_t curr_index = 0; // linearized index of i-th value + for (int j = 0; j < dense_rank; ++j) { + auto index_ij = index_data[i * dense_rank + j]; + if ((index_ij < 0) || (index_ij >= sparse_tensor_proto.dims(j))) { + fail_check("Sparse tensor (", indices.name(), ") index value at position [", i, ",", j, "] out of range."); + } + curr_index = curr_index * sparse_tensor_proto.dims(j) + index_ij; + } + if (curr_index <= prev_index) { + fail_check( + "Sparse tensor (", indices.name(), ") index value at position [", i, "] not in lexicographic sorted order."); + } + prev_index = curr_index; + } +} + +void check_sparse_tensor(const SparseTensorProto& sparse_tensor_proto, const CheckerContext& ctx) { + enforce_has_field(sparse_tensor_proto, values); + + const TensorProto& values = sparse_tensor_proto.values(); + check_tensor(values, ctx); + + // values must be a tensor of shape [NNZ] + // Currently we restrict the value associated with a particular index-tuple + // to be a single value. In the future, if there is a requirement, + // we may extend this to permit the value to be a "sub-tensor", in which + // case values will have dimension > 1. + if (values.dims_size() != 1) { + fail_check("Sparse tensor values (", values.name(), ") must have rank 1."); + } + size_t nnz = static_cast(values.dims(0)); + int dense_rank = sparse_tensor_proto.dims_size(); + if (dense_rank == 0) { + fail_check("Sparse tensor (", values.name(), ") must have a dense-rank > 0"); + } + for (int i = 0; i < dense_rank; ++i) { + if (sparse_tensor_proto.dims(i) <= 0) { + fail_check("Sparse tensor (", values.name(), ") dimensions are not positive."); + } + } + + if (sparse_tensor_proto.has_indices()) { + const TensorProto& indices = sparse_tensor_proto.indices(); + check_tensor(indices, ctx); + if (indices.data_type() != TensorProto::INT64) { + fail_check("Sparse tensor indices (", indices.name(), ") must have INT64 type."); + } + switch (indices.dims().size()) { + case 1: + // Indices in linearized format + check_sparse_tensor_indices_1(indices, sparse_tensor_proto, nnz); + return; + case 2: + // Check COO-style index. E.g., an index for a 3D tensor is a 3-tuple. + check_sparse_tensor_indices_2(indices, sparse_tensor_proto, nnz); + return; + default: + fail_check("Sparse tensor indices (", indices.name(), ") must have rank 1 or 2."); + } + } else if (nnz != 0) { + fail_check("Sparse tensor (", values.name(), ") has no index values."); + } +} + +// NB: This is a generic "attribute well-formedness" check, it doesn't +// actually test if an attribute is valid per a schema +void check_attribute(const AttributeProto& attr, const CheckerContext& ctx, const LexicalScopeContext& lex_ctx) { + enforce_non_empty_field(attr, name); + + if (ctx.get_ir_version() >= 0x00000002) { + enforce_has_field(attr, type); + } + + int used_fields = 0; + +#define check_type(expected_type) \ + if (attr.has_type() && attr.type() != expected_type) { \ + fail_check("type field and data field mismatch in attribute ", attr.name(), "."); \ + } + +#define check_singular_field(field, type) \ + if (attr.has_##field()) { \ + ++used_fields; \ + check_type(type); \ + } + +#define check_repeated_field(field, type) \ + if (attr.field##_size() > 0) { \ + ++used_fields; \ + check_type(type); \ + } + + check_singular_field(f, AttributeProto::FLOAT); + check_singular_field(i, AttributeProto::INT); + check_singular_field(s, AttributeProto::STRING); + check_singular_field(t, AttributeProto::TENSOR); + check_singular_field(g, AttributeProto::GRAPH); + check_singular_field(tp, AttributeProto::TYPE_PROTO); + check_singular_field(sparse_tensor, AttributeProto::SPARSE_TENSOR); + check_repeated_field(floats, AttributeProto::FLOATS); + check_repeated_field(ints, AttributeProto::INTS); + check_repeated_field(strings, AttributeProto::STRINGS); + check_repeated_field(tensors, AttributeProto::TENSORS); + check_repeated_field(graphs, AttributeProto::GRAPHS); + check_repeated_field(sparse_tensors, AttributeProto::SPARSE_TENSORS); + check_repeated_field(type_protos, AttributeProto::TYPE_PROTOS); + +#undef check_type +#undef check_singular_field +#undef check_repeated_field + + // Normally, used_fields is expected to be 1. + // In proto3, when the value to be set is type default value (say 0 for + // int), used_fields may be 0. + if (used_fields > 1) { + fail_check("Attribute (name: ", attr.name(), ") should not contain more than one value field."); + } + + if (!ctx.is_main_graph()) { + // It's an attribute of a node in function body. + if (attr.has_ref_attr_name() && used_fields != 0) { + // The attribute proto is supposed to refer to data outside and does not + // have its own value field set. + fail_check("Attribute (name: ", attr.name(), ") should refer to attribute in parent node."); + } + } + + if (attr.has_t()) { + check_tensor(attr.t(), ctx); + } + + if (attr.has_sparse_tensor()) { + check_sparse_tensor(attr.sparse_tensor(), ctx); + } + + if (attr.has_g()) { + CheckerContext subgraph_ctx(ctx); + subgraph_ctx.set_is_main_graph(false); + check_graph(attr.g(), subgraph_ctx, lex_ctx); + } + + for (const auto& tensor : attr.tensors()) { + check_tensor(tensor, ctx); + } + for (const auto& sparse_tensor : attr.sparse_tensors()) { + check_sparse_tensor(sparse_tensor, ctx); + } + if (attr.graphs().size() > 0) { + CheckerContext subgraph_ctx(ctx); + subgraph_ctx.set_is_main_graph(false); + for (const auto& graph : attr.graphs()) { + check_graph(graph, subgraph_ctx, lex_ctx); + } + } +} + +void print_warning_if_has_experimental(const std::unordered_set& used_experimental_ops) { + if (!used_experimental_ops.empty()) { + std::string all_experimental_ops; + for (const auto& op : used_experimental_ops) { + all_experimental_ops += " " + op + ","; + } + // Remove the last comma which is unnecessary + all_experimental_ops.pop_back(); + std::cout << "Warning: Model contains experimental ops:" + all_experimental_ops << std::endl; + } +} + +void check_node(const NodeProto& node, const CheckerContext& ctx, const LexicalScopeContext& lex_ctx) { + enforce_non_empty_field(node, op_type); + + if (node.input().empty() && node.output().empty()) { + fail_check("NodeProto (name: ", node.name(), ", type: ", node.op_type(), ") has zero input and zero output."); + } + + // Resolve domain for node + const auto& opset_imports = ctx.get_opset_imports(); + auto dit = opset_imports.find(node.domain()); + if (dit == opset_imports.end()) { + fail_check("No opset import for domain '" + node.domain() + "'"); + } + auto domain_version = dit->second; + + // for ops referencing local functions, there is no schema to verify it. + // will add a check to verify consistency between these ops and local functions. + std::unordered_set seen_attr_names{}; + for (const auto& attr : node.attribute()) { + if (!seen_attr_names.insert(attr.name()).second) { + fail_check("Attribute '", attr.name(), "' appeared multiple times."); + }; + + check_attribute(attr, ctx, lex_ctx); + } + + // This issue will be caught by check_graph instead + if (check_is_experimental_op(node)) { + return; + } + + const auto* schema = ctx.get_schema_registry()->GetSchema(node.op_type(), domain_version, node.domain()); + if (!schema) { + if (node.domain() == ONNX_DOMAIN || node.domain() == AI_ONNX_ML_DOMAIN || node.domain() == "ai.onnx" || + node.domain() == AI_ONNX_TRAINING_DOMAIN) { + // fail the checker if op in built-in domains has no schema + fail_check( + "No Op registered for " + node.op_type() + " with domain_version of " + + ONNX_NAMESPACE::to_string(domain_version)); + } else { + // TODO: expose the registration of the op schemas appropriately in + // python, so we can load and register operators in other domains + // + // before we complete the above todo, let's skip the schema check for + // now + } + } else if (schema->Deprecated()) { + fail_check( + "Op registered for " + node.op_type() + " is deprecated in domain_version of " + + ONNX_NAMESPACE::to_string(domain_version)); + } else { + schema->Verify(node); + } +} + +void check_graph(const GraphProto& graph, const CheckerContext& ctx, const LexicalScopeContext& parent_lex) { + enforce_non_empty_field(graph, name); + + for (const auto& value_info : graph.input()) { + check_value_info(value_info, ctx); + } + for (const auto& value_info : graph.output()) { + check_value_info(value_info, ctx); + } + + // Inherit values available in outer scope + // Note that we do not allow shadowing, so the presence of an already-defined + // name is always an error. + LexicalScopeContext lex_ctx{parent_lex}; + + for (const auto& value_info : graph.input()) { + // TODO: If shadowing isn't allowed, this should maybe use + // this_or_ancestor_graph_has + if (lex_ctx.this_graph_has(value_info.name())) { + fail_check( + "Graph must be in single static assignment (SSA) form, however '", + value_info.name(), + "' has been used as graph input names multiple times."); + } + lex_ctx.add(value_info.name()); + } + + std::unordered_set, std::hash, std::equal_to> + initializer_name_checker; + + for (const auto& init : graph.initializer()) { + enforce_has_field(init, name); + const auto& name = init.name(); + if (name.empty()) { + fail_check("Tensor initializers must have a non-empty name"); + } + + if (!initializer_name_checker.insert(std::cref(name)).second) { + fail_check(name + " initializer name is not unique"); + } + + check_tensor(init, ctx); + + if (ctx.get_ir_version() <= 0x00000003) { + // Initializers are a subset of graph inputs for IR_VERSION <= 3 + if (!lex_ctx.this_graph_has(name)) { + fail_check(name + " in initializer but not in graph input"); + } + } else { + // An initializer is allowed to have the same name as an input, + // but is not required to (for IR_VERSION >= 4) + lex_ctx.add(name); + } + } + + for (const auto& sparse_init : graph.sparse_initializer()) { + const auto& values = sparse_init.values(); + enforce_has_field(values, name); + const auto& name = values.name(); + if (name.empty()) { + fail_check("Sparse tensor initializers must have a non-empty name"); + } + if (!initializer_name_checker.insert(std::cref(name)).second) { + fail_check(name + " sparse initializer name is not unique across initializers and sparse_initializers"); + } + check_sparse_tensor(sparse_init, ctx); + lex_ctx.add(name); + } + std::unordered_set used_experimental_ops; + for (const auto& node : graph.node()) { + // nodes must be in topologically sorted order + for (const auto& input : node.input()) { + // explicit optional input + if (input.empty()) { + continue; + } + if (!lex_ctx.this_or_ancestor_graph_has(input)) { + fail_check( + "Nodes in a graph must be topologically sorted, however input '", + input, + "' of node: \n", + "name: ", + node.name(), + " OpType: ", + node.op_type(), + "\n is not output of any previous nodes."); + } + } + + if (check_is_experimental_op(node)) { + used_experimental_ops.insert(node.op_type()); + } + + // This needs to happen before SSA check since we don't want to recurse and + // find that outputs from control flow ops are colliding with names in the + // inner block + + ONNX_TRY { + check_node(node, ctx, lex_ctx); + } + ONNX_CATCH(ValidationError & ex) { + ONNX_HANDLE_EXCEPTION([&]() { + ex.AppendContext("Bad node spec for node. Name: " + node.name() + " OpType: " + node.op_type()); + ONNX_THROW_EX(ex); + }); + } + // check for SSA form + for (const auto& output : node.output()) { + // optional output + if (output.empty()) { + continue; + } + + if (lex_ctx.this_or_ancestor_graph_has(output)) { + fail_check( + "Graph must be in single static assignment (SSA) form, however '", + output, + "' has been used as output names multiple times."); + } + lex_ctx.add(output); + } + } + print_warning_if_has_experimental(used_experimental_ops); +} + +// Utilify function to get the imported version of domain from opset imports +// Returns -1 if requested domain is not found in the opset_imports +int get_version_for_domain(const std::string& domain, const std::unordered_map& opset_imports) { + auto it = opset_imports.find(domain); + if (it == opset_imports.end()) { + return -1; + } + + return it->second; +} + +void check_opset_compatibility( + const NodeProto& node, + const CheckerContext& ctx, + const std::unordered_map& func_opset_imports, + const std::unordered_map& model_opset_imports) { + auto func_opset_version = get_version_for_domain(node.domain(), func_opset_imports); + auto model_opset_version = get_version_for_domain(node.domain(), model_opset_imports); + + if (func_opset_version == -1) { + fail_check("No Opset registered for domain " + node.domain()); + } + + if (model_opset_version == -1) { + // model does not include opset import for a node present in function body. + // This is ok as along as the opset import is present in function level opset imports. + return; + } + + if (func_opset_version == model_opset_version) { + // both versions are same, no need to verify schema. + return; + } + + const auto* schema_for_model_import = + ctx.get_schema_registry()->GetSchema(node.op_type(), model_opset_version, node.domain()); + + const auto* schema_for_function_import = + ctx.get_schema_registry()->GetSchema(node.op_type(), func_opset_version, node.domain()); + + if (!schema_for_model_import && !schema_for_function_import) { + // the op belongs to a custom domain so we cannot verify schema + return; + } + + // if schema is present for 1 but not other or the schema since versions do not match then raise an error + if (!schema_for_model_import || !schema_for_function_import || + schema_for_function_import->since_version() != schema_for_model_import->since_version()) { + fail_check( + "Opset import for domain " + node.domain() + " in function op " + node.op_type() + + "is not compatible with the version imported by model. FunctionOp imports version " + + ONNX_NAMESPACE::to_string(func_opset_version) + " whereas model imports version " + + ONNX_NAMESPACE::to_string(model_opset_version)); + } +} + +void check_model_local_functions( + const ModelProto& model, + const CheckerContext& ctx, + const LexicalScopeContext& parent_lex) { + // make a copy of model opset imports to maintain a main copy of opset imports across the model and + // all model local functions to verify opset compatibility + std::unordered_map model_opset_imports(ctx.get_opset_imports()); + + // merge the opset imports from every function in model_opset_imports + // only add the opset import if an entry for it does not exist in model_opset_imports + // if there is an entry then the compatibility will be checked later on in check_opset_compatibility + // called by check_function. + for (const auto& function_proto : model.functions()) { + for (const auto& opset_import : function_proto.opset_import()) { + if (get_version_for_domain(opset_import.domain(), model_opset_imports) == -1) { + model_opset_imports[opset_import.domain()] = opset_import.version(); + } + } + } + + CheckerContext ctx_copy = ctx; + ctx_copy.set_opset_imports(model_opset_imports); + + for (const auto& function_proto : model.functions()) { + check_function(function_proto, ctx_copy, parent_lex); + } +} + +void check_function(const FunctionProto& function, const CheckerContext& ctx, const LexicalScopeContext& parent_lex) { + enforce_non_empty_field(function, name); + + if (ctx.get_ir_version() >= 0x00000008) { + enforce_has_field(function, domain); + } + + const auto& model_opset_imports = ctx.get_opset_imports(); + CheckerContext ctx_copy = ctx; + + std::unordered_map func_opset_imports; + for (auto& relied_opset : function.opset_import()) { + func_opset_imports[relied_opset.domain()] = static_cast(relied_opset.version()); + } + + ctx_copy.set_opset_imports(func_opset_imports); + + LexicalScopeContext lex_ctx{parent_lex}; + + for (const auto& input : function.input()) { + // TODO: If shadowing isn't allowed, this should maybe use + // this_or_ancestor_graph_has + if (lex_ctx.this_graph_has(input)) { + fail_check( + "Graph must be in single static assignment (SSA) form, however '", input, "' has been used multiple times."); + } + lex_ctx.add(input); + } + + std::unordered_set outputs; + for (const auto& output : function.output()) { + auto result = outputs.insert(output); + if (!result.second) { + fail_check("function (", function.name(), ") should not have duplicate outputs specified."); + } + } + + std::unordered_set attrs; + for (const auto& attr : function.attribute()) { + auto result = attrs.insert(attr); + if (!result.second) { + fail_check("function (", function.name(), ") should not have duplicate attributes specified."); + } + } + std::unordered_set used_experimental_ops; + for (const auto& node : function.node()) { + // nodes must be in topologically sorted order + for (const auto& input : node.input()) { + // explicit optional input + if (input.empty()) { + continue; + } + if (!lex_ctx.this_graph_has(input)) { + fail_check( + "Nodes in a function must be topologically sorted, however input '", + input, + "' of node: \n", + "Name: ", + node.name(), + " OpType: ", + node.op_type(), + "\n is neither output of any previous nodes nor input of the function."); + } + } + + // check whether the opset version imported for a domain by function and model are + // compatible + check_opset_compatibility(node, ctx_copy, func_opset_imports, model_opset_imports); + if (check_is_experimental_op(node)) { + used_experimental_ops.insert(node.op_type()); + } + check_node(node, ctx_copy, lex_ctx); + + // check for SSA form + for (const auto& output : node.output()) { + // optional output + if (output.empty()) { + continue; + } + if (lex_ctx.this_or_ancestor_graph_has(output)) { + fail_check( + "Function must be in single static assignment (SSA) form, however '", + output, + "' has been used as output names multiple times."); + } + lex_ctx.add(output); + } + } + print_warning_if_has_experimental(used_experimental_ops); +} + +void check_model(const ModelProto& model, CheckerContext& ctx) { + if (!model.ir_version()) { + fail_check("The model does not have an ir_version set properly."); + } + if (model.ir_version() > IR_VERSION) { + fail_check("Your model ir_version ", model.ir_version(), " is higher than the checker's (", IR_VERSION, ")."); + } + if (model.metadata_props_size() > 1) { + std::unordered_set keys; + for (const StringStringEntryProto& entry : model.metadata_props()) { + auto i = keys.insert(entry.key()); + if (!i.second) { + fail_check("Your model has duplicate keys in metadata_props."); + } + } + } + std::unordered_map versions; + ctx.set_ir_version(static_cast(model.ir_version())); + std::unordered_map opset_imports; + for (const auto& opset_import : model.opset_import()) { + opset_imports[opset_import.domain()] = static_cast(opset_import.version()); + } + if (model.ir_version() >= 3) { + if (opset_imports.empty()) { + fail_check("model with IR version >= 3 must specify opset_import for ONNX"); + } + } else { + if (opset_imports.empty()) + opset_imports[ONNX_DOMAIN] = 1; + else { + fail_check("model with IR version < 3 cannot have opset_import specified"); + } + } + ctx.set_opset_imports(opset_imports); + LexicalScopeContext lex_ctx; + check_graph(model.graph(), ctx, lex_ctx); + + if (ctx.get_ir_version() >= 0x00000008) { + check_model_local_functions(model, ctx, lex_ctx); + // TODO: check consistency between local functions and ops referencing it. + } +} + +void check_model(const std::string& model_path, bool full_check) { + ModelProto model; + LoadProtoFromPath(model_path, model); + + CheckerContext ctx; + std::string model_dir; + size_t pos = model_path.find_last_of("\\/"); + if (pos != std::string::npos) { + model_dir = model_path.substr(0, pos + 1); + } + ctx.set_model_dir(model_dir); + check_model(model, ctx); + + if (full_check) { + ShapeInferenceOptions options{true, 1, false}; + ONNX_NAMESPACE::shape_inference::InferShapes(model, ctx.get_schema_registry(), options); + } +} + +void check_model(const ModelProto& model, bool full_check) { + CheckerContext ctx; + check_model(model, ctx); + if (full_check) { + ShapeInferenceOptions options{true, 1, false}; + // Do not update the model in place by the check from shape inference + // because checker should not modify the original model + ModelProto copy = model; + ONNX_NAMESPACE::shape_inference::InferShapes(copy, ctx.get_schema_registry(), options); + } +} + +std::set experimental_ops = { + "ATen", + "Affine", + "ConstantFill", + "Crop", + "DynamicSlice", + "GRUUnit", + "GivenTensorFill", + "ImageScaler", + "ParametricSoftplus", + "Scale", + "ScaledTanh"}; + +bool check_is_experimental_op(const NodeProto& node) { + return (node.domain() == ONNX_DOMAIN || node.domain() == "ai.onnx") && experimental_ops.count(node.op_type()); +} + +#undef fail_check +#undef enforce_has_field +#undef enforce_has_repeated_field +#undef enforce_non_empty_field + +} // namespace checker +} // namespace ONNX_NAMESPACE diff --git a/runtime/Lib/site-packages/onnx/checker.h b/runtime/Lib/site-packages/onnx/checker.h new file mode 100644 index 0000000000000000000000000000000000000000..d7da6d545e884af8bec1b9728f3b1a3a6c64b340 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/checker.h @@ -0,0 +1,155 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include +#include "onnx/defs/function.h" +#include "onnx/defs/schema.h" +#include "onnx/onnx-data_pb.h" +#include "onnx/onnx-operators_pb.h" +#include "onnx/onnx_pb.h" +#include "onnx/string_utils.h" + +namespace ONNX_NAMESPACE { +namespace checker { +class ValidationError final : public std::runtime_error { + public: + using std::runtime_error::runtime_error; + const char* what() const noexcept override { + if (!expanded_message_.empty()) { + return expanded_message_.c_str(); + } + return std::runtime_error::what(); + } + void AppendContext(const std::string& context) { + expanded_message_ = ONNX_NAMESPACE::MakeString(std::runtime_error::what(), "\n\n==> Context: ", context); + } + + private: + std::string expanded_message_; +}; + +#define fail_check(...) \ + ONNX_THROW_EX(ONNX_NAMESPACE::checker::ValidationError(ONNX_NAMESPACE::MakeString(__VA_ARGS__))); + +class CheckerContext final { + public: + int get_ir_version() const { + return ir_version_; + } + void set_ir_version(int v) { + ir_version_ = v; + } + const std::unordered_map& get_opset_imports() const { + return opset_imports_; + } + void set_opset_imports(std::unordered_map imps) { + opset_imports_ = std::move(imps); + } + bool is_main_graph() const { + return is_main_graph_; + } + void set_is_main_graph(bool is_main_graph) { + is_main_graph_ = is_main_graph; + } + + void set_schema_registry(const ISchemaRegistry* schema_registry) { + schema_registry_ = schema_registry; + } + + const ISchemaRegistry* get_schema_registry() const { + return schema_registry_; + } + + void set_model_dir(const std::string& model_dir) { + model_dir_ = model_dir; + } + + std::string get_model_dir() const { + return model_dir_; + } + + explicit CheckerContext() : ir_version_(-1) {} + + private: + int ir_version_; + std::unordered_map opset_imports_; + bool is_main_graph_ = true; + const ISchemaRegistry* schema_registry_ = OpSchemaRegistry::Instance(); + std::string model_dir_; +}; + +class LexicalScopeContext final { + public: + LexicalScopeContext() = default; + + // Construct an instance with the lexical scope from the parent graph to allow + // lookup of names from that scope via this_or_ancestor_graph_has. + // The caller must ensure parent_context remains valid for the entire lifetime + // of the new instance. Alternatively, if that cannot be guaranteed, create an + // instance with the default constructor and populate output_names with the + // values from the parent scope so the values are copied instead. + LexicalScopeContext(const LexicalScopeContext& parent_context) : parent_context_{&parent_context} {} + LexicalScopeContext& operator=(const LexicalScopeContext& parent_context) { + parent_context_ = &parent_context; + return *this; + } + + void add(const std::string& name) { + output_names.insert(name); + } + + bool this_graph_has(const std::string& name) const { + return output_names.find(name) != output_names.cend(); + } + + bool this_or_ancestor_graph_has(const std::string& name) const { + return this_graph_has(name) || (parent_context_ && parent_context_->this_or_ancestor_graph_has(name)); + } + + // public for backwards compatibility. please prefer the public interface of + // this class over directly changing output_names + std::unordered_set output_names; + + private: + const LexicalScopeContext* parent_context_{nullptr}; +}; + +using IR_VERSION_TYPE = decltype(Version::IR_VERSION); +void check_value_info(const ValueInfoProto& value_info, const CheckerContext&); +void check_tensor(const TensorProto& tensor, const CheckerContext&); +void check_sparse_tensor(const SparseTensorProto& sparse_tensor, const CheckerContext&); +void check_sequence(const SequenceProto& sequence, const CheckerContext&); +void check_map(const MapProto& map, const CheckerContext&); +void check_optional(const OptionalProto& opt, const CheckerContext&); +void check_attribute(const AttributeProto& attr, const CheckerContext&, const LexicalScopeContext&); +void check_node(const NodeProto& node, const CheckerContext&, const LexicalScopeContext&); +void check_graph(const GraphProto& graph, const CheckerContext&, const LexicalScopeContext&); +void check_function(const FunctionProto& function, const CheckerContext&, const LexicalScopeContext&); + +// Check schema compatibility for 2 opset versions for a given node. +// Checks whether the schema for 2 versions is same, this is true when the opschema +// does not change between versions. +void check_opset_compatibility( + const NodeProto& node, + const CheckerContext& ctx, + const std::unordered_map& func_opset_imports, + const std::unordered_map& model_opset_imports); + +// Checks all model local functions present in ModelProto +void check_model_local_functions( + const ModelProto& model, + const CheckerContext& ctx, + const LexicalScopeContext& parent_lex); + +void check_model(const ModelProto& model, bool full_check = false); +void check_model(const std::string& model_path, bool full_check = false); + +bool check_is_experimental_op(const NodeProto& node); + +} // namespace checker +} // namespace ONNX_NAMESPACE diff --git a/runtime/Lib/site-packages/onnx/checker.py b/runtime/Lib/site-packages/onnx/checker.py new file mode 100644 index 0000000000000000000000000000000000000000..aeb04c62d0556d9af09c9c192ded6e3462a3cbc8 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/checker.py @@ -0,0 +1,139 @@ +# Copyright (c) ONNX Project Contributors +# +# SPDX-License-Identifier: Apache-2.0 +"""onnx checker + +This implements graphalities that allows us to check whether a serialized +proto is legal. +""" + +import functools +import sys +from typing import Any, Callable, Optional, Type, TypeVar, Union, cast + +from google.protobuf.message import Message + +import onnx.defs +import onnx.onnx_cpp2py_export.checker as C # noqa: N812 +import onnx.shape_inference +from onnx import ( + IR_VERSION, + AttributeProto, + FunctionProto, + GraphProto, + ModelProto, + NodeProto, + SparseTensorProto, + TensorProto, + ValueInfoProto, + helper, +) + +# Limitation of single protobuf file is 2GB +MAXIMUM_PROTOBUF = 2000000000 + +# TODO: This thing where we reserialize the protobuf back into the +# string, only to deserialize it at the call site, is really goofy. +# Stop doing that. + + +# NB: Please don't edit this context! +DEFAULT_CONTEXT = C.CheckerContext() +DEFAULT_CONTEXT.ir_version = IR_VERSION +# TODO: Maybe ONNX-ML should also be defaulted? +DEFAULT_CONTEXT.opset_imports = {"": onnx.defs.onnx_opset_version()} + + +FuncType = TypeVar("FuncType", bound=Callable[..., Any]) + + +# TODO: This really doesn't seem worth the metaprogramming... +def _create_checker(proto_type: Type[Message]) -> Callable[[FuncType], FuncType]: + def decorator(py_func: FuncType) -> FuncType: + @functools.wraps(py_func) + def checker(proto: Message, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> Any: + if not isinstance(proto, proto_type): + raise RuntimeError( + f"You cannot pass an object that is not of type {proto_type.__name__}" + ) + return getattr(C, py_func.__name__)(proto.SerializeToString(), ctx) + + return cast(FuncType, checker) + + return decorator + + +@_create_checker(ValueInfoProto) +def check_value_info( + value_info: ValueInfoProto, ctx: C.CheckerContext = DEFAULT_CONTEXT +) -> None: + pass + + +@_create_checker(TensorProto) +def check_tensor(tensor: TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None: + pass + + +@_create_checker(AttributeProto) +def check_attribute( + attr: AttributeProto, ctx: C.CheckerContext = DEFAULT_CONTEXT +) -> None: + pass + + +@_create_checker(NodeProto) +def check_node(node: NodeProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None: + pass + + +def check_function( + function: FunctionProto, ctx: Optional[C.CheckerContext] = None +) -> None: + if ctx is None: + ctx = C.CheckerContext() + ctx.ir_version = helper.find_min_ir_version_for( + list(function.opset_import), True + ) + function_opset_dic = {} + for domain_version in function.opset_import: + function_opset_dic[domain_version.domain] = domain_version.version + ctx.opset_imports = function_opset_dic + C.check_function(function.SerializeToString(), ctx) + + +@_create_checker(GraphProto) +def check_graph(graph: GraphProto, ctx: C.CheckerContext = DEFAULT_CONTEXT) -> None: + pass + + +def check_sparse_tensor( + sparse: SparseTensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT +) -> None: + C.check_sparse_tensor(sparse.SerializeToString(), ctx) + + +def check_model(model: Union[ModelProto, str, bytes], full_check: bool = False) -> None: + """Check the consistency of a model. An exception is raised if the test fails. + + Arguments: + model (ModelProto): model to check + full_check (bool): if True, the function checks shapes can be inferred + """ + # If model is a path instead of ModelProto + if isinstance(model, str): + C.check_model_path(model, full_check) + else: + protobuf_string = ( + model if isinstance(model, bytes) else model.SerializeToString() + ) + # If the protobuf is larger than 2GB, + # remind users should use the model path to check + if sys.getsizeof(protobuf_string) > MAXIMUM_PROTOBUF: + raise ValueError( + "This protobuf of onnx model is too large (>2GB). Call check_model with model path instead." + ) + C.check_model(protobuf_string, full_check) + + +ValidationError = C.ValidationError diff --git a/runtime/Lib/site-packages/onnx/common/array_ref.h b/runtime/Lib/site-packages/onnx/common/array_ref.h new file mode 100644 index 0000000000000000000000000000000000000000..61b5428952e7b059fa530e5553335e013be61458 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/array_ref.h @@ -0,0 +1,198 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +//===--- ArrayRef.h - Array Reference Wrapper -------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// ONNX: modified from llvm::ArrayRef. +// removed llvm-specific functionality +// removed some implicit const -> non-const conversions that rely on +// complicated std::enable_if meta-programming +// removed a bunch of slice variants for simplicity... + +#pragma once +#include +#include +#include + +namespace ONNX_NAMESPACE { +/// ArrayRef - Represent a constant reference to an array (0 or more elements +/// consecutively in memory), i.e. a start pointer and a length. It allows +/// various APIs to take consecutive elements easily and conveniently. +/// +/// This class does not own the underlying data, it is expected to be used in +/// situations where the data resides in some other buffer, whose lifetime +/// extends past that of the ArrayRef. For this reason, it is not in general +/// safe to store an ArrayRef. +/// +/// This is intended to be trivially copyable, so it should be passed by +/// value. +template +class ArrayRef { + public: + typedef const T* iterator; + typedef const T* const_iterator; + typedef size_t size_type; + + typedef std::reverse_iterator reverse_iterator; + + private: + /// The start of the array, in an external buffer. + const T* Data; + + /// The number of elements. + size_type Length; + + public: + /// @name Constructors + /// @{ + + /// Construct an empty ArrayRef. + /*implicit*/ ArrayRef() : Data(nullptr), Length(0) {} + + /// Construct an ArrayRef from a single element. + /*implicit*/ ArrayRef(const T& OneElt) : Data(&OneElt), Length(1) {} + + /// Construct an ArrayRef from a pointer and length. + /*implicit*/ ArrayRef(const T* data, size_t length) : Data(data), Length(length) {} + + /// Construct an ArrayRef from a range. + ArrayRef(const T* begin, const T* end) : Data(begin), Length(end - begin) {} + + /// Construct an ArrayRef from a std::vector. + template + /*implicit*/ ArrayRef(const std::vector& Vec) : Data(Vec.data()), Length(Vec.size()) {} + + /// Construct an ArrayRef from a std::array + template + /*implicit*/ constexpr ArrayRef(const std::array& Arr) : Data(Arr.data()), Length(N) {} + + /// Construct an ArrayRef from a C array. + template + /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {} + + /// Construct an ArrayRef from a std::initializer_list. + /*implicit*/ ArrayRef(const std::initializer_list& Vec) + : Data(Vec.begin() == Vec.end() ? (T*)nullptr : Vec.begin()), Length(Vec.size()) {} + + /// @} + /// @name Simple Operations + /// @{ + + iterator begin() const { + return Data; + } + iterator end() const { + return Data + Length; + } + + reverse_iterator rbegin() const { + return reverse_iterator(end()); + } + reverse_iterator rend() const { + return reverse_iterator(begin()); + } + + /// empty - Check if the array is empty. + bool empty() const { + return Length == 0; + } + + const T* data() const { + return Data; + } + + /// size - Get the array size. + size_t size() const { + return Length; + } + + /// front - Get the first element. + const T& front() const { + assert(!empty()); + return Data[0]; + } + + /// back - Get the last element. + const T& back() const { + assert(!empty()); + return Data[Length - 1]; + } + + /// equals - Check for element-wise equality. + bool equals(ArrayRef RHS) const { + if (Length != RHS.Length) + return false; + return std::equal(begin(), end(), RHS.begin()); + } + + /// slice(n, m) - Chop off the first N elements of the array, and keep M + /// elements in the array. + ArrayRef slice(size_t N, size_t M) const { + assert(N + M <= size() && "Invalid specifier"); + return ArrayRef(data() + N, M); + } + + /// slice(n) - Chop off the first N elements of the array. + ArrayRef slice(size_t N) const { + return slice(N, size() - N); + } + + /// @} + /// @name Operator Overloads + /// @{ + const T& operator[](size_t Index) const { + assert(Index < Length && "Invalid index!"); + return Data[Index]; + } + + /// Vector compatibility + const T& at(size_t Index) const { + assert(Index < Length && "Invalid index!"); + return Data[Index]; + } + + /// Disallow accidental assignment from a temporary. + /// + /// The declaration here is extra complicated so that "arrayRef = {}" + /// continues to select the move assignment operator. + template + typename std::enable_if::value, ArrayRef>::type& operator=(U&& Temporary) = delete; + + /// Disallow accidental assignment from a temporary. + /// + /// The declaration here is extra complicated so that "arrayRef = {}" + /// continues to select the move assignment operator. + template + typename std::enable_if::value, ArrayRef>::type& operator=(std::initializer_list) = delete; + + /// @} + /// @name Expensive Operations + /// @{ + std::vector vec() const { + return std::vector(Data, Data + Length); + } + + /// @} + /// @name Conversion operators + /// @{ + operator std::vector() const { + return std::vector(Data, Data + Length); + } + + /// @} +}; + +} // namespace ONNX_NAMESPACE diff --git a/runtime/Lib/site-packages/onnx/common/assertions.cc b/runtime/Lib/site-packages/onnx/common/assertions.cc new file mode 100644 index 0000000000000000000000000000000000000000..6649618af030641ddfba72f876dcde9cbf5970da --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/assertions.cc @@ -0,0 +1,38 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#include "onnx/common/assertions.h" +#include +#include +#include "onnx/common/common.h" + +namespace ONNX_NAMESPACE { + +std::string barf(const char* fmt, ...) { + char msg[2048]; + va_list args; + + va_start(args, fmt); + // Although vsnprintf might have vulnerability issue while using format string with overflowed length, + // it should be safe here to use fixed length for buffer "msg". No further checking is needed. + vsnprintf(msg, 2048, fmt, args); + va_end(args); + + return std::string(msg); +} + +void throw_assert_error(std::string& msg) { + ONNX_THROW_EX(assert_error(msg)); +} + +void throw_tensor_error(std::string& msg) { + ONNX_THROW_EX(tensor_error(msg)); +} + +} // namespace ONNX_NAMESPACE diff --git a/runtime/Lib/site-packages/onnx/common/assertions.h b/runtime/Lib/site-packages/onnx/common/assertions.h new file mode 100644 index 0000000000000000000000000000000000000000..73984562cf8b788a8d3fa1af277dfb472fcdfe97 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/assertions.h @@ -0,0 +1,72 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#pragma once + +#include +#include + +namespace ONNX_NAMESPACE { + +struct assert_error : public std::runtime_error { + public: + explicit assert_error(const std::string& msg) : runtime_error(msg) {} +}; + +struct tensor_error : public assert_error { + public: + explicit tensor_error(const std::string& msg) : assert_error(msg) {} +}; + +std::string barf(const char* fmt, ...); + +[[noreturn]] void throw_assert_error(std::string&); + +[[noreturn]] void throw_tensor_error(std::string&); + +} // namespace ONNX_NAMESPACE + +#if defined(__GNUC__) || defined(__ICL) || defined(__clang__) +#define _ONNX_EXPECT(x, y) (__builtin_expect((x), (y))) +#else +#define _ONNX_EXPECT(x, y) (x) +#endif + +#define ONNX_ASSERT(cond) \ + if (_ONNX_EXPECT(!(cond), 0)) { \ + std::string error_msg = \ + ::ONNX_NAMESPACE::barf("%s:%u: %s: Assertion `%s` failed.", __FILE__, __LINE__, __func__, #cond); \ + throw_assert_error(error_msg); \ + } + +// The following is used to prevent MSVC from passing the whole __VA_ARGS__ list +// as the first parameter value to a macro call. +#define ONNX_EXPAND(x) x + +// Note: msg must be a string literal +#define _ONNX_ASSERTM(cond, msg, ...) \ + if (_ONNX_EXPECT(!(cond), 0)) { \ + std::string error_msg = ::ONNX_NAMESPACE::barf( \ + "%s:%u: %s: Assertion `%s` failed: " msg, __FILE__, __LINE__, __func__, #cond, __VA_ARGS__); \ + throw_assert_error(error_msg); \ + } + +// The trailing ' ' argument is a hack to deal with the extra comma when ... is empty. +// Another way to solve this is ##__VA_ARGS__ in _ONNX_ASSERTM, but this is a non-portable +// extension we shouldn't use. +#define ONNX_ASSERTM(...) ONNX_EXPAND(_ONNX_ASSERTM(__VA_ARGS__, " ")) + +#define _TENSOR_ASSERTM(cond, msg, ...) \ + if (_ONNX_EXPECT(!(cond), 0)) { \ + std::string error_msg = ::ONNX_NAMESPACE::barf( \ + "%s:%u: %s: Assertion `%s` failed: " msg, __FILE__, __LINE__, __func__, #cond, __VA_ARGS__); \ + throw_tensor_error(error_msg); \ + } + +#define TENSOR_ASSERTM(...) ONNX_EXPAND(_TENSOR_ASSERTM(__VA_ARGS__, " ")) diff --git a/runtime/Lib/site-packages/onnx/common/common.h b/runtime/Lib/site-packages/onnx/common/common.h new file mode 100644 index 0000000000000000000000000000000000000000..40fd3e7462a2a62fa7965401ffe2971fe6baa906 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/common.h @@ -0,0 +1,36 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#define ONNX_UNUSED_PARAMETER(x) (void)(x) + +#ifdef ONNX_NO_EXCEPTIONS +#include +#define ONNX_THROW(...) \ + do { \ + std::cerr << ONNX_NAMESPACE::MakeString(__VA_ARGS__); \ + abort(); \ + } while (false) + +#define ONNX_THROW_EX(ex) \ + do { \ + std::cerr << ex.what() << std::endl; \ + abort(); \ + } while (false) + +#define ONNX_TRY if (true) +#define ONNX_CATCH(x) else if (false) +#define ONNX_HANDLE_EXCEPTION(func) + +#else +#define ONNX_THROW(...) throw std::runtime_error(ONNX_NAMESPACE::MakeString(__VA_ARGS__)) +#define ONNX_THROW_EX(ex) throw ex + +#define ONNX_TRY try +#define ONNX_CATCH(x) catch (x) +#define ONNX_HANDLE_EXCEPTION(func) func() +#endif diff --git a/runtime/Lib/site-packages/onnx/common/constants.h b/runtime/Lib/site-packages/onnx/common/constants.h new file mode 100644 index 0000000000000000000000000000000000000000..8b7463442f47e7f1187a3fe9d653db65209fe796 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/constants.h @@ -0,0 +1,34 @@ +// Copyright (c) ONNX Project Contributors +// +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include + +namespace ONNX_NAMESPACE { +// For ONNX op/function registration. + +// ONNX domains. +constexpr const char* AI_ONNX_ML_DOMAIN = "ai.onnx.ml"; +constexpr const char* AI_ONNX_TRAINING_DOMAIN = "ai.onnx.training"; +constexpr const char* AI_ONNX_PREVIEW_TRAINING_DOMAIN = "ai.onnx.preview.training"; +constexpr const char* ONNX_DOMAIN = ""; +constexpr bool OPTIONAL_VALUE = false; + +// For dimension denotation. +constexpr const char* DATA_BATCH = "DATA_BATCH"; +constexpr const char* DATA_CHANNEL = "DATA_CHANNEL"; +constexpr const char* DATA_TIME = "DATA_TIME"; +constexpr const char* DATA_FEATURE = "DATA_FEATURE"; +constexpr const char* FILTER_IN_CHANNEL = "FILTER_IN_CHANNEL"; +constexpr const char* FILTER_OUT_CHANNEL = "FILTER_OUT_CHANNEL"; +constexpr const char* FILTER_SPATIAL = "FILTER_SPATIAL"; + +// For type denotation. +constexpr const char* TENSOR = "TENSOR"; +constexpr const char* IMAGE = "IMAGE"; +constexpr const char* AUDIO = "AUDIO"; +constexpr const char* TEXT = "TEXT"; + +} // namespace ONNX_NAMESPACE diff --git a/runtime/Lib/site-packages/onnx/common/file_utils.h b/runtime/Lib/site-packages/onnx/common/file_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..bc4db05e72b5682dcbce98acb755390e8e3bc657 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/file_utils.h @@ -0,0 +1,28 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#include "onnx/checker.h" +#include "onnx/common/path.h" + +#include + +namespace ONNX_NAMESPACE { + +template +void LoadProtoFromPath(const std::string proto_path, T& proto) { + std::fstream proto_stream(proto_path, std::ios::in | std::ios::binary); + if (!proto_stream.good()) { + fail_check("Unable to open proto file: ", proto_path, ". Please check if it is a valid proto. "); + } + std::string data{std::istreambuf_iterator{proto_stream}, std::istreambuf_iterator{}}; + if (!ParseProtoFromBytes(&proto, data.c_str(), data.size())) { + fail_check( + "Unable to parse proto from file: ", proto_path, ". Please check if it is a valid protobuf file of proto. "); + } +} +} // namespace ONNX_NAMESPACE diff --git a/runtime/Lib/site-packages/onnx/common/graph_node_list.h b/runtime/Lib/site-packages/onnx/common/graph_node_list.h new file mode 100644 index 0000000000000000000000000000000000000000..31ada8a80282311d1cab2d7ff2b3c43f96d95e4f --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/graph_node_list.h @@ -0,0 +1,167 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#include "onnx/common/assertions.h" + +namespace ONNX_NAMESPACE { + +// Intrusive doubly linked lists with sane reverse iterators. +// The header file is named graph_node_list.h because it is ONLY +// used for Graph's Node lists, and if you want to use it for other +// things, you will have to do some refactoring. +// +// At the moment, the templated type T must support a few operations: +// +// - It must have a field: T* next_in_graph[2] = { nullptr, nullptr }; +// which are used for the intrusive linked list pointers. +// +// - It must have a method 'destroy()', which removes T from the +// list and frees a T. +// +// In practice, we are only using it with Node and const Node. 'destroy()' +// needs to be renegotiated if you want to use this somewhere else. +// +// Besides the benefits of being intrusive, unlike std::list, these lists handle +// forward and backward iteration uniformly because we require a +// "before-first-element" sentinel. This means that reverse iterators +// physically point to the element they logically point to, rather than +// the off-by-one behavior for all standard library reverse iterators. + +static constexpr size_t kNextDirection = 0; +static constexpr size_t kPrevDirection = 1; + +template +struct generic_graph_node_list; + +template +struct generic_graph_node_list_iterator; + +struct Node; +using graph_node_list = generic_graph_node_list; +using const_graph_node_list = generic_graph_node_list; +using graph_node_list_iterator = generic_graph_node_list_iterator; +using const_graph_node_list_iterator = generic_graph_node_list_iterator; + +template +struct generic_graph_node_list_iterator final { + generic_graph_node_list_iterator() : cur(nullptr), d(kNextDirection) {} + generic_graph_node_list_iterator(T* cur, size_t d) : cur(cur), d(d) {} + T* operator*() const { + return cur; + } + T* operator->() const { + return cur; + } + generic_graph_node_list_iterator& operator++() { + ONNX_ASSERT(cur); + cur = cur->next_in_graph[d]; + return *this; + } + generic_graph_node_list_iterator operator++(int) { + generic_graph_node_list_iterator old = *this; + ++(*this); + return old; + } + generic_graph_node_list_iterator& operator--() { + ONNX_ASSERT(cur); + cur = cur->next_in_graph[reverseDir()]; + return *this; + } + generic_graph_node_list_iterator operator--(int) { + generic_graph_node_list_iterator old = *this; + --(*this); + return old; + } + + // erase cur without invalidating this iterator + // named differently from destroy so that ->/. bugs do not + // silently cause the wrong one to be called. + // iterator will point to the previous entry after call + void destroyCurrent() { + T* n = cur; + cur = cur->next_in_graph[reverseDir()]; + n->destroy(); + } + generic_graph_node_list_iterator reverse() { + return generic_graph_node_list_iterator(cur, reverseDir()); + } + + private: + size_t reverseDir() { + return d == kNextDirection ? kPrevDirection : kNextDirection; + } + T* cur; + size_t d; // direction 0 is forward 1 is reverse, see next_in_graph +}; + +template +struct generic_graph_node_list final { + using iterator = generic_graph_node_list_iterator; + using const_iterator = generic_graph_node_list_iterator; + generic_graph_node_list_iterator begin() { + return generic_graph_node_list_iterator(head->next_in_graph[d], d); + } + generic_graph_node_list_iterator begin() const { + return generic_graph_node_list_iterator(head->next_in_graph[d], d); + } + generic_graph_node_list_iterator end() { + return generic_graph_node_list_iterator(head, d); + } + generic_graph_node_list_iterator end() const { + return generic_graph_node_list_iterator(head, d); + } + generic_graph_node_list_iterator rbegin() { + return reverse().begin(); + } + generic_graph_node_list_iterator rbegin() const { + return reverse().begin(); + } + generic_graph_node_list_iterator rend() { + return reverse().end(); + } + generic_graph_node_list_iterator rend() const { + return reverse().end(); + } + generic_graph_node_list reverse() { + return generic_graph_node_list(head, d == kNextDirection ? kPrevDirection : kNextDirection); + } + const generic_graph_node_list reverse() const { + return generic_graph_node_list(head, d == kNextDirection ? kPrevDirection : kNextDirection); + } + generic_graph_node_list(T* head, size_t d) : head(head), d(d) {} + + private: + T* head; + size_t d; +}; + +template +static inline bool operator==(generic_graph_node_list_iterator a, generic_graph_node_list_iterator b) { + return *a == *b; +} + +template +static inline bool operator!=(generic_graph_node_list_iterator a, generic_graph_node_list_iterator b) { + return *a != *b; +} + +} // namespace ONNX_NAMESPACE + +namespace std { + +template +struct iterator_traits> { + using difference_type = int64_t; + using value_type = T*; + using pointer = T**; + using reference = T*&; + using iterator_category = bidirectional_iterator_tag; +}; + +} // namespace std diff --git a/runtime/Lib/site-packages/onnx/common/interned_strings.cc b/runtime/Lib/site-packages/onnx/common/interned_strings.cc new file mode 100644 index 0000000000000000000000000000000000000000..5c719e3b86f366b5b91c07fd5a8db8618369b87a --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/interned_strings.cc @@ -0,0 +1,79 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#include +#include +#include +#include +#include + +#include "onnx/common/assertions.h" +#include "onnx/common/interned_strings.h" + +namespace ONNX_NAMESPACE { + +struct InternedStrings { + InternedStrings() : next_sym(kLastSymbol) { +#define REGISTER_SYMBOL(s) \ + string_to_sym_[#s] = k##s; \ + sym_to_string_[k##s] = #s; + FORALL_BUILTIN_SYMBOLS(REGISTER_SYMBOL) +#undef REGISTER_SYMBOL + } + uint32_t symbol(const std::string& s) { + std::lock_guard guard(mutex_); + auto it = string_to_sym_.find(s); + if (it != string_to_sym_.end()) + return it->second; + uint32_t k = next_sym++; + string_to_sym_[s] = k; + sym_to_string_[k] = s; + return k; + } + const char* string(Symbol sym) { + // Builtin Symbols are also in the maps, but + // we can bypass the need to acquire a lock + // to read the map for Builtins because we already + // know their string value + switch (sym) { +#define DEFINE_CASE(s) \ + case k##s: \ + return #s; + FORALL_BUILTIN_SYMBOLS(DEFINE_CASE) +#undef DEFINE_CASE + default: + return customString(sym); + } + } + + private: + const char* customString(Symbol sym) { + std::lock_guard guard(mutex_); + auto it = sym_to_string_.find(sym); + ONNX_ASSERT(it != sym_to_string_.end()); + return it->second.c_str(); + } + std::unordered_map string_to_sym_; + std::unordered_map sym_to_string_; + uint32_t next_sym; + std::mutex mutex_; +}; + +static InternedStrings& globalStrings() { + static InternedStrings s; + return s; +} + +const char* Symbol::toString() const { + return globalStrings().string(*this); +} + +Symbol::Symbol(const std::string& s) : value(globalStrings().symbol(s)) {} + +} // namespace ONNX_NAMESPACE diff --git a/runtime/Lib/site-packages/onnx/common/interned_strings.h b/runtime/Lib/site-packages/onnx/common/interned_strings.h new file mode 100644 index 0000000000000000000000000000000000000000..aedc01f9e9bc2f7cfa8e91fe4beab411e6ba1d81 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/interned_strings.h @@ -0,0 +1,237 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#pragma once +#include +#include +#include +#include + +namespace ONNX_NAMESPACE { + +#define FORALL_BUILTIN_SYMBOLS(_) \ + _(spatial) \ + _(select_last_index) \ + _(coordinate_transformation_mode) \ + _(PythonOp) \ + _(CppOp) \ + _(Param) \ + _(Select) \ + _(Return) \ + _(Eval) \ + _(add) \ + _(Add) \ + _(Div) \ + _(Mul) \ + _(Neg) \ + _(Sub) \ + _(Pow) \ + _(Sigmoid) \ + _(ArgMax) \ + _(Concat) \ + _(Softmax) \ + _(LogSoftmax) \ + _(Dropout) \ + _(Tanh) \ + _(mul) \ + _(neg) \ + _(sigmoid) \ + _(tanh) \ + _(Constant) \ + _(cat) \ + _(Slice) \ + _(Squeeze) \ + _(Undefined) \ + _(FusionGroup) \ + _(MatMul) \ + _(Gemm) \ + _(Tile) \ + _(SubConstant) \ + _(Scale) \ + _(Transpose) \ + _(Pad) \ + _(Reshape) \ + _(split) \ + _(chunk) \ + _(Offset) \ + _(value) \ + _(Subgraph) \ + _(BatchNormalization) \ + _(Conv) \ + _(ConvTranspose) \ + _(is_test) \ + _(epsilon) \ + _(expand) \ + _(Expand) \ + _(order) \ + _(momentum) \ + _(consumed_inputs) \ + _(kernels) \ + _(kernel_shape) \ + _(kernel) \ + _(scale) \ + _(strides) \ + _(stride) \ + _(pads) \ + _(pad) \ + _(beta) \ + _(alpha) \ + _(dilations) \ + _(dilation) \ + _(broadcast) \ + _(axis) \ + _(ratio) \ + _(size) \ + _(dim) \ + _(keepdims) \ + _(perm) \ + _(shape) \ + _(axes) \ + _(group) \ + _(inplace) \ + _(transA) \ + _(transB) \ + _(other) \ + _(__and__) \ + _(__lshift__) \ + _(__or__) \ + _(__rshift__) \ + _(__xor__) \ + _(abs) \ + _(acos) \ + _(asin) \ + _(atan) \ + _(atan2) \ + _(ceil) \ + _(clamp) \ + _(cos) \ + _(cosh) \ + _(div) \ + _(eq) \ + _(equal) \ + _(Exp) \ + _(ends) \ + _(expm1) \ + _(floor) \ + _(fmod) \ + _(frac) \ + _(ge) \ + _(gt) \ + _(le) \ + _(lerp) \ + _(lgamma) \ + _(Log) \ + _(log1p) \ + _(lt) \ + _(max) \ + _(min) \ + _(ne) \ + _(ones) \ + _(pow) \ + _(reciprocal) \ + _(remainder) \ + _(round) \ + _(rsqrt) \ + _(sin) \ + _(sinh) \ + _(Sqrt) \ + _(sub) \ + _(starts) \ + _(tan) \ + _(trunc) \ + _(zeros) \ + _(exponent) \ + _(device) \ + _(mode) \ + _(Identity) \ + _(Loop) \ + _(If) \ + _(body) \ + _(then_branch) \ + _(else_branch) \ + _(Captured) \ + _(__control_inputs) \ + _(count_include_pad) \ + _(storage_order) \ + _(Unsqueeze) \ + _(ReduceL1) \ + _(ReduceL2) \ + _(ReduceLogSum) \ + _(ReduceLogSumExp) \ + _(ReduceMax) \ + _(ReduceMean) \ + _(ReduceMin) \ + _(ReduceProd) \ + _(ReduceSum) \ + _(ReduceSumSquare) \ + _(Cast) \ + _(to) \ + _(PRelu) \ + _(Greater) \ + _(Less) \ + _(scales) \ + _(Upsample) \ + _(RNN) \ + _(layout) \ + _(k) \ + _(Flatten) \ + _(ScatterElements) \ + _(Resize) \ + _(ceil_mode) \ + _(num_outputs) + +enum BuiltinSymbol { +#define DEFINE_SYMBOL(s) k##s, + FORALL_BUILTIN_SYMBOLS(DEFINE_SYMBOL) +#undef DEFINE_SYMBOL + kLastSymbol, // where we start counting for new symbols +}; + +struct Symbol { + Symbol() {} + /*implicit*/ Symbol(BuiltinSymbol value) : value(value) {} + explicit Symbol(const std::string& s); + explicit Symbol(uint32_t value) : value(value) {} + + operator uint32_t() const { + return value; + } + const char* toString() const; + + private: + uint32_t value; +}; + +static inline bool operator==(Symbol lhs, Symbol rhs) { + return static_cast(lhs) == static_cast(rhs); +} +// necessary to prevent ambiguous overload resolutions +static inline bool operator==(BuiltinSymbol lhs, Symbol rhs) { + return static_cast(lhs) == static_cast(rhs); +} +static inline bool operator==(Symbol lhs, BuiltinSymbol rhs) { + return static_cast(lhs) == static_cast(rhs); +} + +inline Symbol operator"" _sym(const char* s, size_t) { + return Symbol(s); +} + +} // namespace ONNX_NAMESPACE + +// make symbol behave like an integer in hash tables +namespace std { +template <> +struct hash { + std::size_t operator()(ONNX_NAMESPACE::Symbol s) const { + return std::hash()(static_cast(s)); + } +}; + +} // namespace std diff --git a/runtime/Lib/site-packages/onnx/common/ir.h b/runtime/Lib/site-packages/onnx/common/ir.h new file mode 100644 index 0000000000000000000000000000000000000000..b5ce00518dbbd8c8e41b928ad2fea9612d96f413 --- /dev/null +++ b/runtime/Lib/site-packages/onnx/common/ir.h @@ -0,0 +1,1422 @@ +// Copyright (c) ONNX Project Contributors + +/* + * SPDX-License-Identifier: Apache-2.0 + */ + +// ATTENTION: The code in this file is highly EXPERIMENTAL. +// Adventurous users should note that the APIs will probably change. + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "onnx/common/array_ref.h" +#include "onnx/common/assertions.h" +#include "onnx/common/common.h" +#include "onnx/common/graph_node_list.h" +#include "onnx/common/interned_strings.h" +#include "onnx/common/tensor.h" +#include "onnx/string_utils.h" + +#define ONNX_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&) = delete; \ + TypeName& operator=(const TypeName&) = delete + +namespace ONNX_NAMESPACE { + +// Graph represents one "function" of computation. +// It uses a simple ownership model where the graph owns all the nodes inside it. +// All references inside the graph are raw pointers. +// Destroying the Graph will invalidate any pointers to nodes in the graph. +struct Graph; + +// Node is the base class of the IR graph. It represents one computation +// and dependencies on a list of Values. The "prim-ops", so to speak. +struct Node; + +// A Value represents an input or output to node that is either a +// Tensor or an opaque Handle object, as determined by type(). +struct Value; + +class ResourceGuard final { + std::function destructor_; + bool released_; + + public: + ONNX_DISALLOW_COPY_AND_ASSIGN(ResourceGuard); + explicit ResourceGuard(std::function destructor) : destructor_(std::move(destructor)), released_(false) {} + ResourceGuard(ResourceGuard&& other) = default; + ResourceGuard& operator=(ResourceGuard&& other) = default; + + ~ResourceGuard() { + if (!released_) + destructor_(); + } + + void release() { + released_ = true; + } +}; + +struct Dimension final { + Dimension() : is_unknown(true), is_int(false), dim(-1) {} + Dimension(std::string param) : is_unknown(false), is_int(false), dim(-1), param(std::move(param)) {} // NOLINT + Dimension(int64_t dim) : is_unknown(false), is_int(true), dim(dim) {} // NOLINT + + bool is_unknown; + bool is_int; + int64_t dim; + std::string param; +}; + +enum class AttributeKind : uint8_t { + // float, float list, int, int list, string, string list, + // tensor, tensor list, subgraph, subgraph list. type proto, type proto list + f, + fs, + i, + is, + s, + ss, + t, + ts, + g, + gs, + tp, + tps +}; + +static inline const char* toString(AttributeKind kind) { + static constexpr const char* names[] = {"f", "fs", "i", "is", "s", "ss", "t", "ts", "g", "gs", "tp", "tps"}; + ONNX_ASSERT(size_t(kind) < sizeof(names) / sizeof(const char*)); + return names[int(kind)]; +} + +struct AttributeValue { + explicit AttributeValue(Symbol name) : name(name) {} + using Ptr = std::unique_ptr; + Symbol name; + virtual AttributeKind kind() const = 0; + virtual Ptr clone() const = 0; + virtual ~AttributeValue() = default; +}; + +template +struct ScalarAttributeValue final : public AttributeValue { + using ConstructorType = const T&; + using ValueType = T; + ScalarAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(value_) {} + ValueType& value() { + return value_; + } + virtual Ptr clone() const override { + return Ptr(new ScalarAttributeValue(name, value_)); + } + virtual AttributeKind kind() const override { + return Kind; + } + + private: + ValueType value_; +}; + +template +struct VectorAttributeValue final : public AttributeValue { + using ConstructorType = const std::vector&&; + using ValueType = std::vector; + VectorAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(std::move(value_)) {} + ValueType& value() { + return value_; + } + virtual AttributeKind kind() const override { + return Kind; + } + virtual std::unique_ptr clone() const override { + auto copy = value_; + return Ptr(new VectorAttributeValue(name, std::move(copy))); + } + + private: + ValueType value_; +}; + +using FloatAttr = ScalarAttributeValue; +using FloatsAttr = VectorAttributeValue; +using IntAttr = ScalarAttributeValue; +using IntsAttr = VectorAttributeValue; +using StringAttr = ScalarAttributeValue; +using StringsAttr = VectorAttributeValue; +using TensorAttr = ScalarAttributeValue; +using TensorsAttr = VectorAttributeValue; +using GraphAttr = ScalarAttributeValue, AttributeKind::g>; +using GraphsAttr = VectorAttributeValue, AttributeKind::gs>; +using TypeProtoAttr = ScalarAttributeValue; +using TypeProtosAttr = VectorAttributeValue; + +// CRTP so that Node which inherits Attributes can be return for +// method chaining e.g: +// Node * n = g->create(kSelect)->set_i(kOffset,3)->set_f(kValue,3.5); +// we return Derived* pointers because Nodes are normally held as pointers. +template +struct Attributes { + Attributes() {} + void copyAttributes(const Attributes& rhs) { + values_.clear(); + values_.reserve(rhs.values_.size()); + for (auto& i : rhs.values_) { + values_.push_back(i->clone()); + } + } + bool hasAttribute(Symbol name) const { + return find(name, false) != values_.end(); + } + AttributeKind kindOf(Symbol name) const { + return (*find(name, true))->kind(); + } + Derived* removeAttribute(Symbol name) { + values_.erase(find(name, true)); + return This(); + } + bool hasAttributes() const { + return !values_.empty(); + } + // The names are returned in order, since name actually is the index. + std::vector attributeNames() const { + std::vector names; + names.reserve(values_.size()); + for (auto& a : values_) + names.push_back(a->name); + return names; + } + +#define CREATE_ACCESSOR(Kind, method) \ + Derived* method##_(Symbol name, Kind##Attr::ConstructorType v) { \ + return set(name, std::forward(v)); \ + } \ + const Kind##Attr::ValueType& method(Symbol name) const { \ + return get(name); \ + } + CREATE_ACCESSOR(Float, f) + CREATE_ACCESSOR(Floats, fs) + CREATE_ACCESSOR(String, s) + CREATE_ACCESSOR(Strings, ss) + CREATE_ACCESSOR(Int, i) + CREATE_ACCESSOR(Ints, is) + CREATE_ACCESSOR(Tensor, t) + CREATE_ACCESSOR(Tensors, ts) + CREATE_ACCESSOR(Graph, g) + CREATE_ACCESSOR(Graphs, gs) + CREATE_ACCESSOR(TypeProto, tp) + CREATE_ACCESSOR(TypeProtos, tps) + +#undef CREATE_ACCESSOR + + private: + Derived* This() { + return static_cast(this); + } + template + Derived* set(Symbol name, typename T::ConstructorType v) { + auto it = find(name, false); + auto nv = AVPtr(new T(name, std::forward(v))); + if (it == values_.end()) { + values_.push_back(std::move(nv)); + } else { + *it = std::move(nv); + } + return This(); + } + template + typename T::ValueType& get(Symbol name) const { + auto it = find(name, true); + T* child = static_cast(it->get()); + return child->value(); + } + using AVPtr = AttributeValue::Ptr; + // NB: For determinism, we use a vector rather than a hash map. This does + // mean that lookups are O(n), so you shouldn't use Attributes to store + // a big pile of messages. + std::vector values_; + using iterator = std::vector::iterator; + iterator find(Symbol name, bool required) { + auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; }); + ONNX_ASSERT(!required || it != values_.end()); + return it; + } + using const_iterator = std::vector::const_iterator; + const_iterator find(Symbol name, bool required) const { + auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; }); + ONNX_ASSERTM( + !required || it != values_.end(), + "%s:%u: %s: required undefined attribute '%s'", + __FILE__, + __LINE__, + __func__, + name.toString()); + return it; + } +}; + +// Each use is represented by this type, see Node::uses() +// 'user' is the consumer of the value, offset is the index into +// 'user's input this where the produces will be found. +struct Use final { + Use(Node* user, size_t offset) : user(user), offset(offset) {} + Node* user; + size_t offset; +}; + +static inline bool operator==(const Use& a, const Use& b) { + return a.user == b.user && a.offset == b.offset; +} + +// the list types are intentionally simple, but we type-def +// them here so if we need to change them, refactoring will be easier +using node_list = std::vector; +using value_list = std::vector; +using use_list = std::vector; +using NodeKind = Symbol; + +struct Value final { + ONNX_DISALLOW_COPY_AND_ASSIGN(Value); + Value(Node* node_, size_t offset_); + Value(Value&&) = default; + Value& operator=(Value&&) = default; + ~Value() = default; + + private: + friend struct Node; + friend struct Graph; + Node* node_; + size_t offset_; + size_t unique_ = 0; // unique id + size_t stage_ = 0; // 0-forward, 1-backward, 2-double-backward,... + use_list uses_in_current_graph_; + bool has_unique_name_; + std::string unique_name_; + int32_t elem_type_; + bool has_sizes_; + std::vector sizes_; + + public: + Value* setElemType(int32_t elem_type) { + elem_type_ = elem_type; + return this; + } + int32_t elemType() const { + return elem_type_; + } + bool has_sizes() const { + return has_sizes_; + } + Value* setSizes(std::vector sizes) { + has_sizes_ = true; + sizes_ = std::move(sizes); + return this; + } + Value* wipeSizes() { + has_sizes_ = false; + sizes_ = std::vector(); + return this; + } + const std::vector& sizes() const { + return sizes_; + } + size_t unique() const { + return unique_; + } + bool has_unique_name() const { + return has_unique_name_; + } + std::string uniqueName() const { + if (has_unique_name()) + return unique_name_; + return ONNX_NAMESPACE::to_string(unique()); + } + Value* setUniqueName(const std::string& name, bool rename_subgraph_captured_nodes = true); + Value* setStage(size_t s) { + stage_ = s; + return this; + } + size_t stage() const { + return stage_; + } + Node* node() { + return node_; + } + size_t offset() const { + return offset_; + } + const Node* node() const { + return node_; + } + Graph* owningGraph(); + const Graph* owningGraph() const; + // TODO: make this more const correct + const use_list uses() const; + + // Replaces all uses of this node with 'newValue'. + // + // Given: %3 = f(%1, %2) + // %4 = g(%3) + // %5 = h(%3, %3) + // Execute: %3.replaceAllUsesWith(%6) + // Result: %3 = f(%1, %2) + // %4 = g(%6) + // %5 = h(%6, %6) + void replaceAllUsesWith(Value* newValue); + + Value* copyMetadata(Value* from) { + setElemType(from->elemType()); + setSizes(from->sizes()); + if (from->has_unique_name()) { + setUniqueName(from->uniqueName()); + } + return this; + } +}; + +struct Node : public Attributes { + ONNX_DISALLOW_COPY_AND_ASSIGN(Node); + friend struct Graph; + friend struct Value; + friend graph_node_list; + friend const_graph_node_list; + friend graph_node_list_iterator; + friend const_graph_node_list_iterator; + + private: + // each node but Return/Param + // is associated with exactly one place in the node list... + // of the graph_ + // this circular is a doubly-linked list, the Return node is used as the sentinel for the beginning and end of the + // list such that the list never has null pointers next_in_graph[0] is next pointer next_in_graph[1] is prev pointer + // using an array to allow the same iterator class for forward and reverse node lists + // This list represents a topological sort + + Node* next_in_graph[2] = {nullptr, nullptr}; + Node*& next() { + return next_in_graph[kNextDirection]; + } + Node*& prev() { + return next_in_graph[kPrevDirection]; + } + Node* const& next() const { + return next_in_graph[kNextDirection]; + } + Node* const& prev() const { + return next_in_graph[kPrevDirection]; + } + + const NodeKind kind_; + std::vector inputs_; + std::vector outputs_; + Graph* graph_; + size_t stage_; + bool has_name_; + std::string name_; + bool has_domain_; + std::string domain_; + bool has_doc_string_; + std::string doc_string_; + + protected: + Node(Graph* graph_, NodeKind kind_); // defined after graph + + public: + bool has_name() const { + return has_name_; + } + const std::string& name() const { + return name_; + } + void setName(std::string name) { + has_name_ = true; + name_ = std::move(name); + } + bool has_domain() const { + return has_domain_; + } + const std::string& domain() const { + return domain_; + } + void setDomain(std::string domain) { + has_domain_ = true; + domain_ = std::move(domain); + } + bool has_doc_string() const { + return has_doc_string_; + } + const std::string& docString() const { + return doc_string_; + } + void setDocString(std::string doc_string) { + has_doc_string_ = true; + doc_string_ = std::move(doc_string); + } + NodeKind kind() const { + return kind_; + } + Graph* owningGraph() { + return graph_; + } + const Graph* owningGraph() const { + return graph_; + } + size_t stage() const { + return stage_; + } + Node* setStage(size_t s) { + stage_ = s; + return this; + } + // NB: This returns an ArrayRef; that means that it will + // get invalidated if you resize inputs (e.g., using addInput) + // We can't return a std::vector& because there's no + // way to soundly cast to std::vector (an insane + // implementation of std::vector could make this representationally + // different.) + ArrayRef inputs() { + return inputs_; + } + ArrayRef inputs() const { + // Vectors are not convertible in const-ness of elements, but + // raw pointers are. + return {inputs_.data(), inputs_.size()}; + } + // NB: This returns an ArrayRef; that means that it will + // get invalidated if you resize inputs (e.g., using addInput) + // We can't return a std::vector& because there's no + // way to soundly cast to std::vector (an insane + // implementation of std::vector could make this representationally + // different.) + ArrayRef outputs() { + return outputs_; + } + ArrayRef outputs() const { + // Vectors are not convertible in const-ness of elements, but + // raw pointers are. + return {outputs_.data(), outputs_.size()}; + } + bool hasUses() const { + for (auto o : outputs()) { + if (!o->uses().empty()) + return true; + } + return false; + } + void replaceAllUsesWith(Node* n) { + ONNX_ASSERT(outputs().size() == n->outputs().size()); + size_t nOutputs = outputs().size(); + for (size_t i = 0; i < nOutputs; i++) { + outputs()[i]->replaceAllUsesWith(n->outputs()[i]); + } + } + // lots of things like chunk have a single input or single output, so we have a + // helper to make accessing it easier + Value* input() { + ONNX_ASSERT(inputs_.size() == 1); + return inputs_.at(0); + } + Value* output() { + ONNX_ASSERT(outputs_.size() == 1); + return outputs_.at(0); + } + const Value* input() const { + ONNX_ASSERT(inputs_.size() == 1); + return inputs_.at(0); + } + Value* output() const { + ONNX_ASSERT(outputs_.size() == 1); + return outputs_.at(0); + } + // Access a particular input. This is a checked index. + Value* input(size_t i) { + return inputs_.at(i); + } + const Value* input(size_t i) const { + return inputs_.at(i); + } + + // Graphs + + // Note [Topological invariant] + // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // We always maintain an up-to-date topological ordering of all nodes via + // the next()/prev() links. All transformations to graphs must preserve + // this topological ordering: for example, it is only valid to 'addInput' + // with an input which is topologically before the current node. + // + // Usually, it is obvious whether or not topological order is maintained; + // for example, if you are adding nodes to the end of the topsort, it's + // impossible for them to refer to inputs that are not in the topsort. + // If it is not obvious, please comment accordingly. + + // Add 'node' as an input to 'this' at the end of existing + // arguments. Returns the added node for ease of chaining. + // + // Given: %3 = f(%1, %2) + // Execute: %3.addInput(%4) + // Result: %3 = f(%1, %2, %4) + Value* addInput(Value* node) { + ONNX_ASSERT(graph_ == node->owningGraph()); + node->uses_in_current_graph_.emplace_back(this, inputs_.size()); + inputs_.push_back(node); + return node; + } + + // Replace the input of 'this' at position 'i' with + // 'newValue', returning the old node. + // + // Given: %3 = f(%1, %2) + // Execute: %3.replaceInput(1, %4) + // Result: %3 = f(%1, %4) + Value* replaceInput(size_t i, Value* newValue) { + ONNX_ASSERT(newValue->owningGraph() == graph_); + Value* old = dropInput(i); + inputs_[i] = newValue; + newValue->uses_in_current_graph_.emplace_back(this, i); + return old; + } + + // Replace all occurrences of 'from' in the inputs of this + // node with 'to'. Corresponds to llvm's replaceUsesOfWith. + // + // Given: %3 = f(%1, %2, %1) + // Execute: %3.replaceInputWith(%1, %4) + // Result: %3 = f(%4, %2, %4) + void replaceInputWith(Value* from, Value* to) { + ONNX_ASSERT(from->owningGraph() == graph_); + ONNX_ASSERT(to->owningGraph() == graph_); + size_t i = 0; + for (auto input : inputs()) { + if (input == from) + replaceInput(i, to); + i++; + } + } + + Value* addOutput() { + outputs_.push_back(new Value(this, outputs_.size())); + return outputs_.back(); + } + + void eraseOutput(size_t i); + + // Insert unattached 'this' node after 'n' in the topological order. + // Returns this (for chaining). + // + // Given: %3 = f(%1, %2) + // %4 = g(%3) + // and unattached: %5 = h(%1) + // Execute: %5.insertBefore(%4) + // Result: %3 = f(%1, %2) + // %5 = h(%1) + // %4 = g(%3) + Node* insertBefore(Node* n) { + ONNX_ASSERT(n->inGraphList()); + insertAfter(n->prev()); + return this; + } + + // Insert unattached 'this' node after 'n' in the topological order. + // Returns this (for chaining). + // + // Given: %3 = f(%1, %2) + // %4 = g(%3) + // and unattached: %5 = h(%1) + // Execute: %5.insertAfter(%4) + // Result: %3 = f(%1, %2) + // %4 = g(%3) + // %5 = h(%1) + Node* insertAfter(Node* n) { + ONNX_ASSERT(!inGraphList() && n->inGraphList()); + Node* next = n->next(); + n->next() = this; + this->prev() = n; + this->next() = next; + next->prev() = this; + return this; + } + + // Move 'this' (already in the graph) after 'n' in the topological order. + // + // Given: %2 = f(%1) + // %3 = g(%1) + // Execute: %2.moveAfter(%3) + // Result: %3 = g(%1) + // %2 = f(%1) + // + void moveAfter(Node* n) { + removeFromList(); + insertAfter(n); + } + + // Move a node 'n' (already in the graph) before 'this' in the topological order. + // + // Given: %2 = f(%1) + // %3 = g(%1) + // Execute: %3.moveBefore(%2) + // Result: %3 = g(%1) + // %2 = f(%1) + void moveBefore(Node* n) { + removeFromList(); + insertBefore(n); + } + + // Remove the input at 'i' from this node. + // + // WARNING: This is O(n) in the number of inputs, so avoid repeatedly calling + // removeInput. + // + // Given: %3 = f(%1, %2) + // Execute: %3.removeInput(1) + // Result: %3 = f(%1) + void removeInput(size_t i) { + dropInput(i); + // everything after this input shifts left, + // so we need to update their use offsets to match + for (size_t j = i + 1; j < inputs_.size(); j++) { + auto it = findUseForInput(j); + it->offset--; + } + inputs_.erase(inputs_.begin() + i); + } + + // Remove all inputs from a node. + // + // Given: %3 = f(%1, %2) + // Execute: %3.removeAllInputs() + // Result: %3 = f() + void removeAllInputs() { + for (size_t i = 0; i < inputs().size(); ++i) + dropInput(i); + inputs_.clear(); + } + + // Check whether this node is before node n in the graph. + bool isBefore(Node* n); + + // iterators of the node list starting at this node + // useful for resuming a search starting at this node + graph_node_list_iterator iterator(); + graph_node_list_iterator reverseIterator(); + const_graph_node_list_iterator iterator() const; + const_graph_node_list_iterator reverseIterator() const; + + // Remove 'this' from the instruction list and deallocate it. + // + // Invariant: no outputs of 'this' may have any uses. + // + // Given: %2 = f(%1) + // %3 = g(%1) + // Execute: %2.destroy() + // Result: %3 = g(%1) + void destroy(); + + // Dynamically cast this node to the subclass indicated by the + // template variable, returning nullptr if the cast is invalid.. + // + // Example usage: if(auto s = n.cast