Skip to content

GitLab

Commit 5f215b71 authored by charlie's avatar charlie
Browse files

Merge branch 'develop' of github.com:ROCmSoftwarePlatform/AMDMIGraphX into dyn_dim_onnx_parser

parents 42601741 adbafc06
Show whitespace changes
Inline Side-by-side
Showing with 3733 additions and 3608 deletions
Dockerfile
View file @ 5f215b71
...@@ -86,7 +86,7 @@ RUN git clone --single-branch --branch ${ONNXRUNTIME_BRANCH} --recursive ${ONNXR ...@@ -86,7 +86,7 @@ RUN git clone --single-branch --branch ${ONNXRUNTIME_BRANCH} --recursive ${ONNXR
ADD tools/build_and_test_onnxrt.sh /onnxruntime/build_and_test_onnxrt.sh ADD tools/build_and_test_onnxrt.sh /onnxruntime/build_and_test_onnxrt.sh
RUN PATH=/opt/cmake/bin:$PATH cget -p /usr/local install ROCmSoftwarePlatform/llvm-project-mlir@02078ce236ad90e3aec04c0c770ef5bfc99e49c2 RUN cget -p /usr/local install ROCmSoftwarePlatform/llvm-project-mlir@26a4b3cfc0a1a15181490f24ae461608fef1b04e -DBUILD_MIXR_TARGET=On
ENV MIOPEN_FIND_DB_PATH=/tmp/miopen/find-db ENV MIOPEN_FIND_DB_PATH=/tmp/miopen/find-db
ENV MIOPEN_USER_DB_PATH=/tmp/miopen/user-db ENV MIOPEN_USER_DB_PATH=/tmp/miopen/user-db
......
examples/migraphx/custom_op_hip_kernel/CMakeLists.txt 0 → 100755
View file @ 5f215b71
#####################################################################################
# The MIT License (MIT)
#
# Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#####################################################################################
cmake_minimum_required(VERSION 3.5)
project (custom_hip_kernel)
set (CMAKE_CXX_STANDARD 14)
set (EXAMPLE custom_op_hip_kernel)
list (APPEND CMAKE_PREFIX_PATH /opt/rocm/hip /opt/rocm)
find_package (migraphx REQUIRED)
find_package (hip REQUIRED)
message("source file: " ${EXAMPLE}.cpp " ---> bin: " ${EXAMPLE})
add_executable(${EXAMPLE} ${EXAMPLE}.cpp)
target_link_libraries(${EXAMPLE} migraphx::c hip::device)
examples/migraphx/custom_op_hip_kernel/README.md 0 → 100644
View file @ 5f215b71
# Custom Kernel using MIGraphX API.
This is an example of a custom operator implementation using MIGraphX's C/C++ APIs. It also demonstrates how to use this custom op in conjunction with rest of MIGraphX operators to build and run MIGraphX program on GPU.
Kernels can be written in either HIP, MIOpen, or by using RocBLAS library. This particular example uses **HIP**.
To build the example, ensure ROCm is installed at `/opt/rocm`.
1. `export LD_LIBRARY_PATH=/opt/rocm/lib:$LD_LIBRARY_PATH`
2. `cd $MIGRAPHX_SRC/examples/migraphx/custom_op_hip_kernel/`
3. `mkdir build && cd build`
4. `CXX=/opt/rocm/llvm/bin/clang++ cmake .. && make`
5. `./custom_op_hip_kernel`
\ No newline at end of file
examples/migraphx/custom_op_hip_kernel/custom_op_hip_kernel.cpp 0 → 100644
View file @ 5f215b71
/*
* The MIT License (MIT)
*
* Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <algorithm>
#include <hip/hip_runtime.h>
#include <migraphx/migraphx.hpp> // MIGraphX's C++ API
#include <numeric>
#define MIGRAPHX_HIP_ASSERT(x) (assert((x) == hipSuccess))
/*
* Square each element in the array A and write to array C.
*/
template <typename T>
__global__ void vector_square(T* C_d, const T* A_d, size_t N)
{
size_t offset = (hipBlockIdx_x * hipBlockDim_x + hipThreadIdx_x);
size_t stride = hipBlockDim_x * hipGridDim_x;
for(size_t i = offset; i < N; i += stride)
{
C_d[i] = A_d[i] * A_d[i];
}
}
struct square_custom_op final : migraphx::experimental_custom_op_base
{
virtual std::string name() const override { return "square_custom_op"; }
virtual migraphx::argument
compute(migraphx::context ctx, migraphx::shape, migraphx::arguments inputs) const override
{
// if compile options has offload_copy = true then, parameters and outputs will be
// automatically copied to and from GPUs' memory. Here assume that `inputs` arguments are
// already in the GPU, so no need to do Malloc, Free or Memcpy. Last element in the `inputs`
// is output argument, so it should be returned from compute method.
auto* input_buffer = reinterpret_cast<float*>(inputs[0].data());
auto* output_buffer = reinterpret_cast<float*>(inputs[1].data());
size_t n_elements = inputs[0].get_shape().bytes() / sizeof(inputs[0].get_shape().type());
MIGRAPHX_HIP_ASSERT(hipSetDevice(0));
const unsigned blocks = 512;
const unsigned threads_per_block = 256;
// cppcheck-suppress UseDeviceLaunch
hipLaunchKernelGGL(vector_square,
dim3(blocks),
dim3(threads_per_block),
0,
ctx.get_queue<hipStream_t>(),
output_buffer,
input_buffer,
n_elements);
return inputs[1];
}
virtual migraphx::shape compute_shape(migraphx::shapes inputs) const override
{
if(inputs.size() != 2)
{
throw std::runtime_error("square_custom_op must have 2 arguments");
}
if(inputs[0] != inputs[1])
{
throw std::runtime_error("Inputs to the square_custom_op must have same Shape");
}
return inputs.back();
}
};
int main(int argc, const char* argv[])
{
square_custom_op square_op;
migraphx::register_experimental_custom_op(square_op);
migraphx::program p;
migraphx::shape s{migraphx_shape_float_type, {32, 256}};
migraphx::module m = p.get_main_module();
auto x = m.add_parameter("x", s);
auto neg_ins = m.add_instruction(migraphx::operation("neg"), x);
// add allocation for the custom_kernel's output buffer
auto alloc = m.add_allocation(s);
auto custom_kernel =
m.add_instruction(migraphx::operation("square_custom_op"), {neg_ins, alloc});
auto relu_ins = m.add_instruction(migraphx::operation("relu"), {custom_kernel});
m.add_return({relu_ins});
migraphx::compile_options options;
// set offload copy to true for GPUs
options.set_offload_copy();
p.compile(migraphx::target("gpu"), options);
migraphx::program_parameters pp;
std::vector<float> x_data(s.bytes() / sizeof(s.type()));
std::iota(x_data.begin(), x_data.end(), 0);
pp.add("x", migraphx::argument(s, x_data.data()));
auto results = p.eval(pp);
auto result = results[0];
std::vector<float> expected_result = x_data;
std::transform(expected_result.begin(),
expected_result.end(),
expected_result.begin(),
[](auto i) { return std::pow(i, 2); });
if(bool{result == migraphx::argument(s, expected_result.data())})
{
std::cout << "Successfully executed custom HIP kernel example\n";
}
else
{
std::cout << "Custom HIP kernel example failed\n";
}
return 0;
}
examples/migraphx/custom_op_miopen_kernel/CMakeLists.txt 0 → 100755
View file @ 5f215b71
#####################################################################################
# The MIT License (MIT)
#
# Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#####################################################################################
cmake_minimum_required(VERSION 3.5)
project (custom_miopen_kernel)
set (CMAKE_CXX_STANDARD 14)
set (EXAMPLE custom_op_miopen_kernel)
list (APPEND CMAKE_PREFIX_PATH /opt/rocm/hip /opt/rocm)
find_package (migraphx REQUIRED)
find_package (miopen REQUIRED)
message("source file: " ${EXAMPLE}.cpp " ---> bin: " ${EXAMPLE})
add_executable(${EXAMPLE} ${EXAMPLE}.cpp)
target_link_libraries(${EXAMPLE} migraphx::c MIOpen)
examples/migraphx/custom_op_miopen_kernel/README.md 0 → 100644
View file @ 5f215b71
# Custom MIOpen Kernel using MIGraphX API.
This is an example of a custom operator implementation using MIGraphX's C/C++ APIs. It also demonstrates how to use this custom op in conjunction with rest of MIGraphX operators to build and run MIGraphX program on GPU.
Kernels can be written in either HIP, MIOpen, or by using RocBLAS library. This particular example uses **MIOpen** library calls.
To build and run example, ensure ROCm is installed at `/opt/rocm`.
1. `export LD_LIBRARY_PATH=/opt/rocm/lib:$LD_LIBRARY_PATH`
2. `cd $MIGRAPHX_SRC/examples/migraphx/custom_op_miopen_kernel/`
3. `mkdir build && cd build`
4. `cmake .. && make`
5. `./custom_op_miopen_kernel`
examples/migraphx/custom_op_miopen_kernel/custom_op_miopen_kernel.cpp 0 → 100644
View file @ 5f215b71
/*
* The MIT License (MIT)
*
* Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <algorithm>
#include <hip/hip_runtime.h>
#include <migraphx/migraphx.h>
#include <miopen/miopen.h>
#include <migraphx/migraphx.hpp> // MIGraphX's C++ API
#include <numeric>
#include <stdexcept>
#define MIGRAPHX_MIOPEN_ASSERT(x) (assert((x) == miopenStatusSuccess))
#define MIGRAPHX_HIP_ASSERT(x) (assert((x) == hipSuccess))
inline miopenTensorDescriptor_t make_miopen_tensor(const migraphx::shape& s, bool pack = false)
{
miopenTensorDescriptor_t t;
MIGRAPHX_MIOPEN_ASSERT(miopenCreateTensorDescriptor(&t));
// Convert to ints
auto s_lens = s.lengths();
std::vector<int> lens(s_lens.begin(), s_lens.end());
auto s_strides = s.strides();
std::vector<int> strides(s_strides.begin(), s_strides.end());
miopenDataType_t d;
if(s.type() == migraphx_shape_float_type)
d = miopenFloat;
else if(s.type() == migraphx_shape_half_type)
d = miopenHalf;
else if(s.type() == migraphx_shape_int32_type)
d = miopenInt32;
else if(s.type() == migraphx_shape_int8_type)
{
if(pack)
{
// update the lens and corresponding strides
d = miopenInt8x4;
lens[1] = ((lens[1] + 3) / 4) * 4;
strides[0] = strides[1] * lens[1];
}
else
{
d = miopenInt8;
}
}
else
{
throw("MAKE_TENSOR: unsupported type");
}
miopenSetTensorDescriptor(t, d, s_lens.size(), lens.data(), strides.data());
return t;
}
inline auto make_miopen_handle(migraphx::context& ctx)
{
MIGRAPHX_HIP_ASSERT(hipSetDevice(0));
auto* stream = ctx.get_queue<hipStream_t>();
miopenHandle_t out;
MIGRAPHX_MIOPEN_ASSERT(miopenCreateWithStream(&out, stream));
return out;
}
inline auto make_activation_descriptor(miopenActivationMode_t mode,
double alpha = 0,
double beta = 0,
double gamma = 0)
{
miopenActivationDescriptor_t ad;
MIGRAPHX_MIOPEN_ASSERT(miopenCreateActivationDescriptor(&ad));
miopenSetActivationDescriptor(ad, mode, alpha, beta, gamma);
return ad;
}
struct abs_custom_op final : migraphx::experimental_custom_op_base
{
virtual std::string name() const override { return "abs_custom_op"; }
virtual migraphx::argument compute(migraphx::context ctx,
migraphx::shape output_shape,
migraphx::arguments args) const override
{
float alpha = 1;
float beta = 0;
// MIOpen kernel call takes raw buffer pointers for the TensorData. These Buffer pointers
// must be accompanied with Tensor Description e.g. shape, type, strides, dimensionality.
// Following `make_miopen_tensor` makes such tensor descriptors to pass as parameter to
// MIOpen kernel call.
auto y_desc = make_miopen_tensor(output_shape);
auto x_desc = make_miopen_tensor(args[0].get_shape());
// create MIOpen stream handle
auto miopen_handle = make_miopen_handle(ctx);
// MIOpen has generic kernel for many different kinds of activation functions.
// Each such generic call must be accompanied with description of what kind of activation
// computation to perform
auto ad = make_activation_descriptor(miopenActivationABS, 0, 0, 0);
miopenActivationForward(
miopen_handle, ad, &alpha, x_desc, args[0].data(), &beta, y_desc, args[1].data());
return args[1];
}
virtual migraphx::shape compute_shape(migraphx::shapes inputs) const override
{
if(inputs.size() != 2)
{
throw std::runtime_error("abs_custom_op must have two input arguments");
}
if(inputs[0] != inputs[1])
{
throw std::runtime_error("Input arguments to abs_custom_op must have same shape");
}
return inputs.back();
}
};
int main(int argc, const char* argv[])
{
abs_custom_op abs_op;
migraphx::register_experimental_custom_op(abs_op);
migraphx::program p;
migraphx::shape s{migraphx_shape_float_type, {32, 256}};
migraphx::module m = p.get_main_module();
auto x = m.add_parameter("x", s);
auto neg_ins = m.add_instruction(migraphx::operation("neg"), {x});
// add allocation for the custom_kernel's output buffer
auto alloc = m.add_allocation(s);
auto custom_kernel = m.add_instruction(migraphx::operation("abs_custom_op"), {neg_ins, alloc});
auto relu_ins = m.add_instruction(migraphx::operation("relu"), {custom_kernel});
m.add_return({relu_ins});
migraphx::compile_options options;
// set offload copy to true for GPUs
options.set_offload_copy();
p.compile(migraphx::target("gpu"), options);
migraphx::program_parameters prog_params;
std::vector<float> x_data(s.bytes() / sizeof(s.type()));
std::iota(x_data.begin(), x_data.end(), 0);
prog_params.add("x", migraphx::argument(s, x_data.data()));
auto results = p.eval(prog_params);
auto result = results[0];
std::vector<float> expected_result = x_data;
std::transform(expected_result.begin(),
expected_result.end(),
expected_result.begin(),
[](auto i) { return std::abs(i); });
if(bool{result == migraphx::argument(s, expected_result.data())})
{
std::cout << "Successfully executed custom MIOpen kernel example with MIGraphX\n";
}
else
{
std::cout << "Custom MIOpen kernel example failed\n";
}
return 0;
}
examples/migraphx/custom_op_rocblas_kernel/CMakeLists.txt 0 → 100755
View file @ 5f215b71
#####################################################################################
# The MIT License (MIT)
#
# Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#####################################################################################
cmake_minimum_required(VERSION 3.5)
project (custom_rocblas_kernel)
set (CMAKE_CXX_STANDARD 14)
set (EXAMPLE custom_op_rocblas_kernel)
list (APPEND CMAKE_PREFIX_PATH /opt/rocm/hip /opt/rocm)
find_package (migraphx REQUIRED)
find_package (rocblas REQUIRED)
message("source file: " ${EXAMPLE}.cpp " ---> bin: " ${EXAMPLE})
add_executable(${EXAMPLE} ${EXAMPLE}.cpp)
target_link_libraries(${EXAMPLE} migraphx::c roc::rocblas)
examples/migraphx/custom_op_rocblas_kernel/README.md 0 → 100644
View file @ 5f215b71
# Custom rocBLAS Kernel using MIGraphX API.
This is an example of a custom operator implementation using MIGraphX's C/C++ APIs. It also demonstrates how to use this custom op in conjunction with rest of MIGraphX operators to build and run MIGraphX program on GPU.
Kernels can be written in either HIP, MIOpen, or by using RocBLAS library. This particular example uses **rocBLAS** library calls.
To build and run the example, ensure ROCm is installed at `/opt/rocm`.
1. `export LD_LIBRARY_PATH=/opt/rocm/lib:$LD_LIBRARY_PATH`
2. `cd $MIGRAPHX_SRC/examples/migraphx/custom_op_rocblas_kernel/`
3. `mkdir build && cd build`
4. `cmake .. && make`
5. `./custom_op_rocblas_kernel`
examples/migraphx/custom_op_rocblas_kernel/custom_op_rocblas_kernel.cpp 0 → 100644
View file @ 5f215b71
/*
* The MIT License (MIT)
*
* Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <algorithm>
#include <hip/hip_runtime.h>
#include <rocblas.h>
#include <migraphx/migraphx.h>
#include <migraphx/migraphx.hpp> // MIGraphX's C++ API
#include <numeric>
#include <stdexcept>
#define MIGRAPHX_ROCBLAS_ASSERT(x) (assert((x) == rocblas_status::rocblas_status_success))
#define MIGRAPHX_HIP_ASSERT(x) (assert((x) == hipSuccess))
rocblas_handle create_rocblas_handle_ptr()
{
rocblas_handle handle;
MIGRAPHX_ROCBLAS_ASSERT(rocblas_create_handle(&handle));
return rocblas_handle{handle};
}
rocblas_handle create_rocblas_handle_ptr(migraphx::context& ctx)
{
MIGRAPHX_HIP_ASSERT(hipSetDevice(0));
rocblas_handle rb = create_rocblas_handle_ptr();
auto* stream = ctx.get_queue<hipStream_t>();
MIGRAPHX_ROCBLAS_ASSERT(rocblas_set_stream(rb, stream));
return rb;
}
struct sscal_custom_op final : migraphx::experimental_custom_op_base
{
virtual std::string name() const override { return "sscal_custom_op"; }
virtual migraphx::argument compute(migraphx::context ctx,
migraphx::shape output_shape,
migraphx::arguments args) const override
{
// create rocblas stream handle
auto rocblas_handle = create_rocblas_handle_ptr(ctx);
rocblas_int n = args[1].get_shape().lengths()[0];
float* alpha = reinterpret_cast<float*>(args[0].data());
float* vec_ptr = reinterpret_cast<float*>(args[1].data());
MIGRAPHX_ROCBLAS_ASSERT(rocblas_sscal(rocblas_handle, n, alpha, vec_ptr, 1));
return args[1];
}
virtual migraphx::shape compute_shape(migraphx::shapes inputs) const override
{
if(inputs.size() != 2)
{
throw std::runtime_error("sscal_custom_op must have 2 input arguments");
}
if(inputs[0].lengths().size() != 1 || inputs[0].lengths()[0] != 1)
{
throw std::runtime_error("first input argument to sscal_custom_op must be a scalar");
}
if(inputs[1].lengths().size() != 1)
{
throw std::runtime_error(
"second input argument to sscal_custom_op must be a vector with dimension one");
}
return inputs.back();
}
};
int main(int argc, const char* argv[])
{
// computes ReLU(neg(x) * scale)
sscal_custom_op sscal_op;
migraphx::register_experimental_custom_op(sscal_op);
migraphx::program p;
migraphx::shape x_shape{migraphx_shape_float_type, {8192}};
migraphx::shape scale_shape{migraphx_shape_float_type, {1}};
migraphx::module m = p.get_main_module();
auto x = m.add_parameter("x", x_shape);
auto scale = m.add_parameter("scale", scale_shape);
auto neg_ins = m.add_instruction(migraphx::operation("neg"), {x});
auto custom_kernel =
m.add_instruction(migraphx::operation("sscal_custom_op"), {scale, neg_ins});
auto relu_ins = m.add_instruction(migraphx::operation("relu"), {custom_kernel});
m.add_return({relu_ins});
migraphx::compile_options options;
// set offload copy to true for GPUs
options.set_offload_copy();
p.compile(migraphx::target("gpu"), options);
migraphx::program_parameters pp;
std::vector<float> x_data(x_shape.bytes() / sizeof(x_shape.type()));
std::vector<float> scale_data{-1};
std::iota(x_data.begin(), x_data.end(), 0);
pp.add("x", migraphx::argument(x_shape, x_data.data()));
pp.add("scale", migraphx::argument(scale_shape, scale_data.data()));
auto results = p.eval(pp);
auto result = results[0];
std::vector<float> expected_result = x_data;
if(bool{result == migraphx::argument(x_shape, expected_result.data())})
{
std::cout << "Successfully executed custom rocBLAS kernel example\n";
}
else
{
std::cout << "Custom rocBLAS kernel example failed\n";
}
return 0;
}
examples/vision/python_yolov4/yolov4_inference.ipynb
View file @ 5f215b71
...@@ -80,7 +80,7 @@ ...@@ -80,7 +80,7 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"if not os.path.exists(\"yolov4_fp16.mxr\"):\n", "if not os.path.exists(\"yolov4_fp16.mxr\"):\n",
" !/opt/rocm/bin/migraphx-driver compile ./utilities/yolov4.onnx --gpu --enable-offload-copy --fp16ref --binary -o yolov4_fp16.mxr\n", " !/opt/rocm/bin/migraphx-driver compile ./utilities/yolov4.onnx --gpu --enable-offload-copy --fp16 --binary -o yolov4_fp16.mxr\n",
"if not os.path.exists(\"yolov4.mxr\"):\n", "if not os.path.exists(\"yolov4.mxr\"):\n",
" !/opt/rocm/bin/migraphx-driver compile ./utilities/yolov4.onnx --gpu --enable-offload-copy --binary -o yolov4.mxr" " !/opt/rocm/bin/migraphx-driver compile ./utilities/yolov4.onnx --gpu --enable-offload-copy --binary -o yolov4.mxr"
] ]
......
src/CMakeLists.txt
View file @ 5f215b71
...@@ -88,6 +88,7 @@ add_library(migraphx ...@@ -88,6 +88,7 @@ add_library(migraphx
shape.cpp shape.cpp
simplify_algebra.cpp simplify_algebra.cpp
simplify_reshapes.cpp simplify_reshapes.cpp
target_assignments.cpp
tmp_dir.cpp tmp_dir.cpp
value.cpp value.cpp
verify_args.cpp verify_args.cpp
......
src/driver/alexnet.cpp
View file @ 5f215b71
/* /*
* The MIT License (MIT) * The MIT License (MIT)
* *
...@@ -21,10 +22,10 @@ ...@@ -21,10 +22,10 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include <migraphx/operators.hpp> #include <migraphx/make_op.hpp>
#include <migraphx/program.hpp> #include <migraphx/program.hpp>
#include <migraphx/generate.hpp> #include <migraphx/generate.hpp>
#include <migraphx/apply_alpha_beta.hpp> #include <migraphx/json.hpp>
#include "models.hpp" #include "models.hpp"
namespace migraphx { namespace migraphx {
...@@ -34,173 +35,189 @@ inline namespace MIGRAPHX_INLINE_NS { ...@@ -34,173 +35,189 @@ inline namespace MIGRAPHX_INLINE_NS {
migraphx::program alexnet(unsigned batch) // NOLINT(readability-function-size) migraphx::program alexnet(unsigned batch) // NOLINT(readability-function-size)
{ {
migraphx::program p; migraphx::program p;
auto* mm = p.get_main_module(); migraphx::module_ref mmain = p.get_main_module();
auto m0 = auto x_main_module_0 = mmain->add_literal(migraphx::abs(
mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}}); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 0)));
auto mx0 = mm->add_literal( auto x_main_module_1 = mmain->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 0)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 1)));
auto mx1 = mm->add_literal( auto x_main_module_2 = mmain->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 4096}}, 1)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 2)));
auto mx2 = mm->add_literal( auto x_input_1 = mmain->add_parameter(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 2)); "input.1", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
auto mx3 = mm->add_literal( auto x_main_module_4 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 4096}}, 3)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 4096}}, 3));
auto mx4 = mm->add_literal( auto x_main_module_5 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 4)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 4));
auto mx5 = mm->add_literal( auto x_main_module_6 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 9216}}, 5)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 9216}}, 5));
auto mx6 = mm->add_literal( auto x_main_module_7 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 6)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 6));
auto mx7 = mm->add_literal(migraphx::generate_literal( auto x_main_module_8 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 7)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 4096}}, 7));
auto mx8 = mm->add_literal( auto x_main_module_9 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 8)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 8));
auto mx9 = mm->add_literal(migraphx::generate_literal( auto x_main_module_10 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 384, 3, 3}}, 9)); migraphx::shape{migraphx::shape::float_type, {256, 384, 3, 3}}, 9));
auto mx10 = mm->add_literal( auto x_main_module_11 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {384}}, 10)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 10));
auto mx11 = mm->add_literal(migraphx::generate_literal( auto x_main_module_12 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {384, 192, 3, 3}}, 11)); migraphx::shape{migraphx::shape::float_type, {384, 192, 3, 3}}, 11));
auto mx12 = mm->add_literal( auto x_main_module_13 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {192}}, 12)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {384}}, 12));
auto mx13 = mm->add_literal(migraphx::generate_literal( auto x_main_module_14 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {192, 64, 5, 5}}, 13)); migraphx::shape{migraphx::shape::float_type, {192, 64, 5, 5}}, 13));
auto mx14 = mm->add_literal( auto x_main_module_15 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 14)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {192}}, 14));
auto mx15 = mm->add_literal(migraphx::generate_literal( auto x_main_module_16 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 3, 11, 11}}, 15)); migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 15));
migraphx::op::convolution convolution16; auto x_main_module_17 = mmain->add_literal(
convolution16.padding = {2, 2}; migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 16));
convolution16.stride = {4, 4}; auto x_main_module_18 = mmain->add_literal(migraphx::generate_literal(
convolution16.dilation = {1, 1}; migraphx::shape{migraphx::shape::float_type, {64, 3, 11, 11}}, 17));
convolution16.group = 1; auto x_main_module_19 = mmain->add_literal(
auto mx16 = mm->add_instruction(convolution16, m0, mx15); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 18));
migraphx::op::broadcast broadcast17; auto x_main_module_20 = mmain->add_instruction(
broadcast17.axis = 1; migraphx::make_op(
broadcast17.broadcast_lens = {batch, 64, 55, 55}; "convolution",
auto mx17 = mm->add_instruction(broadcast17, mx14); migraphx::from_json_string(
migraphx::op::add add18; "{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[4,4]}")),
auto mx18 = mm->add_instruction(add18, mx16, mx17); x_input_1,
migraphx::op::relu relu19; x_main_module_18);
auto mx19 = mm->add_instruction(relu19, mx18); auto x_main_module_21 = mmain->add_instruction(
migraphx::op::pooling pooling20; migraphx::make_op("broadcast",
pooling20.mode = migraphx::op::pooling_mode::max; migraphx::from_json_string("{axis:1,out_lens:[1,64,55,55]}")),
pooling20.padding = {0, 0}; x_main_module_19);
pooling20.stride = {2, 2}; auto x_main_module_22 =
pooling20.lengths = {3, 3}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_20, x_main_module_21);
auto mx20 = mm->add_instruction(pooling20, mx19); auto x_main_module_23 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_22);
migraphx::op::convolution convolution21; auto x_main_module_24 = mmain->add_instruction(
convolution21.padding = {2, 2}; migraphx::make_op(
convolution21.stride = {1, 1}; "pooling",
convolution21.dilation = {1, 1}; migraphx::from_json_string(
convolution21.group = 1; "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
auto mx21 = mm->add_instruction(convolution21, mx20, mx13); x_main_module_23);
migraphx::op::broadcast broadcast22; auto x_main_module_25 = mmain->add_instruction(
broadcast22.axis = 1; migraphx::make_op(
broadcast22.broadcast_lens = {batch, 192, 27, 27}; "convolution",
auto mx22 = mm->add_instruction(broadcast22, mx12); migraphx::from_json_string(
migraphx::op::add add23; "{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[1,1]}")),
auto mx23 = mm->add_instruction(add23, mx21, mx22); x_main_module_24,
migraphx::op::relu relu24; x_main_module_14);
auto mx24 = mm->add_instruction(relu24, mx23); auto x_main_module_26 = mmain->add_instruction(
migraphx::op::pooling pooling25; migraphx::make_op("broadcast",
pooling25.mode = migraphx::op::pooling_mode::max; migraphx::from_json_string("{axis:1,out_lens:[1,192,27,27]}")),
pooling25.padding = {0, 0}; x_main_module_15);
pooling25.stride = {2, 2}; auto x_main_module_27 =
pooling25.lengths = {3, 3}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_25, x_main_module_26);
auto mx25 = mm->add_instruction(pooling25, mx24); auto x_main_module_28 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_27);
migraphx::op::convolution convolution26; auto x_main_module_29 = mmain->add_instruction(
convolution26.padding = {1, 1}; migraphx::make_op(
convolution26.stride = {1, 1}; "pooling",
convolution26.dilation = {1, 1}; migraphx::from_json_string(
convolution26.group = 1; "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
auto mx26 = mm->add_instruction(convolution26, mx25, mx11); x_main_module_28);
migraphx::op::broadcast broadcast27; auto x_main_module_30 = mmain->add_instruction(
broadcast27.axis = 1; migraphx::make_op(
broadcast27.broadcast_lens = {batch, 384, 13, 13}; "convolution",
auto mx27 = mm->add_instruction(broadcast27, mx10); migraphx::from_json_string(
migraphx::op::add add28; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
auto mx28 = mm->add_instruction(add28, mx26, mx27); x_main_module_29,
migraphx::op::relu relu29; x_main_module_12);
auto mx29 = mm->add_instruction(relu29, mx28); auto x_main_module_31 = mmain->add_instruction(
migraphx::op::convolution convolution30; migraphx::make_op("broadcast",
convolution30.padding = {1, 1}; migraphx::from_json_string("{axis:1,out_lens:[1,384,13,13]}")),
convolution30.stride = {1, 1}; x_main_module_13);
convolution30.dilation = {1, 1}; auto x_main_module_32 =
convolution30.group = 1; mmain->add_instruction(migraphx::make_op("add"), x_main_module_30, x_main_module_31);
auto mx30 = mm->add_instruction(convolution30, mx29, mx9); auto x_main_module_33 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_32);
migraphx::op::broadcast broadcast31; auto x_main_module_34 = mmain->add_instruction(
broadcast31.axis = 1; migraphx::make_op(
broadcast31.broadcast_lens = {batch, 256, 13, 13}; "convolution",
auto mx31 = mm->add_instruction(broadcast31, mx8); migraphx::from_json_string(
migraphx::op::add add32; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
auto mx32 = mm->add_instruction(add32, mx30, mx31); x_main_module_33,
migraphx::op::relu relu33; x_main_module_10);
auto mx33 = mm->add_instruction(relu33, mx32); auto x_main_module_35 = mmain->add_instruction(
migraphx::op::convolution convolution34; migraphx::make_op("broadcast",
convolution34.padding = {1, 1}; migraphx::from_json_string("{axis:1,out_lens:[1,256,13,13]}")),
convolution34.stride = {1, 1}; x_main_module_11);
convolution34.dilation = {1, 1}; auto x_main_module_36 =
convolution34.group = 1; mmain->add_instruction(migraphx::make_op("add"), x_main_module_34, x_main_module_35);
auto mx34 = mm->add_instruction(convolution34, mx33, mx7); auto x_main_module_37 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_36);
migraphx::op::broadcast broadcast35; auto x_main_module_38 = mmain->add_instruction(
broadcast35.axis = 1; migraphx::make_op(
broadcast35.broadcast_lens = {batch, 256, 13, 13}; "convolution",
auto mx35 = mm->add_instruction(broadcast35, mx6); migraphx::from_json_string(
migraphx::op::add add36; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
auto mx36 = mm->add_instruction(add36, mx34, mx35); x_main_module_37,
migraphx::op::relu relu37; x_main_module_16);
auto mx37 = mm->add_instruction(relu37, mx36); auto x_main_module_39 = mmain->add_instruction(
migraphx::op::pooling pooling38; migraphx::make_op("broadcast",
pooling38.mode = migraphx::op::pooling_mode::max; migraphx::from_json_string("{axis:1,out_lens:[1,256,13,13]}")),
pooling38.padding = {0, 0}; x_main_module_17);
pooling38.stride = {2, 2}; auto x_main_module_40 =
pooling38.lengths = {3, 3}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_38, x_main_module_39);
auto mx38 = mm->add_instruction(pooling38, mx37); auto x_main_module_41 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_40);
migraphx::op::flatten flatten39; auto x_main_module_42 = mmain->add_instruction(
flatten39.axis = 1; migraphx::make_op(
auto mx39 = mm->add_instruction(flatten39, mx38); "pooling",
migraphx::op::identity identity40; migraphx::from_json_string(
auto mx40 = mm->add_instruction(identity40, mx39); "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
migraphx::op::transpose transpose41; x_main_module_41);
transpose41.dims = {1, 0}; auto x_main_module_43 = mmain->add_instruction(
auto mx41 = mm->add_instruction(transpose41, mx5); migraphx::make_op("reshape", migraphx::from_json_string("{dims:[1,9216]}")),
migraphx::op::multibroadcast multibroadcast42; x_main_module_42);
multibroadcast42.output_lens = {batch, 4096}; auto x_main_module_44 = mmain->add_instruction(
auto mx42 = mm->add_instruction(multibroadcast42, mx4); migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
float dot43_alpha = 1; x_main_module_6);
float dot43_beta = 1; auto x_main_module_45 =
auto mx43 = migraphx::add_apply_alpha_beta( mmain->add_instruction(migraphx::make_op("dot"), x_main_module_43, x_main_module_44);
*mm, {mx40, mx41, mx42}, migraphx::make_op("dot"), dot43_alpha, dot43_beta); auto x_main_module_46 = mmain->add_instruction(
migraphx::op::relu relu44; migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
auto mx44 = mm->add_instruction(relu44, mx43); x_main_module_7);
migraphx::op::identity identity45; auto x_main_module_47 = mmain->add_instruction(
auto mx45 = mm->add_instruction(identity45, mx44); migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
migraphx::op::transpose transpose46; x_main_module_2);
transpose46.dims = {1, 0}; auto x_main_module_48 =
auto mx46 = mm->add_instruction(transpose46, mx3); mmain->add_instruction(migraphx::make_op("mul"), x_main_module_46, x_main_module_47);
migraphx::op::multibroadcast multibroadcast47; auto x_main_module_49 =
multibroadcast47.output_lens = {batch, 4096}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_45, x_main_module_48);
auto mx47 = mm->add_instruction(multibroadcast47, mx2); auto x_main_module_50 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_49);
float dot48_alpha = 1; auto x_main_module_51 = mmain->add_instruction(
float dot48_beta = 1; migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
auto mx48 = migraphx::add_apply_alpha_beta( x_main_module_4);
*mm, {mx45, mx46, mx47}, migraphx::make_op("dot"), dot48_alpha, dot48_beta); auto x_main_module_52 =
migraphx::op::relu relu49; mmain->add_instruction(migraphx::make_op("dot"), x_main_module_50, x_main_module_51);
auto mx49 = mm->add_instruction(relu49, mx48); auto x_main_module_53 = mmain->add_instruction(
migraphx::op::transpose transpose50; migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
transpose50.dims = {1, 0}; x_main_module_5);
auto mx50 = mm->add_instruction(transpose50, mx1); auto x_main_module_54 = mmain->add_instruction(
migraphx::op::multibroadcast multibroadcast51; migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
multibroadcast51.output_lens = {batch, 1000}; x_main_module_1);
auto mx51 = mm->add_instruction(multibroadcast51, mx0); auto x_main_module_55 =
float dot52_alpha = 1; mmain->add_instruction(migraphx::make_op("mul"), x_main_module_53, x_main_module_54);
float dot52_beta = 1; auto x_main_module_56 =
migraphx::add_apply_alpha_beta( mmain->add_instruction(migraphx::make_op("add"), x_main_module_52, x_main_module_55);
*mm, {mx49, mx50, mx51}, migraphx::make_op("dot"), dot52_alpha, dot52_beta); auto x_main_module_57 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_56);
auto x_main_module_58 = mmain->add_instruction(
migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
x_main_module_8);
auto x_main_module_59 =
mmain->add_instruction(migraphx::make_op("dot"), x_main_module_57, x_main_module_58);
auto x_main_module_60 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
x_main_module_9);
auto x_main_module_61 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
x_main_module_0);
auto x_main_module_62 =
mmain->add_instruction(migraphx::make_op("mul"), x_main_module_60, x_main_module_61);
auto x_main_module_63 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_59, x_main_module_62);
mmain->add_return({x_main_module_63});
return p; return p;
} }
} // namespace MIGRAPHX_INLINE_NS } // namespace MIGRAPHX_INLINE_NS
} // namespace driver } // namespace driver
} // namespace migraphx } // namespace migraphx
src/driver/inceptionv3.cpp
View file @ 5f215b71
This source diff could not be displayed because it is too large. You can view the blob instead.
src/driver/main.cpp
View file @ 5f215b71
...@@ -210,6 +210,9 @@ struct loader ...@@ -210,6 +210,9 @@ struct loader
auto last = std::prev(mm->end(), trim); auto last = std::prev(mm->end(), trim);
mm->remove_instructions(last, mm->end()); mm->remove_instructions(last, mm->end());
} }
// Remove unused variable when exporting to cpp
if(output_type == "cpp")
migraphx::run_passes(*p.get_main_module(), {migraphx::dead_code_elimination{}});
if(optimize) if(optimize)
{ {
migraphx::run_passes(*p.get_main_module(), migraphx::run_passes(*p.get_main_module(),
......
src/driver/resnet50.cpp
View file @ 5f215b71
/* /*
* The MIT License (MIT) * The MIT License (MIT)
* *
...@@ -21,10 +22,10 @@ ...@@ -21,10 +22,10 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include <migraphx/operators.hpp> #include <migraphx/make_op.hpp>
#include <migraphx/program.hpp> #include <migraphx/program.hpp>
#include <migraphx/generate.hpp> #include <migraphx/generate.hpp>
#include <migraphx/apply_alpha_beta.hpp> #include <migraphx/json.hpp>
#include "models.hpp" #include "models.hpp"
namespace migraphx { namespace migraphx {
...@@ -34,1231 +35,1026 @@ inline namespace MIGRAPHX_INLINE_NS { ...@@ -34,1231 +35,1026 @@ inline namespace MIGRAPHX_INLINE_NS {
migraphx::program resnet50(unsigned batch) // NOLINT(readability-function-size) migraphx::program resnet50(unsigned batch) // NOLINT(readability-function-size)
{ {
migraphx::program p; migraphx::program p;
auto* mm = p.get_main_module(); migraphx::module_ref mmain = p.get_main_module();
auto m0 = auto x_main_module_0 = mmain->add_literal(migraphx::abs(
mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}}); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 0)));
auto mx0 = mm->add_literal( auto x_input_1 = mmain->add_parameter(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 0)); "input.1", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
auto mx1 = mm->add_literal( auto x_main_module_2 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 2048}}, 1)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 2048}}, 1));
auto mx2 = mm->add_literal(migraphx::abs( auto x_main_module_3 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 2))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 2));
auto mx3 = mm->add_literal( auto x_main_module_4 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 3)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 3));
auto mx4 = mm->add_literal( auto x_main_module_5 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 4)); migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 4));
auto mx5 = mm->add_literal(migraphx::abs( auto x_main_module_6 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 5))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 5));
auto mx6 = mm->add_literal(migraphx::generate_literal( auto x_main_module_7 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 6)); migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 6));
auto mx7 = mm->add_literal(migraphx::abs( auto x_main_module_8 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 7))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 7));
auto mx8 = mm->add_literal( auto x_main_module_9 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 8)); migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 8));
auto mx9 = mm->add_literal( auto x_main_module_10 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 9)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 9));
auto mx10 = mm->add_literal(migraphx::abs( auto x_main_module_11 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 10))); migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 10));
auto mx11 = mm->add_literal(migraphx::generate_literal( auto x_main_module_12 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 11)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 11));
auto mx12 = mm->add_literal(migraphx::abs( auto x_main_module_13 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 12))); migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 12));
auto mx13 = mm->add_literal( auto x_main_module_14 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 13)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 13));
auto mx14 = mm->add_literal( auto x_main_module_15 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 14)); migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 14));
auto mx15 = mm->add_literal(migraphx::abs( auto x_main_module_16 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 15))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 15));
auto mx16 = mm->add_literal(migraphx::generate_literal( auto x_main_module_17 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 16)); migraphx::shape{migraphx::shape::float_type, {2048, 1024, 1, 1}}, 16));
auto mx17 = mm->add_literal(migraphx::abs( auto x_main_module_18 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 17))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 17));
auto mx18 = mm->add_literal( auto x_main_module_19 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 18)); migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 18));
auto mx19 = mm->add_literal( auto x_main_module_20 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 19)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 19));
auto mx20 = mm->add_literal(migraphx::abs( auto x_main_module_21 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 20))); migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 20));
auto mx21 = mm->add_literal(migraphx::generate_literal( auto x_main_module_22 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 21)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 21));
auto mx22 = mm->add_literal(migraphx::abs( auto x_main_module_23 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 22))); migraphx::shape{migraphx::shape::float_type, {512, 1024, 1, 1}}, 22));
auto mx23 = mm->add_literal( auto x_main_module_24 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 23)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 23));
auto mx24 = mm->add_literal( auto x_main_module_25 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 24)); migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 24));
auto mx25 = mm->add_literal(migraphx::abs( auto x_main_module_26 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 25))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 25));
auto mx26 = mm->add_literal(migraphx::generate_literal( auto x_main_module_27 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 26)); migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 26));
auto mx27 = mm->add_literal(migraphx::abs( auto x_main_module_28 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 27))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 27));
auto mx28 = mm->add_literal( auto x_main_module_29 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 28)); migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 28));
auto mx29 = mm->add_literal( auto x_main_module_30 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 29)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 29));
auto mx30 = mm->add_literal(migraphx::abs( auto x_main_module_31 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 30))); migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 30));
auto mx31 = mm->add_literal(migraphx::generate_literal( auto x_main_module_32 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 31)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 31));
auto mx32 = mm->add_literal(migraphx::abs( auto x_main_module_33 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 32))); migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 32));
auto mx33 = mm->add_literal( auto x_main_module_34 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 33)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 33));
auto mx34 = mm->add_literal( auto x_main_module_35 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 34)); migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 34));
auto mx35 = mm->add_literal(migraphx::abs( auto x_main_module_36 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 35))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 35));
auto mx36 = mm->add_literal(migraphx::generate_literal( auto x_main_module_37 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 1024, 1, 1}}, 36)); migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 36));
auto mx37 = mm->add_literal(migraphx::abs( auto x_main_module_38 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 37))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 37));
auto mx38 = mm->add_literal( auto x_main_module_39 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 38)); migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 38));
auto mx39 = mm->add_literal( auto x_main_module_40 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 39)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 39));
auto mx40 = mm->add_literal(migraphx::abs( auto x_main_module_41 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 40))); migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 40));
auto mx41 = mm->add_literal(migraphx::generate_literal( auto x_main_module_42 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 41)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 41));
auto mx42 = mm->add_literal(migraphx::abs( auto x_main_module_43 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 42))); migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 42));
auto mx43 = mm->add_literal( auto x_main_module_44 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 43)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 43));
auto mx44 = mm->add_literal( auto x_main_module_45 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 44)); migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 44));
auto mx45 = mm->add_literal(migraphx::abs( auto x_main_module_46 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 45))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 45));
auto mx46 = mm->add_literal(migraphx::generate_literal( auto x_main_module_47 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 46)); migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 46));
auto mx47 = mm->add_literal(migraphx::abs( auto x_main_module_48 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 47))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 47));
auto mx48 = mm->add_literal( auto x_main_module_49 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 48)); migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 48));
auto mx49 = mm->add_literal( auto x_main_module_50 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 49)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 49));
auto mx50 = mm->add_literal(migraphx::abs( auto x_main_module_51 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 50))); migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 50));
auto mx51 = mm->add_literal(migraphx::generate_literal( auto x_main_module_52 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {512, 1024, 1, 1}}, 51)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 51));
auto mx52 = mm->add_literal(migraphx::abs( auto x_main_module_53 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 52))); migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 52));
auto mx53 = mm->add_literal( auto x_main_module_54 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 53)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 53));
auto mx54 = mm->add_literal( auto x_main_module_55 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 54)); migraphx::shape{migraphx::shape::float_type, {1024, 512, 1, 1}}, 54));
auto mx55 = mm->add_literal( auto x_main_module_56 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 55)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 55));
auto mx56 = mm->add_literal(migraphx::generate_literal( auto x_main_module_57 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 56)); migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 56));
auto mx57 = mm->add_literal(migraphx::abs( auto x_main_module_58 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 57))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 57));
auto mx58 = mm->add_literal( auto x_main_module_59 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 58)); migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 58));
auto mx59 = mm->add_literal( auto x_main_module_60 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 59)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 59));
auto mx60 = mm->add_literal(migraphx::abs( auto x_main_module_61 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 60))); migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}}, 60));
auto mx61 = mm->add_literal(migraphx::generate_literal( auto x_main_module_62 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 61)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 61));
auto mx62 = mm->add_literal(migraphx::abs( auto x_main_module_63 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 62))); migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 62));
auto mx63 = mm->add_literal( auto x_main_module_64 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 63)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 63));
auto mx64 = mm->add_literal( auto x_main_module_65 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 64)); migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 64));
auto mx65 = mm->add_literal(migraphx::abs( auto x_main_module_66 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 65))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 65));
auto mx66 = mm->add_literal(migraphx::generate_literal( auto x_main_module_67 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 66)); migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 66));
auto mx67 = mm->add_literal(migraphx::abs( auto x_main_module_68 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 67))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 67));
auto mx68 = mm->add_literal( auto x_main_module_69 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 68)); migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 68));
auto mx69 = mm->add_literal( auto x_main_module_70 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 69)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 69));
auto mx70 = mm->add_literal( auto x_main_module_71 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 70)); migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 70));
auto mx71 = mm->add_literal(migraphx::generate_literal( auto x_main_module_72 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 71)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 71));
auto mx72 = mm->add_literal(migraphx::abs( auto x_main_module_73 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 72))); migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 72));
auto mx73 = mm->add_literal( auto x_main_module_74 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 73)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 73));
auto mx74 = mm->add_literal( auto x_main_module_75 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 74)); migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 74));
auto mx75 = mm->add_literal(migraphx::abs( auto x_main_module_76 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 75))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 75));
auto mx76 = mm->add_literal(migraphx::generate_literal( auto x_main_module_77 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 76)); migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 76));
auto mx77 = mm->add_literal(migraphx::abs( auto x_main_module_78 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 77))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 77));
auto mx78 = mm->add_literal( auto x_main_module_79 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 78)); migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 78));
auto mx79 = mm->add_literal( auto x_main_module_80 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 79)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 79));
auto mx80 = mm->add_literal(migraphx::abs( auto x_main_module_81 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 80))); migraphx::shape{migraphx::shape::float_type, {512, 256, 1, 1}}, 80));
auto mx81 = mm->add_literal(migraphx::generate_literal( auto x_main_module_82 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 81)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 81));
auto mx82 = mm->add_literal(migraphx::abs( auto x_main_module_83 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 82))); migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 82));
auto mx83 = mm->add_literal( auto x_main_module_84 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 83)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 83));
auto mx84 = mm->add_literal( auto x_main_module_85 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 84)); migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 84));
auto mx85 = mm->add_literal( auto x_main_module_86 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 85)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 85));
auto mx86 = mm->add_literal(migraphx::generate_literal( auto x_main_module_87 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 86)); migraphx::shape{migraphx::shape::float_type, {128, 256, 1, 1}}, 86));
auto mx87 = mm->add_literal(migraphx::abs( auto x_main_module_88 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 87))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 87));
auto mx88 = mm->add_literal( auto x_main_module_89 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 88)); migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 88));
auto mx89 = mm->add_literal( auto x_main_module_90 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 89)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 89));
auto mx90 = mm->add_literal(migraphx::abs( auto x_main_module_91 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 90))); migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 90));
auto mx91 = mm->add_literal(migraphx::generate_literal( auto x_main_module_92 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 91)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 91));
auto mx92 = mm->add_literal(migraphx::abs( auto x_main_module_93 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 92))); migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 92));
auto mx93 = mm->add_literal( auto x_main_module_94 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 93)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 93));
auto mx94 = mm->add_literal( auto x_main_module_95 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 94)); migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 94));
auto mx95 = mm->add_literal(migraphx::abs( auto x_main_module_96 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 95))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 95));
auto mx96 = mm->add_literal(migraphx::generate_literal( auto x_main_module_97 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 96)); migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 96));
auto mx97 = mm->add_literal(migraphx::abs( auto x_main_module_98 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 97))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 97));
auto mx98 = mm->add_literal( auto x_main_module_99 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 98)); migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 98));
auto mx99 = mm->add_literal( auto x_main_module_100 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 99)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 99));
auto mx100 = mm->add_literal( auto x_main_module_101 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 100)); migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 100));
auto mx101 = mm->add_literal(migraphx::generate_literal( auto x_main_module_102 = mmain->add_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 101)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 101));
auto mx102 = mm->add_literal(migraphx::abs( auto x_main_module_103 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 102))); migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 102));
auto mx103 = mm->add_literal( auto x_main_module_104 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 103)); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 103));
auto mx104 = mm->add_literal( auto x_main_module_105 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 104)); migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 104));
auto mx105 = mm->add_literal(migraphx::abs( auto x_main_module_106 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 105))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 105));
auto mx106 = mm->add_literal(migraphx::generate_literal( auto x_main_module_107 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 106)); migraphx::shape{migraphx::shape::float_type, {64, 64, 1, 1}}, 106));
auto mx107 = mm->add_literal(migraphx::abs( auto x_main_module_108 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 107))); migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 107));
auto mx108 = mm->add_literal( auto x_main_module_109 = mmain->add_literal(migraphx::generate_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 108)); migraphx::shape{migraphx::shape::float_type, {64, 3, 7, 7}}, 108));
auto mx109 = mm->add_literal( auto x_main_module_110 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 109)); migraphx::make_op(
auto mx110 = mm->add_literal(migraphx::abs( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 110))); migraphx::from_json_string(
auto mx111 = mm->add_literal(migraphx::generate_literal( "{dilation:[1,1],group:1,padding:[3,3,3,3],padding_mode:0,stride:[2,2]}")),
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 111)); x_input_1,
auto mx112 = mm->add_literal(migraphx::abs( x_main_module_109);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 112))); auto x_main_module_111 = mmain->add_instruction(
auto mx113 = mm->add_literal( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 113)); migraphx::from_json_string("{axis:1,out_lens:[1,64,112,112]}")),
auto mx114 = mm->add_literal( x_main_module_108);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 114)); auto x_main_module_112 =
auto mx115 = mm->add_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_110, x_main_module_111);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 115)); auto x_main_module_113 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_112);
auto mx116 = mm->add_literal(migraphx::generate_literal( auto x_main_module_114 = mmain->add_instruction(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 116)); migraphx::make_op(
auto mx117 = mm->add_literal(migraphx::abs( "pooling",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 117))); migraphx::from_json_string(
auto mx118 = mm->add_literal( "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[1,1,1,1],stride:[2,2]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 118)); x_main_module_113);
auto mx119 = mm->add_literal( auto x_main_module_115 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 119)); migraphx::make_op(
auto mx120 = mm->add_literal(migraphx::abs( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 120))); migraphx::from_json_string(
auto mx121 = mm->add_literal(migraphx::generate_literal( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 121)); x_main_module_114,
auto mx122 = mm->add_literal(migraphx::abs( x_main_module_107);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 122))); auto x_main_module_116 = mmain->add_instruction(
auto mx123 = mm->add_literal( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 123)); migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
auto mx124 = mm->add_literal( x_main_module_106);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 124)); auto x_main_module_117 =
auto mx125 = mm->add_literal(migraphx::abs( mmain->add_instruction(migraphx::make_op("add"), x_main_module_115, x_main_module_116);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 125))); auto x_main_module_118 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_117);
auto mx126 = mm->add_literal(migraphx::generate_literal( auto x_main_module_119 = mmain->add_instruction(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 126)); migraphx::make_op(
auto mx127 = mm->add_literal(migraphx::abs( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 127))); migraphx::from_json_string(
auto mx128 = mm->add_literal( "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 128)); x_main_module_118,
auto mx129 = mm->add_literal( x_main_module_105);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 129)); auto x_main_module_120 = mmain->add_instruction(
auto mx130 = mm->add_literal( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 130)); migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
auto mx131 = mm->add_literal(migraphx::generate_literal( x_main_module_104);
migraphx::shape{migraphx::shape::float_type, {1024, 512, 1, 1}}, 131)); auto x_main_module_121 =
auto mx132 = mm->add_literal(migraphx::abs( mmain->add_instruction(migraphx::make_op("add"), x_main_module_119, x_main_module_120);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 132))); auto x_main_module_122 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_121);
auto mx133 = mm->add_literal( auto x_main_module_123 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 133)); migraphx::make_op(
auto mx134 = mm->add_literal( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 134)); migraphx::from_json_string(
auto mx135 = mm->add_literal( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 135)); x_main_module_122,
auto mx136 = mm->add_literal(migraphx::generate_literal( x_main_module_103);
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 136)); auto x_main_module_124 = mmain->add_instruction(
auto mx137 = mm->add_literal(migraphx::abs( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 137))); migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
auto mx138 = mm->add_literal( x_main_module_102);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 138)); auto x_main_module_125 =
auto mx139 = mm->add_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_123, x_main_module_124);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 139)); auto x_main_module_126 = mmain->add_instruction(
auto mx140 = mm->add_literal(migraphx::abs( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 140))); "convolution",
auto mx141 = mm->add_literal(migraphx::generate_literal( migraphx::from_json_string(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 141)); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx142 = mm->add_literal(migraphx::abs( x_main_module_114,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 142))); x_main_module_101);
auto mx143 = mm->add_literal( auto x_main_module_127 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 143)); migraphx::make_op("broadcast",
auto mx144 = mm->add_literal( migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 144)); x_main_module_100);
auto mx145 = mm->add_literal(migraphx::abs( auto x_main_module_128 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 145))); mmain->add_instruction(migraphx::make_op("add"), x_main_module_126, x_main_module_127);
auto mx146 = mm->add_literal(migraphx::generate_literal( auto x_main_module_129 =
migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}}, 146)); mmain->add_instruction(migraphx::make_op("add"), x_main_module_125, x_main_module_128);
auto mx147 = mm->add_literal(migraphx::abs( auto x_main_module_130 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_129);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 147))); auto x_main_module_131 = mmain->add_instruction(
auto mx148 = mm->add_literal( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 148)); "convolution",
auto mx149 = mm->add_literal( migraphx::from_json_string(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 149)); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx150 = mm->add_literal( x_main_module_130,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 150)); x_main_module_99);
auto mx151 = mm->add_literal(migraphx::generate_literal( auto x_main_module_132 = mmain->add_instruction(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 151)); migraphx::make_op("broadcast",
auto mx152 = mm->add_literal(migraphx::abs( migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 152))); x_main_module_98);
auto mx153 = mm->add_literal( auto x_main_module_133 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 153)); mmain->add_instruction(migraphx::make_op("add"), x_main_module_131, x_main_module_132);
auto mx154 = mm->add_literal( auto x_main_module_134 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_133);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 154)); auto x_main_module_135 = mmain->add_instruction(
auto mx155 = mm->add_literal(migraphx::abs( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 155))); "convolution",
auto mx156 = mm->add_literal(migraphx::generate_literal( migraphx::from_json_string(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 156)); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
auto mx157 = mm->add_literal(migraphx::abs( x_main_module_134,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 157))); x_main_module_97);
auto mx158 = mm->add_literal( auto x_main_module_136 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 158)); migraphx::make_op("broadcast",
auto mx159 = mm->add_literal( migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 159)); x_main_module_96);
auto mx160 = mm->add_literal(migraphx::abs( auto x_main_module_137 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 160))); mmain->add_instruction(migraphx::make_op("add"), x_main_module_135, x_main_module_136);
auto mx161 = mm->add_literal(migraphx::generate_literal( auto x_main_module_138 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_137);
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 161)); auto x_main_module_139 = mmain->add_instruction(
auto mx162 = mm->add_literal(migraphx::abs( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 162))); "convolution",
auto mx163 = mm->add_literal( migraphx::from_json_string(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 163)); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx164 = mm->add_literal( x_main_module_138,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 164)); x_main_module_95);
auto mx165 = mm->add_literal( auto x_main_module_140 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 165)); migraphx::make_op("broadcast",
auto mx166 = mm->add_literal(migraphx::generate_literal( migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 166)); x_main_module_94);
auto mx167 = mm->add_literal(migraphx::abs( auto x_main_module_141 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 167))); mmain->add_instruction(migraphx::make_op("add"), x_main_module_139, x_main_module_140);
auto mx168 = mm->add_literal( auto x_main_module_142 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 168)); mmain->add_instruction(migraphx::make_op("add"), x_main_module_141, x_main_module_130);
auto mx169 = mm->add_literal( auto x_main_module_143 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_142);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 169)); auto x_main_module_144 = mmain->add_instruction(
auto mx170 = mm->add_literal(migraphx::abs( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 170))); "convolution",
auto mx171 = mm->add_literal(migraphx::generate_literal( migraphx::from_json_string(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 171)); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx172 = mm->add_literal(migraphx::abs( x_main_module_143,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 172))); x_main_module_93);
auto mx173 = mm->add_literal( auto x_main_module_145 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 173)); migraphx::make_op("broadcast",
auto mx174 = mm->add_literal( migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 174)); x_main_module_92);
auto mx175 = mm->add_literal(migraphx::abs( auto x_main_module_146 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 175))); mmain->add_instruction(migraphx::make_op("add"), x_main_module_144, x_main_module_145);
auto mx176 = mm->add_literal(migraphx::generate_literal( auto x_main_module_147 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_146);
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 176)); auto x_main_module_148 = mmain->add_instruction(
auto mx177 = mm->add_literal(migraphx::abs( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 177))); "convolution",
auto mx178 = mm->add_literal( migraphx::from_json_string(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 178)); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
auto mx179 = mm->add_literal( x_main_module_147,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 179)); x_main_module_91);
auto mx180 = mm->add_literal( auto x_main_module_149 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 180)); migraphx::make_op("broadcast",
auto mx181 = mm->add_literal(migraphx::generate_literal( migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 181)); x_main_module_90);
auto mx182 = mm->add_literal(migraphx::abs( auto x_main_module_150 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 182))); mmain->add_instruction(migraphx::make_op("add"), x_main_module_148, x_main_module_149);
auto mx183 = mm->add_literal( auto x_main_module_151 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_150);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 183)); auto x_main_module_152 = mmain->add_instruction(
auto mx184 = mm->add_literal( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 184)); "convolution",
auto mx185 = mm->add_literal(migraphx::abs( migraphx::from_json_string(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 185))); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx186 = mm->add_literal(migraphx::generate_literal( x_main_module_151,
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 186)); x_main_module_89);
auto mx187 = mm->add_literal(migraphx::abs( auto x_main_module_153 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 187))); migraphx::make_op("broadcast",
auto mx188 = mm->add_literal( migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 188)); x_main_module_88);
auto mx189 = mm->add_literal( auto x_main_module_154 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 189)); mmain->add_instruction(migraphx::make_op("add"), x_main_module_152, x_main_module_153);
auto mx190 = mm->add_literal(migraphx::abs( auto x_main_module_155 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 190))); mmain->add_instruction(migraphx::make_op("add"), x_main_module_154, x_main_module_143);
auto mx191 = mm->add_literal(migraphx::generate_literal( auto x_main_module_156 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_155);
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 191)); auto x_main_module_157 = mmain->add_instruction(
auto mx192 = mm->add_literal(migraphx::abs( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 192))); "convolution",
auto mx193 = mm->add_literal( migraphx::from_json_string(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 193)); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx194 = mm->add_literal( x_main_module_156,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 194)); x_main_module_87);
auto mx195 = mm->add_literal( auto x_main_module_158 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 195)); migraphx::make_op("broadcast",
auto mx196 = mm->add_literal(migraphx::generate_literal( migraphx::from_json_string("{axis:1,out_lens:[1,128,56,56]}")),
migraphx::shape{migraphx::shape::float_type, {512, 256, 1, 1}}, 196)); x_main_module_86);
auto mx197 = mm->add_literal(migraphx::abs( auto x_main_module_159 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 197))); mmain->add_instruction(migraphx::make_op("add"), x_main_module_157, x_main_module_158);
auto mx198 = mm->add_literal( auto x_main_module_160 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_159);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 198)); auto x_main_module_161 = mmain->add_instruction(
auto mx199 = mm->add_literal( migraphx::make_op(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 199)); "convolution",
auto mx200 = mm->add_literal( migraphx::from_json_string(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 200)); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
auto mx201 = mm->add_literal(migraphx::generate_literal( x_main_module_160,
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 201)); x_main_module_85);
auto mx202 = mm->add_literal(migraphx::abs( auto x_main_module_162 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 202))); migraphx::make_op("broadcast",
auto mx203 = mm->add_literal( migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 203)); x_main_module_84);
auto mx204 = mm->add_literal( auto x_main_module_163 =
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 204)); mmain->add_instruction(migraphx::make_op("add"), x_main_module_161, x_main_module_162);
auto mx205 = mm->add_literal(migraphx::abs( auto x_main_module_164 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_163);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 205))); auto x_main_module_165 = mmain->add_instruction(
auto mx206 = mm->add_literal(migraphx::generate_literal( migraphx::make_op(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 206)); "convolution",
auto mx207 = mm->add_literal(migraphx::abs( migraphx::from_json_string(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 207))); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx208 = mm->add_literal( x_main_module_164,
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 208)); x_main_module_83);
auto mx209 = mm->add_literal( auto x_main_module_166 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 209)); migraphx::make_op("broadcast",
auto mx210 = mm->add_literal(migraphx::abs( migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 210))); x_main_module_82);
auto mx211 = mm->add_literal(migraphx::generate_literal( auto x_main_module_167 =
migraphx::shape{migraphx::shape::float_type, {128, 256, 1, 1}}, 211)); mmain->add_instruction(migraphx::make_op("add"), x_main_module_165, x_main_module_166);
auto mx212 = mm->add_literal(migraphx::abs( auto x_main_module_168 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 212))); migraphx::make_op(
auto mx213 = mm->add_literal( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 213)); migraphx::from_json_string(
auto mx214 = mm->add_literal( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 214)); x_main_module_156,
auto mx215 = mm->add_literal( x_main_module_81);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 215)); auto x_main_module_169 = mmain->add_instruction(
auto mx216 = mm->add_literal(migraphx::generate_literal( migraphx::make_op("broadcast",
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 216)); migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
auto mx217 = mm->add_literal(migraphx::abs( x_main_module_80);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 217))); auto x_main_module_170 =
auto mx218 = mm->add_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_168, x_main_module_169);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 218)); auto x_main_module_171 =
auto mx219 = mm->add_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_167, x_main_module_170);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 219)); auto x_main_module_172 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_171);
auto mx220 = mm->add_literal(migraphx::abs( auto x_main_module_173 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 220))); migraphx::make_op(
auto mx221 = mm->add_literal(migraphx::generate_literal( "convolution",
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 221)); migraphx::from_json_string(
auto mx222 = mm->add_literal(migraphx::abs( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 222))); x_main_module_172,
auto mx223 = mm->add_literal( x_main_module_79);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 223)); auto x_main_module_174 = mmain->add_instruction(
auto mx224 = mm->add_literal( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 224)); migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
auto mx225 = mm->add_literal(migraphx::abs( x_main_module_78);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 225))); auto x_main_module_175 =
auto mx226 = mm->add_literal(migraphx::generate_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_173, x_main_module_174);
migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 226)); auto x_main_module_176 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_175);
auto mx227 = mm->add_literal(migraphx::abs( auto x_main_module_177 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 227))); migraphx::make_op(
auto mx228 = mm->add_literal( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 228)); migraphx::from_json_string(
auto mx229 = mm->add_literal( "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 229)); x_main_module_176,
auto mx230 = mm->add_literal( x_main_module_77);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 230)); auto x_main_module_178 = mmain->add_instruction(
auto mx231 = mm->add_literal(migraphx::generate_literal( migraphx::make_op("broadcast",
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 231)); migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
auto mx232 = mm->add_literal(migraphx::abs( x_main_module_76);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 232))); auto x_main_module_179 =
auto mx233 = mm->add_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_177, x_main_module_178);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 233)); auto x_main_module_180 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_179);
auto mx234 = mm->add_literal( auto x_main_module_181 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 234)); migraphx::make_op(
auto mx235 = mm->add_literal(migraphx::abs( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 235))); migraphx::from_json_string(
auto mx236 = mm->add_literal(migraphx::generate_literal( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 236)); x_main_module_180,
auto mx237 = mm->add_literal(migraphx::abs( x_main_module_75);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 237))); auto x_main_module_182 = mmain->add_instruction(
auto mx238 = mm->add_literal( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 238)); migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
auto mx239 = mm->add_literal( x_main_module_74);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 239)); auto x_main_module_183 =
auto mx240 = mm->add_literal(migraphx::abs( mmain->add_instruction(migraphx::make_op("add"), x_main_module_181, x_main_module_182);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 240))); auto x_main_module_184 =
auto mx241 = mm->add_literal(migraphx::generate_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_183, x_main_module_172);
migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 241)); auto x_main_module_185 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_184);
auto mx242 = mm->add_literal(migraphx::abs( auto x_main_module_186 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 242))); migraphx::make_op(
auto mx243 = mm->add_literal( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 243)); migraphx::from_json_string(
auto mx244 = mm->add_literal( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 244)); x_main_module_185,
auto mx245 = mm->add_literal( x_main_module_73);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 245)); auto x_main_module_187 = mmain->add_instruction(
auto mx246 = mm->add_literal(migraphx::generate_literal( migraphx::make_op("broadcast",
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 246)); migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
auto mx247 = mm->add_literal(migraphx::abs( x_main_module_72);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 247))); auto x_main_module_188 =
auto mx248 = mm->add_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_186, x_main_module_187);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 248)); auto x_main_module_189 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_188);
auto mx249 = mm->add_literal( auto x_main_module_190 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 249)); migraphx::make_op(
auto mx250 = mm->add_literal( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 250)); migraphx::from_json_string(
auto mx251 = mm->add_literal(migraphx::generate_literal( "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 251)); x_main_module_189,
auto mx252 = mm->add_literal(migraphx::abs( x_main_module_71);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 252))); auto x_main_module_191 = mmain->add_instruction(
auto mx253 = mm->add_literal( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 253)); migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
auto mx254 = mm->add_literal( x_main_module_70);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 254)); auto x_main_module_192 =
auto mx255 = mm->add_literal(migraphx::abs( mmain->add_instruction(migraphx::make_op("add"), x_main_module_190, x_main_module_191);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 255))); auto x_main_module_193 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_192);
auto mx256 = mm->add_literal(migraphx::generate_literal( auto x_main_module_194 = mmain->add_instruction(
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 256)); migraphx::make_op(
auto mx257 = mm->add_literal(migraphx::abs( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 257))); migraphx::from_json_string(
auto mx258 = mm->add_literal( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 258)); x_main_module_193,
auto mx259 = mm->add_literal( x_main_module_69);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 259)); auto x_main_module_195 = mmain->add_instruction(
auto mx260 = mm->add_literal(migraphx::abs( migraphx::make_op("broadcast",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 260))); migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
auto mx261 = mm->add_literal(migraphx::generate_literal( x_main_module_68);
migraphx::shape{migraphx::shape::float_type, {64, 64, 1, 1}}, 261)); auto x_main_module_196 =
auto mx262 = mm->add_literal(migraphx::abs( mmain->add_instruction(migraphx::make_op("add"), x_main_module_194, x_main_module_195);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 262))); auto x_main_module_197 =
auto mx263 = mm->add_literal( mmain->add_instruction(migraphx::make_op("add"), x_main_module_196, x_main_module_185);
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 263)); auto x_main_module_198 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_197);
auto mx264 = mm->add_literal( auto x_main_module_199 = mmain->add_instruction(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 264)); migraphx::make_op(
auto mx265 = mm->add_literal(migraphx::abs( "convolution",
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 265))); migraphx::from_json_string(
auto mx266 = mm->add_literal(migraphx::generate_literal( "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::shape{migraphx::shape::float_type, {64, 3, 7, 7}}, 266)); x_main_module_198,
migraphx::op::convolution convolution267; x_main_module_67);
convolution267.padding = {3, 3}; auto x_main_module_200 = mmain->add_instruction(
convolution267.stride = {2, 2}; migraphx::make_op("broadcast",
convolution267.dilation = {1, 1}; migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
convolution267.group = 1; x_main_module_66);
auto mx267 = mm->add_instruction(convolution267, m0, mx266); auto x_main_module_201 =
migraphx::op::batch_norm_inference batch_norm_inference268; mmain->add_instruction(migraphx::make_op("add"), x_main_module_199, x_main_module_200);
batch_norm_inference268.epsilon = 1e-05; auto x_main_module_202 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_201);
batch_norm_inference268.momentum = 0.9; auto x_main_module_203 = mmain->add_instruction(
auto mx268 = mm->add_instruction(batch_norm_inference268, mx267, mx265, mx264, mx263, mx262); migraphx::make_op(
migraphx::op::relu relu269; "convolution",
auto mx269 = mm->add_instruction(relu269, mx268); migraphx::from_json_string(
migraphx::op::pooling pooling270; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
pooling270.mode = migraphx::op::pooling_mode::max; x_main_module_202,
pooling270.padding = {1, 1}; x_main_module_65);
pooling270.stride = {2, 2}; auto x_main_module_204 = mmain->add_instruction(
pooling270.lengths = {3, 3}; migraphx::make_op("broadcast",
auto mx270 = mm->add_instruction(pooling270, mx269); migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
migraphx::op::convolution convolution271; x_main_module_64);
convolution271.padding = {0, 0}; auto x_main_module_205 =
convolution271.stride = {1, 1}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_203, x_main_module_204);
convolution271.dilation = {1, 1}; auto x_main_module_206 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_205);
convolution271.group = 1; auto x_main_module_207 = mmain->add_instruction(
auto mx271 = mm->add_instruction(convolution271, mx270, mx261); migraphx::make_op(
migraphx::op::batch_norm_inference batch_norm_inference272; "convolution",
batch_norm_inference272.epsilon = 1e-05; migraphx::from_json_string(
batch_norm_inference272.momentum = 0.9; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx272 = mm->add_instruction(batch_norm_inference272, mx271, mx260, mx259, mx258, mx257); x_main_module_206,
migraphx::op::relu relu273; x_main_module_63);
auto mx273 = mm->add_instruction(relu273, mx272); auto x_main_module_208 = mmain->add_instruction(
migraphx::op::convolution convolution274; migraphx::make_op("broadcast",
convolution274.padding = {1, 1}; migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
convolution274.stride = {1, 1}; x_main_module_62);
convolution274.dilation = {1, 1}; auto x_main_module_209 =
convolution274.group = 1; mmain->add_instruction(migraphx::make_op("add"), x_main_module_207, x_main_module_208);
auto mx274 = mm->add_instruction(convolution274, mx273, mx256); auto x_main_module_210 =
migraphx::op::batch_norm_inference batch_norm_inference275; mmain->add_instruction(migraphx::make_op("add"), x_main_module_209, x_main_module_198);
batch_norm_inference275.epsilon = 1e-05; auto x_main_module_211 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_210);
batch_norm_inference275.momentum = 0.9; auto x_main_module_212 = mmain->add_instruction(
auto mx275 = mm->add_instruction(batch_norm_inference275, mx274, mx255, mx254, mx253, mx252); migraphx::make_op(
migraphx::op::relu relu276; "convolution",
auto mx276 = mm->add_instruction(relu276, mx275); migraphx::from_json_string(
migraphx::op::convolution convolution277; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
convolution277.padding = {0, 0}; x_main_module_211,
convolution277.stride = {1, 1}; x_main_module_61);
convolution277.dilation = {1, 1}; auto x_main_module_213 = mmain->add_instruction(
convolution277.group = 1; migraphx::make_op("broadcast",
auto mx277 = mm->add_instruction(convolution277, mx276, mx251); migraphx::from_json_string("{axis:1,out_lens:[1,256,28,28]}")),
migraphx::op::batch_norm_inference batch_norm_inference278; x_main_module_60);
batch_norm_inference278.epsilon = 1e-05; auto x_main_module_214 =
batch_norm_inference278.momentum = 0.9; mmain->add_instruction(migraphx::make_op("add"), x_main_module_212, x_main_module_213);
auto mx278 = mm->add_instruction(batch_norm_inference278, mx277, mx250, mx249, mx248, mx247); auto x_main_module_215 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_214);
migraphx::op::convolution convolution279; auto x_main_module_216 = mmain->add_instruction(
convolution279.padding = {0, 0}; migraphx::make_op(
convolution279.stride = {1, 1}; "convolution",
convolution279.dilation = {1, 1}; migraphx::from_json_string(
convolution279.group = 1; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
auto mx279 = mm->add_instruction(convolution279, mx270, mx246); x_main_module_215,
migraphx::op::batch_norm_inference batch_norm_inference280; x_main_module_59);
batch_norm_inference280.epsilon = 1e-05; auto x_main_module_217 = mmain->add_instruction(
batch_norm_inference280.momentum = 0.9; migraphx::make_op("broadcast",
auto mx280 = mm->add_instruction(batch_norm_inference280, mx279, mx245, mx244, mx243, mx242); migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
migraphx::op::add add281; x_main_module_58);
auto mx281 = mm->add_instruction(add281, mx278, mx280); auto x_main_module_218 =
migraphx::op::relu relu282; mmain->add_instruction(migraphx::make_op("add"), x_main_module_216, x_main_module_217);
auto mx282 = mm->add_instruction(relu282, mx281); auto x_main_module_219 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_218);
migraphx::op::convolution convolution283; auto x_main_module_220 = mmain->add_instruction(
convolution283.padding = {0, 0}; migraphx::make_op(
convolution283.stride = {1, 1}; "convolution",
convolution283.dilation = {1, 1}; migraphx::from_json_string(
convolution283.group = 1; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx283 = mm->add_instruction(convolution283, mx282, mx241); x_main_module_219,
migraphx::op::batch_norm_inference batch_norm_inference284; x_main_module_57);
batch_norm_inference284.epsilon = 1e-05; auto x_main_module_221 = mmain->add_instruction(
batch_norm_inference284.momentum = 0.9; migraphx::make_op("broadcast",
auto mx284 = mm->add_instruction(batch_norm_inference284, mx283, mx240, mx239, mx238, mx237); migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
migraphx::op::relu relu285; x_main_module_56);
auto mx285 = mm->add_instruction(relu285, mx284); auto x_main_module_222 =
migraphx::op::convolution convolution286; mmain->add_instruction(migraphx::make_op("add"), x_main_module_220, x_main_module_221);
convolution286.padding = {1, 1}; auto x_main_module_223 = mmain->add_instruction(
convolution286.stride = {1, 1}; migraphx::make_op(
convolution286.dilation = {1, 1}; "convolution",
convolution286.group = 1; migraphx::from_json_string(
auto mx286 = mm->add_instruction(convolution286, mx285, mx236); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
migraphx::op::batch_norm_inference batch_norm_inference287; x_main_module_211,
batch_norm_inference287.epsilon = 1e-05; x_main_module_55);
batch_norm_inference287.momentum = 0.9; auto x_main_module_224 = mmain->add_instruction(
auto mx287 = mm->add_instruction(batch_norm_inference287, mx286, mx235, mx234, mx233, mx232); migraphx::make_op("broadcast",
migraphx::op::relu relu288; migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
auto mx288 = mm->add_instruction(relu288, mx287); x_main_module_54);
migraphx::op::convolution convolution289; auto x_main_module_225 =
convolution289.padding = {0, 0}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_223, x_main_module_224);
convolution289.stride = {1, 1}; auto x_main_module_226 =
convolution289.dilation = {1, 1}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_222, x_main_module_225);
convolution289.group = 1; auto x_main_module_227 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_226);
auto mx289 = mm->add_instruction(convolution289, mx288, mx231); auto x_main_module_228 = mmain->add_instruction(
migraphx::op::batch_norm_inference batch_norm_inference290; migraphx::make_op(
batch_norm_inference290.epsilon = 1e-05; "convolution",
batch_norm_inference290.momentum = 0.9; migraphx::from_json_string(
auto mx290 = mm->add_instruction(batch_norm_inference290, mx289, mx230, mx229, mx228, mx227); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::add add291; x_main_module_227,
auto mx291 = mm->add_instruction(add291, mx290, mx282); x_main_module_53);
migraphx::op::relu relu292; auto x_main_module_229 = mmain->add_instruction(
auto mx292 = mm->add_instruction(relu292, mx291); migraphx::make_op("broadcast",
migraphx::op::convolution convolution293; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
convolution293.padding = {0, 0}; x_main_module_52);
convolution293.stride = {1, 1}; auto x_main_module_230 =
convolution293.dilation = {1, 1}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_228, x_main_module_229);
convolution293.group = 1; auto x_main_module_231 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_230);
auto mx293 = mm->add_instruction(convolution293, mx292, mx226); auto x_main_module_232 = mmain->add_instruction(
migraphx::op::batch_norm_inference batch_norm_inference294; migraphx::make_op(
batch_norm_inference294.epsilon = 1e-05; "convolution",
batch_norm_inference294.momentum = 0.9; migraphx::from_json_string(
auto mx294 = mm->add_instruction(batch_norm_inference294, mx293, mx225, mx224, mx223, mx222); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
migraphx::op::relu relu295; x_main_module_231,
auto mx295 = mm->add_instruction(relu295, mx294); x_main_module_51);
migraphx::op::convolution convolution296; auto x_main_module_233 = mmain->add_instruction(
convolution296.padding = {1, 1}; migraphx::make_op("broadcast",
convolution296.stride = {1, 1}; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
convolution296.dilation = {1, 1}; x_main_module_50);
convolution296.group = 1; auto x_main_module_234 =
auto mx296 = mm->add_instruction(convolution296, mx295, mx221); mmain->add_instruction(migraphx::make_op("add"), x_main_module_232, x_main_module_233);
migraphx::op::batch_norm_inference batch_norm_inference297; auto x_main_module_235 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_234);
batch_norm_inference297.epsilon = 1e-05; auto x_main_module_236 = mmain->add_instruction(
batch_norm_inference297.momentum = 0.9; migraphx::make_op(
auto mx297 = mm->add_instruction(batch_norm_inference297, mx296, mx220, mx219, mx218, mx217); "convolution",
migraphx::op::relu relu298; migraphx::from_json_string(
auto mx298 = mm->add_instruction(relu298, mx297); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::convolution convolution299; x_main_module_235,
convolution299.padding = {0, 0}; x_main_module_49);
convolution299.stride = {1, 1}; auto x_main_module_237 = mmain->add_instruction(
convolution299.dilation = {1, 1}; migraphx::make_op("broadcast",
convolution299.group = 1; migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
auto mx299 = mm->add_instruction(convolution299, mx298, mx216); x_main_module_48);
migraphx::op::batch_norm_inference batch_norm_inference300; auto x_main_module_238 =
batch_norm_inference300.epsilon = 1e-05; mmain->add_instruction(migraphx::make_op("add"), x_main_module_236, x_main_module_237);
batch_norm_inference300.momentum = 0.9; auto x_main_module_239 =
auto mx300 = mm->add_instruction(batch_norm_inference300, mx299, mx215, mx214, mx213, mx212); mmain->add_instruction(migraphx::make_op("add"), x_main_module_238, x_main_module_227);
migraphx::op::add add301; auto x_main_module_240 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_239);
auto mx301 = mm->add_instruction(add301, mx300, mx292); auto x_main_module_241 = mmain->add_instruction(
migraphx::op::relu relu302; migraphx::make_op(
auto mx302 = mm->add_instruction(relu302, mx301); "convolution",
migraphx::op::convolution convolution303; migraphx::from_json_string(
convolution303.padding = {0, 0}; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
convolution303.stride = {1, 1}; x_main_module_240,
convolution303.dilation = {1, 1}; x_main_module_47);
convolution303.group = 1; auto x_main_module_242 = mmain->add_instruction(
auto mx303 = mm->add_instruction(convolution303, mx302, mx211); migraphx::make_op("broadcast",
migraphx::op::batch_norm_inference batch_norm_inference304; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
batch_norm_inference304.epsilon = 1e-05; x_main_module_46);
batch_norm_inference304.momentum = 0.9; auto x_main_module_243 =
auto mx304 = mm->add_instruction(batch_norm_inference304, mx303, mx210, mx209, mx208, mx207); mmain->add_instruction(migraphx::make_op("add"), x_main_module_241, x_main_module_242);
migraphx::op::relu relu305; auto x_main_module_244 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_243);
auto mx305 = mm->add_instruction(relu305, mx304); auto x_main_module_245 = mmain->add_instruction(
migraphx::op::convolution convolution306; migraphx::make_op(
convolution306.padding = {1, 1}; "convolution",
convolution306.stride = {2, 2}; migraphx::from_json_string(
convolution306.dilation = {1, 1}; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
convolution306.group = 1; x_main_module_244,
auto mx306 = mm->add_instruction(convolution306, mx305, mx206); x_main_module_45);
migraphx::op::batch_norm_inference batch_norm_inference307; auto x_main_module_246 = mmain->add_instruction(
batch_norm_inference307.epsilon = 1e-05; migraphx::make_op("broadcast",
batch_norm_inference307.momentum = 0.9; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
auto mx307 = mm->add_instruction(batch_norm_inference307, mx306, mx205, mx204, mx203, mx202); x_main_module_44);
migraphx::op::relu relu308; auto x_main_module_247 =
auto mx308 = mm->add_instruction(relu308, mx307); mmain->add_instruction(migraphx::make_op("add"), x_main_module_245, x_main_module_246);
migraphx::op::convolution convolution309; auto x_main_module_248 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_247);
convolution309.padding = {0, 0}; auto x_main_module_249 = mmain->add_instruction(
convolution309.stride = {1, 1}; migraphx::make_op(
convolution309.dilation = {1, 1}; "convolution",
convolution309.group = 1; migraphx::from_json_string(
auto mx309 = mm->add_instruction(convolution309, mx308, mx201); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::batch_norm_inference batch_norm_inference310; x_main_module_248,
batch_norm_inference310.epsilon = 1e-05; x_main_module_43);
batch_norm_inference310.momentum = 0.9; auto x_main_module_250 = mmain->add_instruction(
auto mx310 = mm->add_instruction(batch_norm_inference310, mx309, mx200, mx199, mx198, mx197); migraphx::make_op("broadcast",
migraphx::op::convolution convolution311; migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
convolution311.padding = {0, 0}; x_main_module_42);
convolution311.stride = {2, 2}; auto x_main_module_251 =
convolution311.dilation = {1, 1}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_249, x_main_module_250);
convolution311.group = 1; auto x_main_module_252 =
auto mx311 = mm->add_instruction(convolution311, mx302, mx196); mmain->add_instruction(migraphx::make_op("add"), x_main_module_251, x_main_module_240);
migraphx::op::batch_norm_inference batch_norm_inference312; auto x_main_module_253 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_252);
batch_norm_inference312.epsilon = 1e-05; auto x_main_module_254 = mmain->add_instruction(
batch_norm_inference312.momentum = 0.9; migraphx::make_op(
auto mx312 = mm->add_instruction(batch_norm_inference312, mx311, mx195, mx194, mx193, mx192); "convolution",
migraphx::op::add add313; migraphx::from_json_string(
auto mx313 = mm->add_instruction(add313, mx310, mx312); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::relu relu314; x_main_module_253,
auto mx314 = mm->add_instruction(relu314, mx313); x_main_module_41);
migraphx::op::convolution convolution315; auto x_main_module_255 = mmain->add_instruction(
convolution315.padding = {0, 0}; migraphx::make_op("broadcast",
convolution315.stride = {1, 1}; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
convolution315.dilation = {1, 1}; x_main_module_40);
convolution315.group = 1; auto x_main_module_256 =
auto mx315 = mm->add_instruction(convolution315, mx314, mx191); mmain->add_instruction(migraphx::make_op("add"), x_main_module_254, x_main_module_255);
migraphx::op::batch_norm_inference batch_norm_inference316; auto x_main_module_257 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_256);
batch_norm_inference316.epsilon = 1e-05; auto x_main_module_258 = mmain->add_instruction(
batch_norm_inference316.momentum = 0.9; migraphx::make_op(
auto mx316 = mm->add_instruction(batch_norm_inference316, mx315, mx190, mx189, mx188, mx187); "convolution",
migraphx::op::relu relu317; migraphx::from_json_string(
auto mx317 = mm->add_instruction(relu317, mx316); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
migraphx::op::convolution convolution318; x_main_module_257,
convolution318.padding = {1, 1}; x_main_module_39);
convolution318.stride = {1, 1}; auto x_main_module_259 = mmain->add_instruction(
convolution318.dilation = {1, 1}; migraphx::make_op("broadcast",
convolution318.group = 1; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
auto mx318 = mm->add_instruction(convolution318, mx317, mx186); x_main_module_38);
migraphx::op::batch_norm_inference batch_norm_inference319; auto x_main_module_260 =
batch_norm_inference319.epsilon = 1e-05; mmain->add_instruction(migraphx::make_op("add"), x_main_module_258, x_main_module_259);
batch_norm_inference319.momentum = 0.9; auto x_main_module_261 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_260);
auto mx319 = mm->add_instruction(batch_norm_inference319, mx318, mx185, mx184, mx183, mx182); auto x_main_module_262 = mmain->add_instruction(
migraphx::op::relu relu320; migraphx::make_op(
auto mx320 = mm->add_instruction(relu320, mx319); "convolution",
migraphx::op::convolution convolution321; migraphx::from_json_string(
convolution321.padding = {0, 0}; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
convolution321.stride = {1, 1}; x_main_module_261,
convolution321.dilation = {1, 1}; x_main_module_37);
convolution321.group = 1; auto x_main_module_263 = mmain->add_instruction(
auto mx321 = mm->add_instruction(convolution321, mx320, mx181); migraphx::make_op("broadcast",
migraphx::op::batch_norm_inference batch_norm_inference322; migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
batch_norm_inference322.epsilon = 1e-05; x_main_module_36);
batch_norm_inference322.momentum = 0.9; auto x_main_module_264 =
auto mx322 = mm->add_instruction(batch_norm_inference322, mx321, mx180, mx179, mx178, mx177); mmain->add_instruction(migraphx::make_op("add"), x_main_module_262, x_main_module_263);
migraphx::op::add add323; auto x_main_module_265 =
auto mx323 = mm->add_instruction(add323, mx322, mx314); mmain->add_instruction(migraphx::make_op("add"), x_main_module_264, x_main_module_253);
migraphx::op::relu relu324; auto x_main_module_266 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_265);
auto mx324 = mm->add_instruction(relu324, mx323); auto x_main_module_267 = mmain->add_instruction(
migraphx::op::convolution convolution325; migraphx::make_op(
convolution325.padding = {0, 0}; "convolution",
convolution325.stride = {1, 1}; migraphx::from_json_string(
convolution325.dilation = {1, 1}; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
convolution325.group = 1; x_main_module_266,
auto mx325 = mm->add_instruction(convolution325, mx324, mx176); x_main_module_35);
migraphx::op::batch_norm_inference batch_norm_inference326; auto x_main_module_268 = mmain->add_instruction(
batch_norm_inference326.epsilon = 1e-05; migraphx::make_op("broadcast",
batch_norm_inference326.momentum = 0.9; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
auto mx326 = mm->add_instruction(batch_norm_inference326, mx325, mx175, mx174, mx173, mx172); x_main_module_34);
migraphx::op::relu relu327; auto x_main_module_269 =
auto mx327 = mm->add_instruction(relu327, mx326); mmain->add_instruction(migraphx::make_op("add"), x_main_module_267, x_main_module_268);
migraphx::op::convolution convolution328; auto x_main_module_270 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_269);
convolution328.padding = {1, 1}; auto x_main_module_271 = mmain->add_instruction(
convolution328.stride = {1, 1}; migraphx::make_op(
convolution328.dilation = {1, 1}; "convolution",
convolution328.group = 1; migraphx::from_json_string(
auto mx328 = mm->add_instruction(convolution328, mx327, mx171); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
migraphx::op::batch_norm_inference batch_norm_inference329; x_main_module_270,
batch_norm_inference329.epsilon = 1e-05; x_main_module_33);
batch_norm_inference329.momentum = 0.9; auto x_main_module_272 = mmain->add_instruction(
auto mx329 = mm->add_instruction(batch_norm_inference329, mx328, mx170, mx169, mx168, mx167); migraphx::make_op("broadcast",
migraphx::op::relu relu330; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
auto mx330 = mm->add_instruction(relu330, mx329); x_main_module_32);
migraphx::op::convolution convolution331; auto x_main_module_273 =
convolution331.padding = {0, 0}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_271, x_main_module_272);
convolution331.stride = {1, 1}; auto x_main_module_274 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_273);
convolution331.dilation = {1, 1}; auto x_main_module_275 = mmain->add_instruction(
convolution331.group = 1; migraphx::make_op(
auto mx331 = mm->add_instruction(convolution331, mx330, mx166); "convolution",
migraphx::op::batch_norm_inference batch_norm_inference332; migraphx::from_json_string(
batch_norm_inference332.epsilon = 1e-05; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
batch_norm_inference332.momentum = 0.9; x_main_module_274,
auto mx332 = mm->add_instruction(batch_norm_inference332, mx331, mx165, mx164, mx163, mx162); x_main_module_31);
migraphx::op::add add333; auto x_main_module_276 = mmain->add_instruction(
auto mx333 = mm->add_instruction(add333, mx332, mx324); migraphx::make_op("broadcast",
migraphx::op::relu relu334; migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
auto mx334 = mm->add_instruction(relu334, mx333); x_main_module_30);
migraphx::op::convolution convolution335; auto x_main_module_277 =
convolution335.padding = {0, 0}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_275, x_main_module_276);
convolution335.stride = {1, 1}; auto x_main_module_278 =
convolution335.dilation = {1, 1}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_277, x_main_module_266);
convolution335.group = 1; auto x_main_module_279 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_278);
auto mx335 = mm->add_instruction(convolution335, mx334, mx161); auto x_main_module_280 = mmain->add_instruction(
migraphx::op::batch_norm_inference batch_norm_inference336; migraphx::make_op(
batch_norm_inference336.epsilon = 1e-05; "convolution",
batch_norm_inference336.momentum = 0.9; migraphx::from_json_string(
auto mx336 = mm->add_instruction(batch_norm_inference336, mx335, mx160, mx159, mx158, mx157); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::relu relu337; x_main_module_279,
auto mx337 = mm->add_instruction(relu337, mx336); x_main_module_29);
migraphx::op::convolution convolution338; auto x_main_module_281 = mmain->add_instruction(
convolution338.padding = {1, 1}; migraphx::make_op("broadcast",
convolution338.stride = {1, 1}; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
convolution338.dilation = {1, 1}; x_main_module_28);
convolution338.group = 1; auto x_main_module_282 =
auto mx338 = mm->add_instruction(convolution338, mx337, mx156); mmain->add_instruction(migraphx::make_op("add"), x_main_module_280, x_main_module_281);
migraphx::op::batch_norm_inference batch_norm_inference339; auto x_main_module_283 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_282);
batch_norm_inference339.epsilon = 1e-05; auto x_main_module_284 = mmain->add_instruction(
batch_norm_inference339.momentum = 0.9; migraphx::make_op(
auto mx339 = mm->add_instruction(batch_norm_inference339, mx338, mx155, mx154, mx153, mx152); "convolution",
migraphx::op::relu relu340; migraphx::from_json_string(
auto mx340 = mm->add_instruction(relu340, mx339); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
migraphx::op::convolution convolution341; x_main_module_283,
convolution341.padding = {0, 0}; x_main_module_27);
convolution341.stride = {1, 1}; auto x_main_module_285 = mmain->add_instruction(
convolution341.dilation = {1, 1}; migraphx::make_op("broadcast",
convolution341.group = 1; migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
auto mx341 = mm->add_instruction(convolution341, mx340, mx151); x_main_module_26);
migraphx::op::batch_norm_inference batch_norm_inference342; auto x_main_module_286 =
batch_norm_inference342.epsilon = 1e-05; mmain->add_instruction(migraphx::make_op("add"), x_main_module_284, x_main_module_285);
batch_norm_inference342.momentum = 0.9; auto x_main_module_287 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_286);
auto mx342 = mm->add_instruction(batch_norm_inference342, mx341, mx150, mx149, mx148, mx147); auto x_main_module_288 = mmain->add_instruction(
migraphx::op::add add343; migraphx::make_op(
auto mx343 = mm->add_instruction(add343, mx342, mx334); "convolution",
migraphx::op::relu relu344; migraphx::from_json_string(
auto mx344 = mm->add_instruction(relu344, mx343); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::convolution convolution345; x_main_module_287,
convolution345.padding = {0, 0}; x_main_module_25);
convolution345.stride = {1, 1}; auto x_main_module_289 = mmain->add_instruction(
convolution345.dilation = {1, 1}; migraphx::make_op("broadcast",
convolution345.group = 1; migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
auto mx345 = mm->add_instruction(convolution345, mx344, mx146); x_main_module_24);
migraphx::op::batch_norm_inference batch_norm_inference346; auto x_main_module_290 =
batch_norm_inference346.epsilon = 1e-05; mmain->add_instruction(migraphx::make_op("add"), x_main_module_288, x_main_module_289);
batch_norm_inference346.momentum = 0.9; auto x_main_module_291 =
auto mx346 = mm->add_instruction(batch_norm_inference346, mx345, mx145, mx144, mx143, mx142); mmain->add_instruction(migraphx::make_op("add"), x_main_module_290, x_main_module_279);
migraphx::op::relu relu347; auto x_main_module_292 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_291);
auto mx347 = mm->add_instruction(relu347, mx346); auto x_main_module_293 = mmain->add_instruction(
migraphx::op::convolution convolution348; migraphx::make_op(
convolution348.padding = {1, 1}; "convolution",
convolution348.stride = {2, 2}; migraphx::from_json_string(
convolution348.dilation = {1, 1}; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
convolution348.group = 1; x_main_module_292,
auto mx348 = mm->add_instruction(convolution348, mx347, mx141); x_main_module_23);
migraphx::op::batch_norm_inference batch_norm_inference349; auto x_main_module_294 = mmain->add_instruction(
batch_norm_inference349.epsilon = 1e-05; migraphx::make_op("broadcast",
batch_norm_inference349.momentum = 0.9; migraphx::from_json_string("{axis:1,out_lens:[1,512,14,14]}")),
auto mx349 = mm->add_instruction(batch_norm_inference349, mx348, mx140, mx139, mx138, mx137); x_main_module_22);
migraphx::op::relu relu350; auto x_main_module_295 =
auto mx350 = mm->add_instruction(relu350, mx349); mmain->add_instruction(migraphx::make_op("add"), x_main_module_293, x_main_module_294);
migraphx::op::convolution convolution351; auto x_main_module_296 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_295);
convolution351.padding = {0, 0}; auto x_main_module_297 = mmain->add_instruction(
convolution351.stride = {1, 1}; migraphx::make_op(
convolution351.dilation = {1, 1}; "convolution",
convolution351.group = 1; migraphx::from_json_string(
auto mx351 = mm->add_instruction(convolution351, mx350, mx136); "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
migraphx::op::batch_norm_inference batch_norm_inference352; x_main_module_296,
batch_norm_inference352.epsilon = 1e-05; x_main_module_21);
batch_norm_inference352.momentum = 0.9; auto x_main_module_298 = mmain->add_instruction(
auto mx352 = mm->add_instruction(batch_norm_inference352, mx351, mx135, mx134, mx133, mx132); migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
migraphx::op::convolution convolution353; x_main_module_20);
convolution353.padding = {0, 0}; auto x_main_module_299 =
convolution353.stride = {2, 2}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_297, x_main_module_298);
convolution353.dilation = {1, 1}; auto x_main_module_300 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_299);
convolution353.group = 1; auto x_main_module_301 = mmain->add_instruction(
auto mx353 = mm->add_instruction(convolution353, mx344, mx131); migraphx::make_op(
migraphx::op::batch_norm_inference batch_norm_inference354; "convolution",
batch_norm_inference354.epsilon = 1e-05; migraphx::from_json_string(
batch_norm_inference354.momentum = 0.9; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
auto mx354 = mm->add_instruction(batch_norm_inference354, mx353, mx130, mx129, mx128, mx127); x_main_module_300,
migraphx::op::add add355; x_main_module_19);
auto mx355 = mm->add_instruction(add355, mx352, mx354); auto x_main_module_302 = mmain->add_instruction(
migraphx::op::relu relu356; migraphx::make_op("broadcast",
auto mx356 = mm->add_instruction(relu356, mx355); migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
migraphx::op::convolution convolution357; x_main_module_18);
convolution357.padding = {0, 0}; auto x_main_module_303 =
convolution357.stride = {1, 1}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_301, x_main_module_302);
convolution357.dilation = {1, 1}; auto x_main_module_304 = mmain->add_instruction(
convolution357.group = 1; migraphx::make_op(
auto mx357 = mm->add_instruction(convolution357, mx356, mx126); "convolution",
migraphx::op::batch_norm_inference batch_norm_inference358; migraphx::from_json_string(
batch_norm_inference358.epsilon = 1e-05; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
batch_norm_inference358.momentum = 0.9; x_main_module_292,
auto mx358 = mm->add_instruction(batch_norm_inference358, mx357, mx125, mx124, mx123, mx122); x_main_module_17);
migraphx::op::relu relu359; auto x_main_module_305 = mmain->add_instruction(
auto mx359 = mm->add_instruction(relu359, mx358); migraphx::make_op("broadcast",
migraphx::op::convolution convolution360; migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
convolution360.padding = {1, 1}; x_main_module_16);
convolution360.stride = {1, 1}; auto x_main_module_306 =
convolution360.dilation = {1, 1}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_304, x_main_module_305);
convolution360.group = 1; auto x_main_module_307 =
auto mx360 = mm->add_instruction(convolution360, mx359, mx121); mmain->add_instruction(migraphx::make_op("add"), x_main_module_303, x_main_module_306);
migraphx::op::batch_norm_inference batch_norm_inference361; auto x_main_module_308 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_307);
batch_norm_inference361.epsilon = 1e-05; auto x_main_module_309 = mmain->add_instruction(
batch_norm_inference361.momentum = 0.9; migraphx::make_op(
auto mx361 = mm->add_instruction(batch_norm_inference361, mx360, mx120, mx119, mx118, mx117); "convolution",
migraphx::op::relu relu362; migraphx::from_json_string(
auto mx362 = mm->add_instruction(relu362, mx361); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::convolution convolution363; x_main_module_308,
convolution363.padding = {0, 0}; x_main_module_15);
convolution363.stride = {1, 1}; auto x_main_module_310 = mmain->add_instruction(
convolution363.dilation = {1, 1}; migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
convolution363.group = 1; x_main_module_14);
auto mx363 = mm->add_instruction(convolution363, mx362, mx116); auto x_main_module_311 =
migraphx::op::batch_norm_inference batch_norm_inference364; mmain->add_instruction(migraphx::make_op("add"), x_main_module_309, x_main_module_310);
batch_norm_inference364.epsilon = 1e-05; auto x_main_module_312 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_311);
batch_norm_inference364.momentum = 0.9; auto x_main_module_313 = mmain->add_instruction(
auto mx364 = mm->add_instruction(batch_norm_inference364, mx363, mx115, mx114, mx113, mx112); migraphx::make_op(
migraphx::op::add add365; "convolution",
auto mx365 = mm->add_instruction(add365, mx364, mx356); migraphx::from_json_string(
migraphx::op::relu relu366; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
auto mx366 = mm->add_instruction(relu366, mx365); x_main_module_312,
migraphx::op::convolution convolution367; x_main_module_13);
convolution367.padding = {0, 0}; auto x_main_module_314 = mmain->add_instruction(
convolution367.stride = {1, 1}; migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
convolution367.dilation = {1, 1}; x_main_module_12);
convolution367.group = 1; auto x_main_module_315 =
auto mx367 = mm->add_instruction(convolution367, mx366, mx111); mmain->add_instruction(migraphx::make_op("add"), x_main_module_313, x_main_module_314);
migraphx::op::batch_norm_inference batch_norm_inference368; auto x_main_module_316 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_315);
batch_norm_inference368.epsilon = 1e-05; auto x_main_module_317 = mmain->add_instruction(
batch_norm_inference368.momentum = 0.9; migraphx::make_op(
auto mx368 = mm->add_instruction(batch_norm_inference368, mx367, mx110, mx109, mx108, mx107); "convolution",
migraphx::op::relu relu369; migraphx::from_json_string(
auto mx369 = mm->add_instruction(relu369, mx368); "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
migraphx::op::convolution convolution370; x_main_module_316,
convolution370.padding = {1, 1}; x_main_module_11);
convolution370.stride = {1, 1}; auto x_main_module_318 = mmain->add_instruction(
convolution370.dilation = {1, 1}; migraphx::make_op("broadcast",
convolution370.group = 1; migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
auto mx370 = mm->add_instruction(convolution370, mx369, mx106); x_main_module_10);
migraphx::op::batch_norm_inference batch_norm_inference371; auto x_main_module_319 =
batch_norm_inference371.epsilon = 1e-05; mmain->add_instruction(migraphx::make_op("add"), x_main_module_317, x_main_module_318);
batch_norm_inference371.momentum = 0.9; auto x_main_module_320 =
auto mx371 = mm->add_instruction(batch_norm_inference371, mx370, mx105, mx104, mx103, mx102); mmain->add_instruction(migraphx::make_op("add"), x_main_module_319, x_main_module_308);
migraphx::op::relu relu372; auto x_main_module_321 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_320);
auto mx372 = mm->add_instruction(relu372, mx371); auto x_main_module_322 = mmain->add_instruction(
migraphx::op::convolution convolution373; migraphx::make_op(
convolution373.padding = {0, 0}; "convolution",
convolution373.stride = {1, 1}; migraphx::from_json_string(
convolution373.dilation = {1, 1}; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
convolution373.group = 1; x_main_module_321,
auto mx373 = mm->add_instruction(convolution373, mx372, mx101); x_main_module_9);
migraphx::op::batch_norm_inference batch_norm_inference374; auto x_main_module_323 = mmain->add_instruction(
batch_norm_inference374.epsilon = 1e-05; migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
batch_norm_inference374.momentum = 0.9; x_main_module_8);
auto mx374 = mm->add_instruction(batch_norm_inference374, mx373, mx100, mx99, mx98, mx97); auto x_main_module_324 =
migraphx::op::add add375; mmain->add_instruction(migraphx::make_op("add"), x_main_module_322, x_main_module_323);
auto mx375 = mm->add_instruction(add375, mx374, mx366); auto x_main_module_325 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_324);
migraphx::op::relu relu376; auto x_main_module_326 = mmain->add_instruction(
auto mx376 = mm->add_instruction(relu376, mx375); migraphx::make_op(
migraphx::op::convolution convolution377; "convolution",
convolution377.padding = {0, 0}; migraphx::from_json_string(
convolution377.stride = {1, 1}; "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
convolution377.dilation = {1, 1}; x_main_module_325,
convolution377.group = 1; x_main_module_7);
auto mx377 = mm->add_instruction(convolution377, mx376, mx96); auto x_main_module_327 = mmain->add_instruction(
migraphx::op::batch_norm_inference batch_norm_inference378; migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
batch_norm_inference378.epsilon = 1e-05; x_main_module_6);
batch_norm_inference378.momentum = 0.9; auto x_main_module_328 =
auto mx378 = mm->add_instruction(batch_norm_inference378, mx377, mx95, mx94, mx93, mx92); mmain->add_instruction(migraphx::make_op("add"), x_main_module_326, x_main_module_327);
migraphx::op::relu relu379; auto x_main_module_329 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_328);
auto mx379 = mm->add_instruction(relu379, mx378); auto x_main_module_330 = mmain->add_instruction(
migraphx::op::convolution convolution380; migraphx::make_op(
convolution380.padding = {1, 1}; "convolution",
convolution380.stride = {1, 1}; migraphx::from_json_string(
convolution380.dilation = {1, 1}; "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
convolution380.group = 1; x_main_module_329,
auto mx380 = mm->add_instruction(convolution380, mx379, mx91); x_main_module_5);
migraphx::op::batch_norm_inference batch_norm_inference381; auto x_main_module_331 = mmain->add_instruction(
batch_norm_inference381.epsilon = 1e-05; migraphx::make_op("broadcast",
batch_norm_inference381.momentum = 0.9; migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
auto mx381 = mm->add_instruction(batch_norm_inference381, mx380, mx90, mx89, mx88, mx87); x_main_module_4);
migraphx::op::relu relu382; auto x_main_module_332 =
auto mx382 = mm->add_instruction(relu382, mx381); mmain->add_instruction(migraphx::make_op("add"), x_main_module_330, x_main_module_331);
migraphx::op::convolution convolution383; auto x_main_module_333 =
convolution383.padding = {0, 0}; mmain->add_instruction(migraphx::make_op("add"), x_main_module_332, x_main_module_321);
convolution383.stride = {1, 1}; auto x_main_module_334 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_333);
convolution383.dilation = {1, 1}; auto x_main_module_335 = mmain->add_instruction(
convolution383.group = 1; migraphx::make_op(
auto mx383 = mm->add_instruction(convolution383, mx382, mx86); "pooling",
migraphx::op::batch_norm_inference batch_norm_inference384; migraphx::from_json_string(
batch_norm_inference384.epsilon = 1e-05; "{ceil_mode:0,lengths:[7,7],lp_order:2,mode:0,padding:[0,0,0,0],stride:[1,1]}")),
batch_norm_inference384.momentum = 0.9; x_main_module_334);
auto mx384 = mm->add_instruction(batch_norm_inference384, mx383, mx85, mx84, mx83, mx82); auto x_main_module_336 = mmain->add_instruction(
migraphx::op::add add385; migraphx::make_op("reshape", migraphx::from_json_string("{dims:[1,-1]}")),
auto mx385 = mm->add_instruction(add385, mx384, mx376); x_main_module_335);
migraphx::op::relu relu386; auto x_main_module_337 = mmain->add_instruction(
auto mx386 = mm->add_instruction(relu386, mx385); migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
migraphx::op::convolution convolution387; x_main_module_2);
convolution387.padding = {0, 0}; auto x_main_module_338 =
convolution387.stride = {1, 1}; mmain->add_instruction(migraphx::make_op("dot"), x_main_module_336, x_main_module_337);
convolution387.dilation = {1, 1}; auto x_main_module_339 = mmain->add_instruction(
convolution387.group = 1; migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
auto mx387 = mm->add_instruction(convolution387, mx386, mx81); x_main_module_3);
migraphx::op::batch_norm_inference batch_norm_inference388; auto x_main_module_340 = mmain->add_instruction(
batch_norm_inference388.epsilon = 1e-05; migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
batch_norm_inference388.momentum = 0.9; x_main_module_0);
auto mx388 = mm->add_instruction(batch_norm_inference388, mx387, mx80, mx79, mx78, mx77); auto x_main_module_341 =
migraphx::op::relu relu389; mmain->add_instruction(migraphx::make_op("mul"), x_main_module_339, x_main_module_340);
auto mx389 = mm->add_instruction(relu389, mx388); auto x_main_module_342 =
migraphx::op::convolution convolution390; mmain->add_instruction(migraphx::make_op("add"), x_main_module_338, x_main_module_341);
convolution390.padding = {1, 1}; mmain->add_return({x_main_module_342});
convolution390.stride = {1, 1};
convolution390.dilation = {1, 1};
convolution390.group = 1;
auto mx390 = mm->add_instruction(convolution390, mx389, mx76);
migraphx::op::batch_norm_inference batch_norm_inference391;
batch_norm_inference391.epsilon = 1e-05;
batch_norm_inference391.momentum = 0.9;
auto mx391 = mm->add_instruction(batch_norm_inference391, mx390, mx75, mx74, mx73, mx72);
migraphx::op::relu relu392;
auto mx392 = mm->add_instruction(relu392, mx391);
migraphx::op::convolution convolution393;
convolution393.padding = {0, 0};
convolution393.stride = {1, 1};
convolution393.dilation = {1, 1};
convolution393.group = 1;
auto mx393 = mm->add_instruction(convolution393, mx392, mx71);
migraphx::op::batch_norm_inference batch_norm_inference394;
batch_norm_inference394.epsilon = 1e-05;
batch_norm_inference394.momentum = 0.9;
auto mx394 = mm->add_instruction(batch_norm_inference394, mx393, mx70, mx69, mx68, mx67);
migraphx::op::add add395;
auto mx395 = mm->add_instruction(add395, mx394, mx386);
migraphx::op::relu relu396;
auto mx396 = mm->add_instruction(relu396, mx395);
migraphx::op::convolution convolution397;
convolution397.padding = {0, 0};
convolution397.stride = {1, 1};
convolution397.dilation = {1, 1};
convolution397.group = 1;
auto mx397 = mm->add_instruction(convolution397, mx396, mx66);
migraphx::op::batch_norm_inference batch_norm_inference398;
batch_norm_inference398.epsilon = 1e-05;
batch_norm_inference398.momentum = 0.9;
auto mx398 = mm->add_instruction(batch_norm_inference398, mx397, mx65, mx64, mx63, mx62);
migraphx::op::relu relu399;
auto mx399 = mm->add_instruction(relu399, mx398);
migraphx::op::convolution convolution400;
convolution400.padding = {1, 1};
convolution400.stride = {1, 1};
convolution400.dilation = {1, 1};
convolution400.group = 1;
auto mx400 = mm->add_instruction(convolution400, mx399, mx61);
migraphx::op::batch_norm_inference batch_norm_inference401;
batch_norm_inference401.epsilon = 1e-05;
batch_norm_inference401.momentum = 0.9;
auto mx401 = mm->add_instruction(batch_norm_inference401, mx400, mx60, mx59, mx58, mx57);
migraphx::op::relu relu402;
auto mx402 = mm->add_instruction(relu402, mx401);
migraphx::op::convolution convolution403;
convolution403.padding = {0, 0};
convolution403.stride = {1, 1};
convolution403.dilation = {1, 1};
convolution403.group = 1;
auto mx403 = mm->add_instruction(convolution403, mx402, mx56);
migraphx::op::batch_norm_inference batch_norm_inference404;
batch_norm_inference404.epsilon = 1e-05;
batch_norm_inference404.momentum = 0.9;
auto mx404 = mm->add_instruction(batch_norm_inference404, mx403, mx55, mx54, mx53, mx52);
migraphx::op::add add405;
auto mx405 = mm->add_instruction(add405, mx404, mx396);
migraphx::op::relu relu406;
auto mx406 = mm->add_instruction(relu406, mx405);
migraphx::op::convolution convolution407;
convolution407.padding = {0, 0};
convolution407.stride = {1, 1};
convolution407.dilation = {1, 1};
convolution407.group = 1;
auto mx407 = mm->add_instruction(convolution407, mx406, mx51);
migraphx::op::batch_norm_inference batch_norm_inference408;
batch_norm_inference408.epsilon = 1e-05;
batch_norm_inference408.momentum = 0.9;
auto mx408 = mm->add_instruction(batch_norm_inference408, mx407, mx50, mx49, mx48, mx47);
migraphx::op::relu relu409;
auto mx409 = mm->add_instruction(relu409, mx408);
migraphx::op::convolution convolution410;
convolution410.padding = {1, 1};
convolution410.stride = {2, 2};
convolution410.dilation = {1, 1};
convolution410.group = 1;
auto mx410 = mm->add_instruction(convolution410, mx409, mx46);
migraphx::op::batch_norm_inference batch_norm_inference411;
batch_norm_inference411.epsilon = 1e-05;
batch_norm_inference411.momentum = 0.9;
auto mx411 = mm->add_instruction(batch_norm_inference411, mx410, mx45, mx44, mx43, mx42);
migraphx::op::relu relu412;
auto mx412 = mm->add_instruction(relu412, mx411);
migraphx::op::convolution convolution413;
convolution413.padding = {0, 0};
convolution413.stride = {1, 1};
convolution413.dilation = {1, 1};
convolution413.group = 1;
auto mx413 = mm->add_instruction(convolution413, mx412, mx41);
migraphx::op::batch_norm_inference batch_norm_inference414;
batch_norm_inference414.epsilon = 1e-05;
batch_norm_inference414.momentum = 0.9;
auto mx414 = mm->add_instruction(batch_norm_inference414, mx413, mx40, mx39, mx38, mx37);
migraphx::op::convolution convolution415;
convolution415.padding = {0, 0};
convolution415.stride = {2, 2};
convolution415.dilation = {1, 1};
convolution415.group = 1;
auto mx415 = mm->add_instruction(convolution415, mx406, mx36);
migraphx::op::batch_norm_inference batch_norm_inference416;
batch_norm_inference416.epsilon = 1e-05;
batch_norm_inference416.momentum = 0.9;
auto mx416 = mm->add_instruction(batch_norm_inference416, mx415, mx35, mx34, mx33, mx32);
migraphx::op::add add417;
auto mx417 = mm->add_instruction(add417, mx414, mx416);
migraphx::op::relu relu418;
auto mx418 = mm->add_instruction(relu418, mx417);
migraphx::op::convolution convolution419;
convolution419.padding = {0, 0};
convolution419.stride = {1, 1};
convolution419.dilation = {1, 1};
convolution419.group = 1;
auto mx419 = mm->add_instruction(convolution419, mx418, mx31);
migraphx::op::batch_norm_inference batch_norm_inference420;
batch_norm_inference420.epsilon = 1e-05;
batch_norm_inference420.momentum = 0.9;
auto mx420 = mm->add_instruction(batch_norm_inference420, mx419, mx30, mx29, mx28, mx27);
migraphx::op::relu relu421;
auto mx421 = mm->add_instruction(relu421, mx420);
migraphx::op::convolution convolution422;
convolution422.padding = {1, 1};
convolution422.stride = {1, 1};
convolution422.dilation = {1, 1};
convolution422.group = 1;
auto mx422 = mm->add_instruction(convolution422, mx421, mx26);
migraphx::op::batch_norm_inference batch_norm_inference423;
batch_norm_inference423.epsilon = 1e-05;
batch_norm_inference423.momentum = 0.9;
auto mx423 = mm->add_instruction(batch_norm_inference423, mx422, mx25, mx24, mx23, mx22);
migraphx::op::relu relu424;
auto mx424 = mm->add_instruction(relu424, mx423);
migraphx::op::convolution convolution425;
convolution425.padding = {0, 0};
convolution425.stride = {1, 1};
convolution425.dilation = {1, 1};
convolution425.group = 1;
auto mx425 = mm->add_instruction(convolution425, mx424, mx21);
migraphx::op::batch_norm_inference batch_norm_inference426;
batch_norm_inference426.epsilon = 1e-05;
batch_norm_inference426.momentum = 0.9;
auto mx426 = mm->add_instruction(batch_norm_inference426, mx425, mx20, mx19, mx18, mx17);
migraphx::op::add add427;
auto mx427 = mm->add_instruction(add427, mx426, mx418);
migraphx::op::relu relu428;
auto mx428 = mm->add_instruction(relu428, mx427);
migraphx::op::convolution convolution429;
convolution429.padding = {0, 0};
convolution429.stride = {1, 1};
convolution429.dilation = {1, 1};
convolution429.group = 1;
auto mx429 = mm->add_instruction(convolution429, mx428, mx16);
migraphx::op::batch_norm_inference batch_norm_inference430;
batch_norm_inference430.epsilon = 1e-05;
batch_norm_inference430.momentum = 0.9;
auto mx430 = mm->add_instruction(batch_norm_inference430, mx429, mx15, mx14, mx13, mx12);
migraphx::op::relu relu431;
auto mx431 = mm->add_instruction(relu431, mx430);
migraphx::op::convolution convolution432;
convolution432.padding = {1, 1};
convolution432.stride = {1, 1};
convolution432.dilation = {1, 1};
convolution432.group = 1;
auto mx432 = mm->add_instruction(convolution432, mx431, mx11);
migraphx::op::batch_norm_inference batch_norm_inference433;
batch_norm_inference433.epsilon = 1e-05;
batch_norm_inference433.momentum = 0.9;
auto mx433 = mm->add_instruction(batch_norm_inference433, mx432, mx10, mx9, mx8, mx7);
migraphx::op::relu relu434;
auto mx434 = mm->add_instruction(relu434, mx433);
migraphx::op::convolution convolution435;
convolution435.padding = {0, 0};
convolution435.stride = {1, 1};
convolution435.dilation = {1, 1};
convolution435.group = 1;
auto mx435 = mm->add_instruction(convolution435, mx434, mx6);
migraphx::op::batch_norm_inference batch_norm_inference436;
batch_norm_inference436.epsilon = 1e-05;
batch_norm_inference436.momentum = 0.9;
auto mx436 = mm->add_instruction(batch_norm_inference436, mx435, mx5, mx4, mx3, mx2);
migraphx::op::add add437;
auto mx437 = mm->add_instruction(add437, mx436, mx428);
migraphx::op::relu relu438;
auto mx438 = mm->add_instruction(relu438, mx437);
migraphx::op::pooling pooling439;
pooling439.mode = migraphx::op::pooling_mode::average;
pooling439.padding = {0, 0};
pooling439.stride = {1, 1};
pooling439.lengths = {7, 7};
auto mx439 = mm->add_instruction(pooling439, mx438);
migraphx::op::flatten flatten440;
flatten440.axis = 1;
auto mx440 = mm->add_instruction(flatten440, mx439);
migraphx::op::transpose transpose441;
transpose441.dims = {1, 0};
auto mx441 = mm->add_instruction(transpose441, mx1);
migraphx::op::multibroadcast multibroadcast442;
multibroadcast442.output_lens = {batch, 1000};
auto mx442 = mm->add_instruction(multibroadcast442, mx0);
float dot443_alpha = 1;
float dot443_beta = 1;
migraphx::add_apply_alpha_beta(
*mm, {mx440, mx441, mx442}, migraphx::make_op("dot"), dot443_alpha, dot443_beta);
return p; return p;
} }
} // namespace MIGRAPHX_INLINE_NS } // namespace MIGRAPHX_INLINE_NS
} // namespace driver } // namespace driver
} // namespace migraphx } // namespace migraphx
src/eliminate_contiguous.cpp
View file @ 5f215b71
...@@ -93,9 +93,11 @@ static bool try_compute_shape(instruction_ref ins, ...@@ -93,9 +93,11 @@ static bool try_compute_shape(instruction_ref ins,
return try_compute_shape(ins, inputs, mods); return try_compute_shape(ins, inputs, mods);
} }
void eliminate_contiguous::apply(module& m) const template <class F>
static void remove_contiguous(const std::string& op_name, module& m, F f)
{ {
std::vector<instruction_ref> const_instruction; auto last = std::prev(m.end());
std::vector<instruction_ref> const_instructions;
for(auto ins : iterator_for(m)) for(auto ins : iterator_for(m))
{ {
...@@ -103,6 +105,12 @@ void eliminate_contiguous::apply(module& m) const ...@@ -103,6 +105,12 @@ void eliminate_contiguous::apply(module& m) const
if(ins->name() == "@return") if(ins->name() == "@return")
continue; continue;
if(ins != last and ins->outputs().empty())
continue;
if(not f(ins))
continue;
// Make a copy so we can modify it while we iterate // Make a copy so we can modify it while we iterate
auto args = ins->inputs(); auto args = ins->inputs();
auto new_args = args; auto new_args = args;
...@@ -110,8 +118,8 @@ void eliminate_contiguous::apply(module& m) const ...@@ -110,8 +118,8 @@ void eliminate_contiguous::apply(module& m) const
for(auto arg : ins->inputs()) for(auto arg : ins->inputs())
{ {
if(arg->name() == op_name) if(arg->name() != op_name)
{ continue;
auto prev = arg->inputs().front(); auto prev = arg->inputs().front();
replace(new_args, arg, prev); replace(new_args, arg, prev);
if(try_compute_shape(ins, new_args, mod_args)) if(try_compute_shape(ins, new_args, mod_args))
...@@ -120,26 +128,36 @@ void eliminate_contiguous::apply(module& m) const ...@@ -120,26 +128,36 @@ void eliminate_contiguous::apply(module& m) const
} }
else if(prev->can_eval()) else if(prev->can_eval())
{ {
const_instruction.push_back(arg); const_instructions.push_back(arg);
}
} }
} }
} }
// Perform evaluations in parallel // Perform evaluations in parallel
std::vector<argument> literals(const_instruction.size()); std::vector<argument> literals(const_instructions.size());
par_for(const_instruction.size(), 1, [&](const auto i) { par_for(const_instructions.size(), 1, [&](const auto i) {
auto c = op::contiguous{}; auto c = op::contiguous{};
auto prev = const_instruction[i]->inputs().front(); auto prev = const_instructions[i]->inputs().front();
literals[i] = c.compute(c.compute_shape({prev->get_shape()}), {prev->eval()}); literals[i] = c.compute(c.compute_shape({prev->get_shape()}), {prev->eval()});
}); });
for(size_t i = 0; i < const_instruction.size(); i++) for(size_t i = 0; i < const_instructions.size(); i++)
{ {
auto l = m.add_literal(literals[i].get_shape(), literals[i].data()); auto l = m.add_literal(literals[i].get_shape(), literals[i].data());
m.replace_instruction(const_instruction[i], l); m.replace_instruction(const_instructions[i], l);
} }
} }
void eliminate_contiguous::apply(module& m) const
{
// Skip contiguous from splits first
remove_contiguous(op_name, m, [](auto ins) {
if(ins->name() != "slice")
return true;
return (ins->inputs().front()->outputs().size() == 1);
});
remove_contiguous(op_name, m, [](auto) { return true; });
}
} // namespace MIGRAPHX_INLINE_NS } // namespace MIGRAPHX_INLINE_NS
} // namespace migraphx } // namespace migraphx
src/fuse_pointwise.cpp
View file @ 5f215b71
...@@ -142,7 +142,7 @@ static std::vector<instruction_ref> append_pointwise_module(instruction_ref ins, ...@@ -142,7 +142,7 @@ static std::vector<instruction_ref> append_pointwise_module(instruction_ref ins,
input_map[input] = map_ins[param]; input_map[input] = map_ins[param];
} }
} }
pm->replace_return(pm->insert_module_instructions(last, xm, map_ins)); pm->replace_return(pm->insert_instructions(last, xm, map_ins));
return inputs; return inputs;
} }
......
src/include/migraphx/assignment_options.hpp 0 → 100644
View file @ 5f215b71
/*
* The MIT License (MIT)
*
* Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef MIGRAPHX_GUARD_RTGLIB_ASSIGNMENT_OPTIONS_HPP
#define MIGRAPHX_GUARD_RTGLIB_ASSIGNMENT_OPTIONS_HPP
#include <migraphx/support_metric.hpp>
namespace migraphx {
inline namespace MIGRAPHX_INLINE_NS {
struct assignment_options
{
support_metric metric = support_metric::latency;
};
} // namespace MIGRAPHX_INLINE_NS
} // namespace migraphx
#endif // MIGRAPHX_GUARD_RTGLIB_ASSIGNMENT_OPTIONS_HPP
src/include/migraphx/iota_iterator.hpp
View file @ 5f215b71
...@@ -81,8 +81,9 @@ struct basic_iota_iterator ...@@ -81,8 +81,9 @@ struct basic_iota_iterator
index--; index--;
return it; return it;
} }
// TODO: operator->
reference operator*() const { return f(index); } reference operator*() const { return f(index); }
pointer operator->() const { return &f(index); }
reference operator[](int n) const { return f(index + n); }
}; };
template <class T, class F> template <class T, class F>
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment