From 7f8f0fd0fa3be948bd9e86223f2dee8f9d5103ad Mon Sep 17 00:00:00 2001 From: Chris Austen Date: Fri, 10 Nov 2023 10:30:54 -0500 Subject: [PATCH] Merge Navi changes for int8 unit tests and verification mlir issues (#2393) Ensure unique module name for MLIR standalone ops (#2360) Cherry Pick ASAN build excluding additional bin files -1839 #2370 Use an older version of numpy for compatibility with Python3.6 #2369 Add space after rate message Fix wrong size check when axes not present for slice (#2270) Updated Changelog to document latest release work (#2363) Run simplify_qdq first before optimize_module (#2387) fix unit tests and verification issues on navi Set numpy to 1.21.6 and disable py3.6 test Release notes & changelog updates (#2395) --- CHANGELOG.md | 228 +++++++++++++++++------------- README.md | 258 +++++++++++++++++----------------- requirements.txt | 2 +- src/quantization.cpp | 2 +- test/py/CMakeLists.txt | 10 +- test/py/requirements-onnx.txt | 2 +- test/py/requirements.txt | 2 +- 7 files changed, 270 insertions(+), 234 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 30a09d00584..8d4814695c9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,113 +1,141 @@ -# Change Log for MIGraphX +# Changelog for MIGraphX -Full documentation for MIGraphX is available at [MIGraphX Documentation](https://rocmdocs.amd.com/projects/AMDMIGraphX/en/latest/). +Full documentation for MIGraphX is available at +[https://rocmdocs.amd.com/projects/AMDMIGraphX/en/latest/](https://rocmdocs.amd.com/projects/AMDMIGraphX/en/latest/). ## MIGraphX 2.8 for ROCm 6.0.0 -### Added -- Support for MI300 GPUs -- Support for TorchMIGraphX via PyTorch -- Boosted overall performance by integrating rocMLIR -- INT8 support for ONNX Runtime -- Support for ONNX version 1.14.1 -- Added operators Qlinearadd, QlinearGlobalAveragePool, Qlinearconv, Shrink, CastLike, and RandomUniform operators -- Added an error message when gpu_targets is not set when compiling migraphx -- Added parameter to set tolerances with migraphx-driver verify -- Added support for MXR files >4 GB -- Added MIGRAPHX_TRACE_MLIR flag -- BETA added capability to use ROCm Composable Kernels via environment variable MIGRAPHX_ENABLE_CK=1 + +### Additions + +* Support for MI300 GPUs +* Support for TorchMIGraphX via PyTorch +* Boosted overall performance by integrating rocMLIR +* INT8 support for ONNX Runtime +* Support for ONNX version 1.14.1 +* Added new operators: `Qlinearadd`, `QlinearGlobalAveragePool`, `Qlinearconv`, `Shrink`, `CastLike`, + and `RandomUniform` +* Added an error message for when `gpu_targets` is not set during MIGraphX compilation +* Added parameter to set tolerances with `migraphx-driver` verify +* Added support for MXR files > 4 GB +* Added `MIGRAPHX_TRACE_MLIR` flag +* BETA added capability for using ROCm Composable Kernels via the `MIGRAPHX_ENABLE_CK=1` + environment variable ### Optimizations -- Improved performance support for INT8 -- Improved time percision while benchmarking candidate kernels from CK or MLIR -- Remove contiguous from reshape parsing -- Updated ConstantOfShape operator to support Dynamic Batch -- Simplifies dynamic shapes related operators to their static versions if possible -- Improved debugging tools for accuracy issues -- Print warning about miopen_fusion while generating mxr -- General reduction in system memory usage during model compilation -- Created additional fusion opportunities during model compilation -- Improved debugging for matchers -- Improved general debug messages - -### Fixed -- Fixed scatter operator for nonstandard shapes with some models from ONNX Model Zoo -- Provided a compile option to improve accuracy of some models by disabling Fast-Math -- Improved layernorm + pointwise fusion matching to ignore arguments order -- Fixed accuracy issue with ROIAlign operator -- Fixed Trilu operator computation logic -- Fixed support for the DETR model - -### Changed -- Changed migraphx version to 2.8 -- Extracted test packages as its own separate deb file when building migraphx from source - -### Removed -- Removed building Python 2.7 bindings +* Improved performance support for INT8 +* Improved time precision while benchmarking candidate kernels from CK or MLIR +* Removed contiguous from reshape parsing +* Updated the `ConstantOfShape` operator to support Dynamic Batch +* Simplified dynamic shapes-related operators to their static versions, where possible +* Improved debugging tools for accuracy issues +* Included a print warning about `miopen_fusion` while generating `mxr` +* General reduction in system memory usage during model compilation +* Created additional fusion opportunities during model compilation +* Improved debugging for matchers +* Improved general debug messages + +### Fixes + +* Fixed scatter operator for nonstandard shapes with some models from ONNX Model Zoo +* Provided a compile option to improve the accuracy of some models by disabling Fast-Math +* Improved layernorm + pointwise fusion matching to ignore argument order +* Fixed accuracy issue with `ROIAlign` operator +* Fixed computation logic for the `Trilu` operator +* Fixed support for the DETR model + +### Changes + +* Changed MIGraphX version to 2.8 +* Extracted the test packages into a separate deb file when building MIGraphX from source + +### Removals + +* Removed building Python 2.7 bindings ## MIGraphX 2.7 for ROCm 5.7.0 -### Added -- Enabled hipRTC to not require dev packages for migraphx runtime and allow the ROCm install to be in a different directory than it was during build time -- Add support for multi-target execution -- Added Dynamic Batch support with C++/Python APIs -- Add migraphx.create_argument to python API -- Added dockerfile example for Ubuntu 22.04 -- Add TensorFlow supported ops in driver similar to exist onnx operator list -- Add a MIGRAPHX_TRACE_MATCHES_FOR env variable to filter the matcher trace -- Improved debugging by printing max,min,mean and stddev values for TRACE_EVAL = 2 -- use fast_math flag instead of ENV flag for GELU -- Print message from driver if offload copy is set for compiled program + +### Additions + +* hipRTC no longer requires dev packages for MIGraphX runtime and allows the ROCm install to be in a + different directory than build time +* Added support for multi-target execution +* Added Dynamic Batch support with C++/Python APIs +* Added `migraphx.create_argument` to Python API +* Added dockerfile example for Ubuntu 22.04 +* Added TensorFlow supported ops in driver similar to exist onnx operator list +* Added a MIGRAPHX_TRACE_MATCHES_FOR env variable to filter the matcher trace +* Improved debugging by printing max,min,mean and stddev values for TRACE_EVAL = 2 +* You can now use the ` fast_math` flag instead of `ENV` for GELU +* Print message from driver if offload copy is set for compiled program + ### Optimizations -- Optimized for ONNX Runtime 1.14.0 -- Improved compile times by only building for the GPU on the system -- Improve performance of pointwise/reduction kernels when using NHWC layouts -- Load specific version of the migraphx_py library -- Annotate functions with the block size so the compiler can do a better job of optimizing -- Enable reshape on nonstandard shapes -- Use half HIP APIs to compute max and min -- Added support for broadcasted scalars to unsqueeze operator -- Improved multiplies with dot operator -- Handle broadcasts across dot and concat -- Add verify namespace for better symbol resolution -### Fixed -- Resolved accuracy issues with FP16 resnet50 -- Update cpp generator to handle inf from float -- Fix assertion error during verify and make DCE work with tuples -- Fix convert operation for NaNs -- Fix shape typo in API test -- Fix compile warnings for shadowing variable names -- Add missing specialization for the `nullptr` for the hash function -### Changed -- Bumped version of half library to 5.6.0 -- Bumped CI to support rocm 5.6 -- Make building tests optional -- replace np.bool with bool as per numpy request -### Removed -- Removed int8x4 rocBlas calls due to deprecation -- removed std::reduce usage since not all OS' support it +* Optimized for ONNX Runtime 1.14.0 +* Improved compile times by only building for the GPU on the system +* Improved performance of pointwise/reduction kernels when using NHWC layouts +* Loaded specific version of the `migraphx_py` library +* Annotated functions with the block size so the compiler can do a better job of optimizing +* Enabled reshape on nonstandard shapes +* Used half HIP APIs to compute max and min +* Added support for broadcasted scalars to unsqueeze operator +* Improved multiplies with dot operator +* Handled broadcasts across dot and concat +* Added verify namespace for better symbol resolution + +### Fixes + +* Resolved accuracy issues with FP16 resnet50 +* Updated cpp generator to handle inf from float +* Fixed assertion error during verify and made DCE work with tuples +* Fixed convert operation for NaNs +* Fixed shape typo in API test +* Fixed compile warnings for shadowing variable names +* Added missing specialization for the `nullptr` hash function + +### Changees + +* Bumped version of half library to 5.6.0 +* Bumped CI to support ROCm 5.6 +* Made building tests optional +* Replaced `np.bool` with `bool` per NumPy request + +### Removals + +* Removed int8x4 rocBlas calls due to deprecation +* Removed `std::reduce` usage because not all operating systems support it ## MIGraphX 2.5 for ROCm 5.5.0 -### Added -- Y-Model feature to store tuning information with the optimized model -- Added Python 3.10 bindings -- Accuracy checker tool based on ONNX Runtime -- ONNX Operators parse_split, and Trilu -- Build support for ROCm MLIR -- Added migraphx-driver flag to print optimizations in python (--python) -- Added JIT implementation of the Gather and Pad operator which results in better handling of larger tensor sizes. + +### Additions + +* Y-Model feature will store tuning information with the optimized model +* Added Python 3.10 bindings +* Accuracy checker tool based on ONNX runtime +* ONNX operators parse_split, and Trilu +* Build support for ROCm MLIR +* Added the `migraphx-driver` flag to print optimizations in Python (--python) +* Added JIT implementation of the Gather and Pad operators, which results in better handling for + larger tensor sizes + ### Optimizations -- Improved performance of Transformer based models -- Improved performance of the Pad, Concat, Gather, and Pointwise operators -- Improved onnx/pb file loading speed -- Added general optimize pass which runs several passes such as simplify_reshapes/algebra and DCE in loop. -### Fixed -- Improved parsing Tensorflow Protobuf files -- Resolved various accuracy issues with some onnx models -- Resolved a gcc-12 issue with mivisionx -- Improved support for larger sized models and batches -- Use --offload-arch instead of --cuda-gpu-arch for the HIP compiler -- Changes inside JIT to use float accumulator for large reduce ops of half type to avoid overflow. -- Changes inside JIT to temporarily use cosine to compute sine function. -### Changed -- Changed version/location of 3rd party build dependencies to pick up fixes + +* Improved performance of Transformer-based models +* Improved performance of the `Pad`, `Concat`, `Gather`, and `Pointwise` operators +* Improved ONNX/pb file loading speed +* Added a general optimize pass that runs several passes, such as `simplify_reshapes`, algebra, and DCE + in a loop + +### Fixes + +* Improved parsing for TensorFlow Protobuf files +* Resolved various accuracy issues with some ONNX models +* Resolved a gcc-12 issue with MIVisionX +* Improved support for larger sized models and batches +* Use `--offload-arch` instead of `--cuda-gpu-arch` for the HIP compiler +* Changes inside JIT to use float accumulator for large reduce ops of half type to avoid overflow +* Changes inside JIT to temporarily use cosine to compute sine function + +### Changes + +* Changed version and location of third-party build dependencies in order to pick up fixes diff --git a/README.md b/README.md index 65671895c06..d31df0e20d8 100755 --- a/README.md +++ b/README.md @@ -1,199 +1,203 @@ # AMD MIGraphX -AMD MIGraphX is AMD's graph inference engine that accelerates machine learning model inference. AMD MIGraphX can be used by -installing binaries directly or building from source code. +AMD MIGraphX is AMD's graph inference engine, which accelerates machine learning model inference. +To use MIGraphX, you can install the binaries or build from source code. Refer to the following sections +for Ubuntu installation instructions (we'll provide instructions for other Linux distributions in the future). -In the following, instructions of how to build and install MIGraphX are described with Ubuntu as the OS -(Instructions of installation on other Linux OSes will come later). Note that all the following instructions assume -ROCm has been installed successfully. ROCm installation instructions are explained in the [ROCm installation -guide](https://rocmdocs.amd.com/en/latest/Installation_Guide/Installation-Guide.html). +```note +You must [install ROCm](https://rocm.docs.amd.com/en/latest/deploy/linux/quick_start.html) before +installing MIGraphX. +``` ## Installing from binaries -With ROCm installed correctly, MIGraphX binaries can be installed on Ubuntu with the following command: -``` + +Install binaries using: + +```bash sudo apt update && sudo apt install -y migraphx ``` -then the header files and libs are installed under `/opt/rocm-`, where `` is the ROCm version. + +Header files and libraries are installed under `/opt/rocm-`, where `` is the ROCm +version. ## Building from source -There are three ways to build the MIGraphX sources. -* [Use the ROCm build tool](#use-the-rocm-build-tool-rbuild) - - This approach uses [rbuild](https://github.com/RadeonOpenCompute/rbuild) to install the prerequisites and -build the libs with just one command. +You have three options for building from source: -* [Use cmake](#use-cmake-to-build-migraphx) - - This approach uses a script to install the prerequisites, then use cmake to build the source. - -* [Use docker](#use-docker) - - This approach builds a docker image with all prerequisites installed, then build the MIGraphX sources inside a docker container. +* [ROCm build tool](#use-the-rocm-build-tool-rbuild): Uses + [rbuild](https://github.com/RadeonOpenCompute/rbuild) to install prerequisites, then you can build + the libraries with a single command. -In the following, we will first list the prerequisites required to build MIGraphX source code, then describe -each of the three approaches. +* [CMake](#use-cmake-to-build-migraphx): Uses a script to install prerequisites, then you can use + CMake to build the source. -### List of prerequisites -The following is a list of prerequisites required to build MIGraphX source. +* [Docker](#use-docker): Builds a Docker image with all prerequisites installed, then you can build the + MIGraphX sources inside a Docker container. -* [ROCm cmake modules](https://github.com/RadeonOpenCompute/rocm-cmake) **required** +### Build prerequisites + +The following is a list of prerequisites for building MIGraphX. + +* [ROCm CMake modules](https://github.com/RadeonOpenCompute/rocm-cmake) **required** * [MIOpen](https://github.com/ROCmSoftwarePlatform/MIOpen) for running on the GPU * [rocBLAS](https://github.com/ROCmSoftwarePlatform/rocBLAS) for running on the GPU * [HIP](https://github.com/ROCm-Developer-Tools/HIP) for running on the GPU -* [Protobuf](https://github.com/google/protobuf) for reading [onnx](https://github.com/onnx/onnx) files -* [Half](http://half.sourceforge.net/) - IEEE 754-based half-precision floating point library -* [pybind11](https://pybind11.readthedocs.io/en/stable/) - for python bindings -* [JSON](https://github.com/nlohmann/json) - for model serialization to json string format -* [MessagePack](https://msgpack.org/index.html) - for model serialization to binary format -* [SQLite3](https://www.sqlite.org/index.html) - to create database of kernels' tuning information or execute queries on existing database +* [Protobuf](https://github.com/google/protobuf) for reading [onnx](https://github.com/onnx/onnx) + files +* [Half](http://half.sourceforge.net/), an IEEE 754-based half-precision floating point library +* [pybind11](https://pybind11.readthedocs.io/en/stable/) for python bindings +* [JSON](https://github.com/nlohmann/json) for model serialization to json string format +* [MessagePack](https://msgpack.org/index.html) for model serialization to binary format +* [SQLite3](https://www.sqlite.org/index.html) to create database of kernels' tuning information or run queries on existing database -#### Use the ROCm build tool [rbuild](https://github.com/RadeonOpenCompute/rbuild). +### Use the ROCm build tool [rbuild](https://github.com/RadeonOpenCompute/rbuild). -In this approach, we use the [rbuild](https://github.com/RadeonOpenCompute/rbuild) build tool to -build MIGraphX. The specific steps are as follows: +1. Install `rocm-cmake`, `pip3`, `rocblas`, and `miopen-hip`: -1) Install rocm-cmake, pip3, rocblas, and miopen-hip with the command + ```bash + sudo apt install -y rocm-cmake python3-pip rocblas miopen-hip + ``` -``` -sudo apt install -y rocm-cmake python3-pip rocblas miopen-hip -``` +2. Install [rbuild](https://github.com/RadeonOpenCompute/rbuild) (sudo may be required): -2) Install [rbuild](https://github.com/RadeonOpenCompute/rbuild) (sudo may be required here.) + ```bash + pip3 install https://github.com/RadeonOpenCompute/rbuild/archive/master.tar.gz + ``` -``` -pip3 install https://github.com/RadeonOpenCompute/rbuild/archive/master.tar.gz -``` +3. Build MIGraphX source code: -3) Build MIGraphX source code + ```bash + rbuild build -d depend -B build + ``` -``` -rbuild build -d depend -B build +Once completed, all prerequisites are in the `depend` folder and MIGraphX is in the `build` directory. + +```note +If you get an `rbuild: command not found` error, it's because `rbuild` is installed in `$HOME/.local/bin`, +which is not in `PATH`. You can either export PATH as `export PATH=$HOME/.local/bin:$PATH` to add +the folder to `PATH`, or add the option `--prefix /usr/local` in the pip3 command when installing `rbuild`. ``` -then all the prerequisites are in the folder `depend`, and MIGraphX is built in the `build` directory. +### Use CMake to build MIGraphX -Also note that you may meet the error of `rbuild: command not found`. It is because rbuild is installed -at `$HOME/.local/bin`, which is not in `PATH`. You can either export PATH as `export PATH=$HOME/.local/bin:$PATH` -to add the folder to `PATH` or add the option `--prefix /usr/local` in the pip3 command when installing rbuild. +1. Install the prerequisites: -#### Use cmake to build MIGraphX + ```bash + rbuild prepare -d depend + ``` -If using this approach, we need to install the prerequisites, configure the cmake, and then build the source. + This puts all the prerequisites are in `depend` the folder. They can be used in the `cmake` + configuration as `-DCMAKE_PREFIX_PATH=depend`. -##### Installing the prerequisites + If you have sudo access, as an alternative to the `rbuild` command, you can install the prerequisites + in the same way as a Dockerfile, by calling `./tools/install_prereqs.sh`. -For convenience, the prerequisites can be built automatically with rbuild as: + By default, all prerequisites are installed at the default location (`/usr/local`) and are accessible by all + users. For the default location, `sudo` is required to run the script. You can also specify a different + location using `./tools/install_prereqs.sh $custom_location`. -``` -rbuild prepare -d depend -``` +2. Go to the project folder and create a `build` directory: -then all the prerequisites are in the folder `depend`, and they can be used in the `cmake` configuration -as `-DCMAKE_PREFIX_PATH=depend`. + ```bash + mkdir build + cd build + ``` -If you have sudo access, as an alternative to the rbuild command, you can install the prerequisites just -like in the dockerfile by calling `./tools/install_prereqs.sh`. +3. Configure CMake. If the prerequisites are installed at the default location `/usr/local`, use: -(Note that this script is for Ubuntu. By default, all prerequisites are installed at the default location `/usr/local` -and are accessible by all users. For the default location, `sudo` is required to run the script. -You can also specify a location at which the prerequisites are installed with `./tools/install_prereqs.sh $your_loc`.) + ```bash + CXX=/opt/rocm/llvm/bin/clang++ cmake .. + ``` -##### Building MIGraphX source and install libs + Otherwise, you need to set `-DCMAKE_PREFIX_PATH=$your_loc` to configure CMake. -With the above prerequisites installed, we can build source as: +4. Build MIGraphX source code: -1) Go to the project folder and create a `build` directory: + ```cpp + make -j$(nproc) + ``` + You can verify this using: -``` -mkdir build -cd build -``` + ```cpp + make -j$(nproc) check + ``` -2) Configure the cmake. If the prerequisites are installed at the default location `/usr/local`, the command is: +5. Install MIGraphX libraries: -``` -CXX=/opt/rocm/llvm/bin/clang++ cmake .. -``` -Otherwise, you need to set `-DCMAKE_PREFIX_PATH=$your_loc` to configure the cmake. + ```cpp + make install + ``` -3) Build MIGraphX source code +### Use Docker -``` -make -j$(nproc) -``` +The easiest way to set up the development environment is to use Docker. -Correctness can be verified as: +1. With the Dockerfile, build a Docker image: -``` -make -j$(nproc) check -``` + ```bash + docker build -t migraphx . + ``` -MIGraphX libs can be installed as: +2. Enter the development environment using `docker run`: -``` -make install -``` + ```bash + docker run --device='/dev/kfd' --device='/dev/dri' -v=`pwd`:/code/AMDMIGraphX -w /code/AMDMIGraphX --group-add video -it migraphx + ``` -#### Use docker +3. In the Docker container, all required prerequisites are already installed, so you can go to the folder + `/code/AMDMIGraphX` and follow the steps (starting from 2) in the + [Use CMake to build MIGraphX](#use-cmake-to-build-migraphx). -The easiest way to setup the development environment is to use docker. With the dockerfile, you can build a docker image as: +## Using the MIGraphX Python module - docker build -t migraphx . +To use MIGraphX's Python module, you can set `PYTHONPATH` or use the `.deb` package: -Then to enter the developement environment use `docker run`: +* Setting `PYTHONPATH`: - docker run --device='/dev/kfd' --device='/dev/dri' -v=`pwd`:/code/AMDMIGraphX -w /code/AMDMIGraphX --group-add video -it migraphx + ```bash + export PYTHONPATH=/opt/rocm/lib:$PYTHONPATH + ``` -In the docker container, all the required prerequisites are already installed, so users can just go to the folder -`/code/AMDMIGraphX` and follow the steps in the above [Build MIGraphX source and install -libs](#building-migraphx-source-and-install-libs) -section to build MIGraphX source. +* Creating the `deb` package: -### Using MIGraphX Python Module -To use MIGraphX's Python module, please either set `PYTHONPATH` or use `.deb` package as explained below: + ```bash + make package + ``` -- Setting `PYTHONPATH` : -``` -export PYTHONPATH=/opt/rocm/lib:$PYTHONPATH -``` -- Creating and installing the package: + This provides the path for .deb package. -To create deb package: -``` -make package -``` -This will provide the path of .deb package. + To install: -To install: -``` -dpkg -i -``` + ```bash + dpkg -i + ``` -### Calling MIGraphX APIs -To use MIGraphX's C/C++ API in your cmake project, we need to set `CMAKE_PREFIX_PATH` to the MIGraphX -installation location and then do -``` +## Calling MIGraphX APIs + +To use MIGraphX's C/C++ API in your CMake project, you must set `CMAKE_PREFIX_PATH` to the +MIGraphX installation location and run: + +```bash find_package(migraphx) target_link_libraries(myApp migraphx::c) ``` -Where `myApp` is the cmake target in your project. + +Where `myApp` is the CMake target in your project. ## Building for development -Using rbuild, the dependencies for development can be installed with: +Using `rbuild`, you can install the dependencies for development with: -``` +```bash rbuild develop ``` -This will install the dependencies for development into the `deps` directory and -configure `cmake` to use those dependencies in the `build` directory. These -directories can be changed by passing the `--deps-dir` and `--build-dir` flags -to `rbuild` command: +This installs development dependencies in the `deps` directory and configures `cmake` to use those +dependencies in the `build` directory. You can change these directories by passing the `--deps-dir` and +`--build-dir` flags to the `rbuild` command: -``` +```bash rbuild develop --build-dir build_rocm_55 --deps-dir /home/user/deps_dir ``` @@ -223,12 +227,12 @@ Depending on your setup `sudo` may be required for the pip install. All the code is formatted using clang-format. To format a file, use: -``` +```clang clang-format-10 -style=file -i ``` Also, githooks can be installed to format the code per-commit: -``` +```bash ./.githooks/install ``` diff --git a/requirements.txt b/requirements.txt index f35758873f6..1d3ee5d6948 100755 --- a/requirements.txt +++ b/requirements.txt @@ -29,4 +29,4 @@ pybind/pybind11@d159a563383d10c821ba7b2a71905d1207db6de4 --build msgpack/msgpack-c@cpp-3.3.0 -DMSGPACK_BUILD_TESTS=Off sqlite3@3.17 -DCMAKE_POSITION_INDEPENDENT_CODE=On ROCmSoftwarePlatform/composable_kernel@70eefcf4f263aa5c25f3c9ff0db8f6f199ef0fb9 -DCK_BUILD_JIT_LIB=On -DCMAKE_POSITION_INDEPENDENT_CODE=On -ROCmSoftwarePlatform/rocMLIR@507bb94ce7873786486d296ec81d2eadaab49003 -DBUILD_FAT_LIBROCKCOMPILER=On \ No newline at end of file +ROCmSoftwarePlatform/rocMLIR@3700afd2564e21267a4d1fd8f1f80465f45daa93 -DBUILD_FAT_LIBROCKCOMPILER=On diff --git a/src/quantization.cpp b/src/quantization.cpp index 1716c31e19d..057c1e49def 100644 --- a/src/quantization.cpp +++ b/src/quantization.cpp @@ -147,8 +147,8 @@ void quantize_int8(program& prog, run_passes(prog, {quantize_int8_pass{ins_names, *int8_quant_params}, - optimize_module{}, simplify_qdq{}, + optimize_module{}, dead_code_elimination{}}); } diff --git a/test/py/CMakeLists.txt b/test/py/CMakeLists.txt index b0662c9924f..5bfd54fa51d 100755 --- a/test/py/CMakeLists.txt +++ b/test/py/CMakeLists.txt @@ -40,7 +40,7 @@ function(add_py_venv_fixture FIXTURE_NAME VIRTUAL_ENV_DIR REQUIREMENTS_FILE) set(PYTHON_EXECUTABLE ${PYTHON_${PYTHON_VERSION}_EXECUTABLE}) if(NOT TEST py_${PYTHON_VERSION}_${FIXTURE_NAME}_initialize_env) - if (NOT (${FIXTURE_NAME} STREQUAL "onnx" AND ${PYTHON_VERSION} STREQUAL ${PYTHON_VERSION_TO_DISABLE_ONNX})) + if (NOT (${PYTHON_VERSION} STREQUAL ${PYTHON_VERSION_TO_DISABLE_ONNX})) add_test(NAME py_${PYTHON_VERSION}_${FIXTURE_NAME}_initialize_env COMMAND ${PYTHON_EXECUTABLE} -m venv ${VIRTUAL_ENV_DIR}/${PYTHON_VERSION} --clear) set_tests_properties(py_${PYTHON_VERSION}_${FIXTURE_NAME}_initialize_env PROPERTIES FIXTURES_SETUP ${FIXTURE_NAME}_${PYTHON_VERSION}_INIT_VENV) set(PYTHON_EXECUTABLE ${VIRTUAL_ENV_DIR}/${PYTHON_VERSION}/bin/python) @@ -61,8 +61,12 @@ function(add_py_test NAME SCRIPT FIXTURE_NAME VENV_DIR) "PYTHONMALLOC=debug" "MALLOC_CHECK_=3" ) - set(PYTHON_EXECUTABLE ${VENV_DIR}/${PYTHON_VERSION}/bin/python) - if(NOT (${FIXTURE_NAME} STREQUAL "onnx" AND ${PYTHON_VERSION} STREQUAL ${PYTHON_VERSION_TO_DISABLE_ONNX})) + if(MIGRAPHX_DISABLE_VIRTUAL_ENV) + set(PYTHON_EXECUTABLE ${PYTHON_${PYTHON_VERSION}_EXECUTABLE}) + else() + set(PYTHON_EXECUTABLE ${VENV_DIR}/${PYTHON_VERSION}/bin/python) + endif() + if(NOT ${PYTHON_VERSION} STREQUAL ${PYTHON_VERSION_TO_DISABLE_ONNX}) add_test( NAME test_py_${PYTHON_VERSION}_${NAME} COMMAND ${ENV_COMMAND} ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${SCRIPT} ${ARGN}) diff --git a/test/py/requirements-onnx.txt b/test/py/requirements-onnx.txt index fc6964ec664..23095d43849 100644 --- a/test/py/requirements-onnx.txt +++ b/test/py/requirements-onnx.txt @@ -26,4 +26,4 @@ onnx==1.14.1 protobuf==3.20.2 numpy==1.21.6 packaging==23.0 -pytest==6.0.1 \ No newline at end of file +pytest==6.0.1 diff --git a/test/py/requirements.txt b/test/py/requirements.txt index 83194a34017..c643dfe0833 100644 --- a/test/py/requirements.txt +++ b/test/py/requirements.txt @@ -22,4 +22,4 @@ # THE SOFTWARE. ##################################################################################### -numpy==1.19.5 +numpy==1.21.6