Skip to content

GitLab

"llama/patches/0006-add-mllama-support.patch" did not exist on "bf4018b9ecd56a5deff0c22ca2fba242a8f0101b"
Commit eb4dfb49 authored by charlie's avatar charlie
Browse files

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

parents 20394c35 2783c649
Show whitespace changes
Inline Side-by-side
Showing with 3895 additions and 3752 deletions
examples/migraphx/custom_op_hip_kernel/CMakeLists.txt 0 → 100755
View file @ eb4dfb49
#####################################################################################
# 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 @ eb4dfb49
# 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 @ eb4dfb49
/*
* 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 @ eb4dfb49
#####################################################################################
# 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 @ eb4dfb49
# 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 @ eb4dfb49
/*
* 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 @ eb4dfb49
#####################################################################################
# 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 @ eb4dfb49
# 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 @ eb4dfb49
/*
* 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 @ eb4dfb49
......@@ -80,7 +80,7 @@
"outputs": [],
"source": [
"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",
" !/opt/rocm/bin/migraphx-driver compile ./utilities/yolov4.onnx --gpu --enable-offload-copy --binary -o yolov4.mxr"
]
......
src/driver/alexnet.cpp
View file @ eb4dfb49
/*
* The MIT License (MIT)
*
......@@ -21,10 +22,10 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <migraphx/operators.hpp>
#include <migraphx/make_op.hpp>
#include <migraphx/program.hpp>
#include <migraphx/generate.hpp>
#include <migraphx/apply_alpha_beta.hpp>
#include <migraphx/json.hpp>
#include "models.hpp"
namespace migraphx {
......@@ -34,173 +35,189 @@ inline namespace MIGRAPHX_INLINE_NS {
migraphx::program alexnet(unsigned batch) // NOLINT(readability-function-size)
{
migraphx::program p;
auto* mm = p.get_main_module();
auto m0 =
mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
auto mx0 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 0));
auto mx1 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 4096}}, 1));
auto mx2 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 2));
auto mx3 = mm->add_literal(
migraphx::module_ref mmain = p.get_main_module();
auto x_main_module_0 = mmain->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 0)));
auto x_main_module_1 = mmain->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 1)));
auto x_main_module_2 = mmain->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 2)));
auto x_input_1 = mmain->add_parameter(
"input.1", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
auto x_main_module_4 = mmain->add_literal(
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));
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));
auto mx6 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 6));
auto mx7 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 7));
auto mx8 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 8));
auto mx9 = mm->add_literal(migraphx::generate_literal(
auto x_main_module_7 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 6));
auto x_main_module_8 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 4096}}, 7));
auto x_main_module_9 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 8));
auto x_main_module_10 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 384, 3, 3}}, 9));
auto mx10 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {384}}, 10));
auto mx11 = mm->add_literal(migraphx::generate_literal(
auto x_main_module_11 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 10));
auto x_main_module_12 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {384, 192, 3, 3}}, 11));
auto mx12 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {192}}, 12));
auto mx13 = mm->add_literal(migraphx::generate_literal(
auto x_main_module_13 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {384}}, 12));
auto x_main_module_14 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {192, 64, 5, 5}}, 13));
auto mx14 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 14));
auto mx15 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 3, 11, 11}}, 15));
migraphx::op::convolution convolution16;
convolution16.padding = {2, 2};
convolution16.stride = {4, 4};
convolution16.dilation = {1, 1};
convolution16.group = 1;
auto mx16 = mm->add_instruction(convolution16, m0, mx15);
migraphx::op::broadcast broadcast17;
broadcast17.axis = 1;
broadcast17.broadcast_lens = {batch, 64, 55, 55};
auto mx17 = mm->add_instruction(broadcast17, mx14);
migraphx::op::add add18;
auto mx18 = mm->add_instruction(add18, mx16, mx17);
migraphx::op::relu relu19;
auto mx19 = mm->add_instruction(relu19, mx18);
migraphx::op::pooling pooling20;
pooling20.mode = migraphx::op::pooling_mode::max;
pooling20.padding = {0, 0};
pooling20.stride = {2, 2};
pooling20.lengths = {3, 3};
auto mx20 = mm->add_instruction(pooling20, mx19);
migraphx::op::convolution convolution21;
convolution21.padding = {2, 2};
convolution21.stride = {1, 1};
convolution21.dilation = {1, 1};
convolution21.group = 1;
auto mx21 = mm->add_instruction(convolution21, mx20, mx13);
migraphx::op::broadcast broadcast22;
broadcast22.axis = 1;
broadcast22.broadcast_lens = {batch, 192, 27, 27};
auto mx22 = mm->add_instruction(broadcast22, mx12);
migraphx::op::add add23;
auto mx23 = mm->add_instruction(add23, mx21, mx22);
migraphx::op::relu relu24;
auto mx24 = mm->add_instruction(relu24, mx23);
migraphx::op::pooling pooling25;
pooling25.mode = migraphx::op::pooling_mode::max;
pooling25.padding = {0, 0};
pooling25.stride = {2, 2};
pooling25.lengths = {3, 3};
auto mx25 = mm->add_instruction(pooling25, mx24);
migraphx::op::convolution convolution26;
convolution26.padding = {1, 1};
convolution26.stride = {1, 1};
convolution26.dilation = {1, 1};
convolution26.group = 1;
auto mx26 = mm->add_instruction(convolution26, mx25, mx11);
migraphx::op::broadcast broadcast27;
broadcast27.axis = 1;
broadcast27.broadcast_lens = {batch, 384, 13, 13};
auto mx27 = mm->add_instruction(broadcast27, mx10);
migraphx::op::add add28;
auto mx28 = mm->add_instruction(add28, mx26, mx27);
migraphx::op::relu relu29;
auto mx29 = mm->add_instruction(relu29, mx28);
migraphx::op::convolution convolution30;
convolution30.padding = {1, 1};
convolution30.stride = {1, 1};
convolution30.dilation = {1, 1};
convolution30.group = 1;
auto mx30 = mm->add_instruction(convolution30, mx29, mx9);
migraphx::op::broadcast broadcast31;
broadcast31.axis = 1;
broadcast31.broadcast_lens = {batch, 256, 13, 13};
auto mx31 = mm->add_instruction(broadcast31, mx8);
migraphx::op::add add32;
auto mx32 = mm->add_instruction(add32, mx30, mx31);
migraphx::op::relu relu33;
auto mx33 = mm->add_instruction(relu33, mx32);
migraphx::op::convolution convolution34;
convolution34.padding = {1, 1};
convolution34.stride = {1, 1};
convolution34.dilation = {1, 1};
convolution34.group = 1;
auto mx34 = mm->add_instruction(convolution34, mx33, mx7);
migraphx::op::broadcast broadcast35;
broadcast35.axis = 1;
broadcast35.broadcast_lens = {batch, 256, 13, 13};
auto mx35 = mm->add_instruction(broadcast35, mx6);
migraphx::op::add add36;
auto mx36 = mm->add_instruction(add36, mx34, mx35);
migraphx::op::relu relu37;
auto mx37 = mm->add_instruction(relu37, mx36);
migraphx::op::pooling pooling38;
pooling38.mode = migraphx::op::pooling_mode::max;
pooling38.padding = {0, 0};
pooling38.stride = {2, 2};
pooling38.lengths = {3, 3};
auto mx38 = mm->add_instruction(pooling38, mx37);
migraphx::op::flatten flatten39;
flatten39.axis = 1;
auto mx39 = mm->add_instruction(flatten39, mx38);
migraphx::op::identity identity40;
auto mx40 = mm->add_instruction(identity40, mx39);
migraphx::op::transpose transpose41;
transpose41.dims = {1, 0};
auto mx41 = mm->add_instruction(transpose41, mx5);
migraphx::op::multibroadcast multibroadcast42;
multibroadcast42.output_lens = {batch, 4096};
auto mx42 = mm->add_instruction(multibroadcast42, mx4);
float dot43_alpha = 1;
float dot43_beta = 1;
auto mx43 = migraphx::add_apply_alpha_beta(
*mm, {mx40, mx41, mx42}, migraphx::make_op("dot"), dot43_alpha, dot43_beta);
migraphx::op::relu relu44;
auto mx44 = mm->add_instruction(relu44, mx43);
migraphx::op::identity identity45;
auto mx45 = mm->add_instruction(identity45, mx44);
migraphx::op::transpose transpose46;
transpose46.dims = {1, 0};
auto mx46 = mm->add_instruction(transpose46, mx3);
migraphx::op::multibroadcast multibroadcast47;
multibroadcast47.output_lens = {batch, 4096};
auto mx47 = mm->add_instruction(multibroadcast47, mx2);
float dot48_alpha = 1;
float dot48_beta = 1;
auto mx48 = migraphx::add_apply_alpha_beta(
*mm, {mx45, mx46, mx47}, migraphx::make_op("dot"), dot48_alpha, dot48_beta);
migraphx::op::relu relu49;
auto mx49 = mm->add_instruction(relu49, mx48);
migraphx::op::transpose transpose50;
transpose50.dims = {1, 0};
auto mx50 = mm->add_instruction(transpose50, mx1);
migraphx::op::multibroadcast multibroadcast51;
multibroadcast51.output_lens = {batch, 1000};
auto mx51 = mm->add_instruction(multibroadcast51, mx0);
float dot52_alpha = 1;
float dot52_beta = 1;
migraphx::add_apply_alpha_beta(
*mm, {mx49, mx50, mx51}, migraphx::make_op("dot"), dot52_alpha, dot52_beta);
auto x_main_module_15 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {192}}, 14));
auto x_main_module_16 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 15));
auto x_main_module_17 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 16));
auto x_main_module_18 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 3, 11, 11}}, 17));
auto x_main_module_19 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 18));
auto x_main_module_20 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[4,4]}")),
x_input_1,
x_main_module_18);
auto x_main_module_21 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,55,55]}")),
x_main_module_19);
auto x_main_module_22 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_20, x_main_module_21);
auto x_main_module_23 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_22);
auto x_main_module_24 = mmain->add_instruction(
migraphx::make_op(
"pooling",
migraphx::from_json_string(
"{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
x_main_module_23);
auto x_main_module_25 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[1,1]}")),
x_main_module_24,
x_main_module_14);
auto x_main_module_26 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,192,27,27]}")),
x_main_module_15);
auto x_main_module_27 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_25, x_main_module_26);
auto x_main_module_28 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_27);
auto x_main_module_29 = mmain->add_instruction(
migraphx::make_op(
"pooling",
migraphx::from_json_string(
"{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
x_main_module_28);
auto x_main_module_30 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_29,
x_main_module_12);
auto x_main_module_31 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,384,13,13]}")),
x_main_module_13);
auto x_main_module_32 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_30, x_main_module_31);
auto x_main_module_33 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_32);
auto x_main_module_34 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_33,
x_main_module_10);
auto x_main_module_35 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,13,13]}")),
x_main_module_11);
auto x_main_module_36 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_34, x_main_module_35);
auto x_main_module_37 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_36);
auto x_main_module_38 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_37,
x_main_module_16);
auto x_main_module_39 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,13,13]}")),
x_main_module_17);
auto x_main_module_40 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_38, x_main_module_39);
auto x_main_module_41 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_40);
auto x_main_module_42 = mmain->add_instruction(
migraphx::make_op(
"pooling",
migraphx::from_json_string(
"{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
x_main_module_41);
auto x_main_module_43 = mmain->add_instruction(
migraphx::make_op("reshape", migraphx::from_json_string("{dims:[1,9216]}")),
x_main_module_42);
auto x_main_module_44 = mmain->add_instruction(
migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
x_main_module_6);
auto x_main_module_45 =
mmain->add_instruction(migraphx::make_op("dot"), x_main_module_43, x_main_module_44);
auto x_main_module_46 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
x_main_module_7);
auto x_main_module_47 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
x_main_module_2);
auto x_main_module_48 =
mmain->add_instruction(migraphx::make_op("mul"), x_main_module_46, x_main_module_47);
auto x_main_module_49 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_45, x_main_module_48);
auto x_main_module_50 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_49);
auto x_main_module_51 = mmain->add_instruction(
migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
x_main_module_4);
auto x_main_module_52 =
mmain->add_instruction(migraphx::make_op("dot"), x_main_module_50, x_main_module_51);
auto x_main_module_53 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
x_main_module_5);
auto x_main_module_54 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
x_main_module_1);
auto x_main_module_55 =
mmain->add_instruction(migraphx::make_op("mul"), x_main_module_53, x_main_module_54);
auto x_main_module_56 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_52, x_main_module_55);
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;
}
} // namespace MIGRAPHX_INLINE_NS
} // namespace driver
} // namespace migraphx
src/driver/inceptionv3.cpp
View file @ eb4dfb49
This source diff could not be displayed because it is too large. You can view the blob instead.
src/driver/main.cpp
View file @ eb4dfb49
......@@ -210,6 +210,9 @@ struct loader
auto last = std::prev(mm->end(), trim);
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)
{
migraphx::run_passes(*p.get_main_module(),
......
src/driver/resnet50.cpp
View file @ eb4dfb49
/*
* The MIT License (MIT)
*
......@@ -21,10 +22,10 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <migraphx/operators.hpp>
#include <migraphx/make_op.hpp>
#include <migraphx/program.hpp>
#include <migraphx/generate.hpp>
#include <migraphx/apply_alpha_beta.hpp>
#include <migraphx/json.hpp>
#include "models.hpp"
namespace migraphx {
......@@ -34,1231 +35,1026 @@ inline namespace MIGRAPHX_INLINE_NS {
migraphx::program resnet50(unsigned batch) // NOLINT(readability-function-size)
{
migraphx::program p;
auto* mm = p.get_main_module();
auto m0 =
mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
auto mx0 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 0));
auto mx1 = mm->add_literal(
migraphx::module_ref mmain = p.get_main_module();
auto x_main_module_0 = mmain->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 0)));
auto x_input_1 = mmain->add_parameter(
"input.1", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
auto x_main_module_2 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 2048}}, 1));
auto mx2 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 2)));
auto mx3 = mm->add_literal(
auto x_main_module_3 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 2));
auto x_main_module_4 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 3));
auto mx4 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 4));
auto mx5 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 5)));
auto mx6 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 6));
auto mx7 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 7)));
auto mx8 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 8));
auto mx9 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 9));
auto mx10 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 10)));
auto mx11 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 11));
auto mx12 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 12)));
auto mx13 = mm->add_literal(
auto x_main_module_5 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 4));
auto x_main_module_6 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 5));
auto x_main_module_7 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 6));
auto x_main_module_8 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 7));
auto x_main_module_9 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 8));
auto x_main_module_10 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 9));
auto x_main_module_11 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 10));
auto x_main_module_12 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 11));
auto x_main_module_13 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 12));
auto x_main_module_14 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 13));
auto mx14 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 14));
auto mx15 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 15)));
auto mx16 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 16));
auto mx17 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 17)));
auto mx18 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 18));
auto mx19 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 19));
auto mx20 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 20)));
auto mx21 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 21));
auto mx22 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 22)));
auto mx23 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 23));
auto mx24 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 24));
auto mx25 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 25)));
auto mx26 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 26));
auto mx27 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 27)));
auto mx28 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 28));
auto mx29 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 29));
auto mx30 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 30)));
auto mx31 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 31));
auto mx32 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 32)));
auto mx33 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 33));
auto mx34 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 34));
auto mx35 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 35)));
auto mx36 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 1024, 1, 1}}, 36));
auto mx37 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 37)));
auto mx38 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 38));
auto mx39 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 39));
auto mx40 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 40)));
auto mx41 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 41));
auto mx42 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 42)));
auto mx43 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 43));
auto mx44 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 44));
auto mx45 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 45)));
auto mx46 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 46));
auto mx47 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 47)));
auto mx48 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 48));
auto mx49 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 49));
auto mx50 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 50)));
auto mx51 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 1024, 1, 1}}, 51));
auto mx52 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 52)));
auto mx53 = mm->add_literal(
auto x_main_module_15 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 14));
auto x_main_module_16 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 15));
auto x_main_module_17 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 1024, 1, 1}}, 16));
auto x_main_module_18 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 17));
auto x_main_module_19 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 18));
auto x_main_module_20 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 19));
auto x_main_module_21 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 20));
auto x_main_module_22 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 21));
auto x_main_module_23 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 1024, 1, 1}}, 22));
auto x_main_module_24 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 23));
auto x_main_module_25 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 24));
auto x_main_module_26 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 25));
auto x_main_module_27 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 26));
auto x_main_module_28 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 27));
auto x_main_module_29 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 28));
auto x_main_module_30 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 29));
auto x_main_module_31 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 30));
auto x_main_module_32 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 31));
auto x_main_module_33 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 32));
auto x_main_module_34 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 33));
auto x_main_module_35 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 34));
auto x_main_module_36 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 35));
auto x_main_module_37 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 36));
auto x_main_module_38 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 37));
auto x_main_module_39 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 38));
auto x_main_module_40 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 39));
auto x_main_module_41 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 40));
auto x_main_module_42 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 41));
auto x_main_module_43 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 42));
auto x_main_module_44 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 43));
auto x_main_module_45 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 44));
auto x_main_module_46 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 45));
auto x_main_module_47 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 46));
auto x_main_module_48 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 47));
auto x_main_module_49 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 48));
auto x_main_module_50 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 49));
auto x_main_module_51 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 50));
auto x_main_module_52 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 51));
auto x_main_module_53 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 52));
auto x_main_module_54 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 53));
auto mx54 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 54));
auto mx55 = mm->add_literal(
auto x_main_module_55 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 512, 1, 1}}, 54));
auto x_main_module_56 = mmain->add_literal(
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));
auto mx57 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 57)));
auto mx58 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 58));
auto mx59 = mm->add_literal(
auto x_main_module_58 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 57));
auto x_main_module_59 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 58));
auto x_main_module_60 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 59));
auto mx60 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 60)));
auto mx61 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 61));
auto mx62 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 62)));
auto mx63 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 63));
auto mx64 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 64));
auto mx65 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 65)));
auto mx66 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 66));
auto mx67 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 67)));
auto mx68 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 68));
auto mx69 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 69));
auto mx70 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 70));
auto mx71 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 71));
auto mx72 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 72)));
auto mx73 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 73));
auto mx74 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 74));
auto mx75 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 75)));
auto mx76 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 76));
auto mx77 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 77)));
auto mx78 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 78));
auto mx79 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 79));
auto mx80 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 80)));
auto mx81 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 81));
auto mx82 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 82)));
auto mx83 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 83));
auto mx84 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 84));
auto mx85 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 85));
auto mx86 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 86));
auto mx87 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 87)));
auto mx88 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 88));
auto mx89 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 89));
auto mx90 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 90)));
auto mx91 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 91));
auto mx92 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 92)));
auto mx93 = mm->add_literal(
auto x_main_module_61 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}}, 60));
auto x_main_module_62 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 61));
auto x_main_module_63 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 62));
auto x_main_module_64 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 63));
auto x_main_module_65 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 64));
auto x_main_module_66 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 65));
auto x_main_module_67 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 66));
auto x_main_module_68 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 67));
auto x_main_module_69 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 68));
auto x_main_module_70 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 69));
auto x_main_module_71 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 70));
auto x_main_module_72 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 71));
auto x_main_module_73 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 72));
auto x_main_module_74 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 73));
auto x_main_module_75 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 74));
auto x_main_module_76 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 75));
auto x_main_module_77 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 76));
auto x_main_module_78 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 77));
auto x_main_module_79 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 78));
auto x_main_module_80 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 79));
auto x_main_module_81 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 256, 1, 1}}, 80));
auto x_main_module_82 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 81));
auto x_main_module_83 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 82));
auto x_main_module_84 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 83));
auto x_main_module_85 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 84));
auto x_main_module_86 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 85));
auto x_main_module_87 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 256, 1, 1}}, 86));
auto x_main_module_88 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 87));
auto x_main_module_89 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 88));
auto x_main_module_90 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 89));
auto x_main_module_91 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 90));
auto x_main_module_92 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 91));
auto x_main_module_93 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 92));
auto x_main_module_94 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 93));
auto mx94 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 94));
auto mx95 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 95)));
auto mx96 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 96));
auto mx97 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 97)));
auto mx98 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 98));
auto mx99 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 99));
auto mx100 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 100));
auto mx101 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 101));
auto mx102 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 102)));
auto mx103 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 103));
auto mx104 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 104));
auto mx105 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 105)));
auto mx106 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 106));
auto mx107 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 107)));
auto mx108 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 108));
auto mx109 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 109));
auto mx110 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 110)));
auto mx111 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 111));
auto mx112 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 112)));
auto mx113 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 113));
auto mx114 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 114));
auto mx115 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 115));
auto mx116 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 116));
auto mx117 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 117)));
auto mx118 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 118));
auto mx119 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 119));
auto mx120 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 120)));
auto mx121 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 121));
auto mx122 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 122)));
auto mx123 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 123));
auto mx124 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 124));
auto mx125 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 125)));
auto mx126 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 126));
auto mx127 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 127)));
auto mx128 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 128));
auto mx129 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 129));
auto mx130 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 130));
auto mx131 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 512, 1, 1}}, 131));
auto mx132 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 132)));
auto mx133 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 133));
auto mx134 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 134));
auto mx135 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 135));
auto mx136 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 136));
auto mx137 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 137)));
auto mx138 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 138));
auto mx139 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 139));
auto mx140 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 140)));
auto mx141 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 141));
auto mx142 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 142)));
auto mx143 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 143));
auto mx144 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 144));
auto mx145 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 145)));
auto mx146 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}}, 146));
auto mx147 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 147)));
auto mx148 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 148));
auto mx149 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 149));
auto mx150 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 150));
auto mx151 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 151));
auto mx152 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 152)));
auto mx153 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 153));
auto mx154 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 154));
auto mx155 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 155)));
auto mx156 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 156));
auto mx157 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 157)));
auto mx158 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 158));
auto mx159 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 159));
auto mx160 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 160)));
auto mx161 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 161));
auto mx162 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 162)));
auto mx163 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 163));
auto mx164 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 164));
auto mx165 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 165));
auto mx166 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 166));
auto mx167 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 167)));
auto mx168 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 168));
auto mx169 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 169));
auto mx170 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 170)));
auto mx171 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 171));
auto mx172 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 172)));
auto mx173 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 173));
auto mx174 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 174));
auto mx175 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 175)));
auto mx176 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 176));
auto mx177 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 177)));
auto mx178 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 178));
auto mx179 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 179));
auto mx180 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 180));
auto mx181 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 181));
auto mx182 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 182)));
auto mx183 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 183));
auto mx184 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 184));
auto mx185 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 185)));
auto mx186 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 186));
auto mx187 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 187)));
auto mx188 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 188));
auto mx189 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 189));
auto mx190 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 190)));
auto mx191 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 191));
auto mx192 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 192)));
auto mx193 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 193));
auto mx194 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 194));
auto mx195 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 195));
auto mx196 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 256, 1, 1}}, 196));
auto mx197 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 197)));
auto mx198 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 198));
auto mx199 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 199));
auto mx200 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 200));
auto mx201 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 201));
auto mx202 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 202)));
auto mx203 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 203));
auto mx204 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 204));
auto mx205 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 205)));
auto mx206 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 206));
auto mx207 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 207)));
auto mx208 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 208));
auto mx209 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 209));
auto mx210 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 210)));
auto mx211 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {128, 256, 1, 1}}, 211));
auto mx212 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 212)));
auto mx213 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 213));
auto mx214 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 214));
auto mx215 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 215));
auto mx216 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 216));
auto mx217 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 217)));
auto mx218 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 218));
auto mx219 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 219));
auto mx220 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 220)));
auto mx221 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 221));
auto mx222 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 222)));
auto mx223 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 223));
auto mx224 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 224));
auto mx225 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 225)));
auto mx226 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 226));
auto mx227 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 227)));
auto mx228 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 228));
auto mx229 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 229));
auto mx230 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 230));
auto mx231 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 231));
auto mx232 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 232)));
auto mx233 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 233));
auto mx234 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 234));
auto mx235 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 235)));
auto mx236 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 236));
auto mx237 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 237)));
auto mx238 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 238));
auto mx239 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 239));
auto mx240 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 240)));
auto mx241 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 241));
auto mx242 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 242)));
auto mx243 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 243));
auto mx244 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 244));
auto mx245 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 245));
auto mx246 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 246));
auto mx247 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 247)));
auto mx248 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 248));
auto mx249 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 249));
auto mx250 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 250));
auto mx251 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 251));
auto mx252 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 252)));
auto mx253 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 253));
auto mx254 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 254));
auto mx255 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 255)));
auto mx256 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 256));
auto mx257 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 257)));
auto mx258 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 258));
auto mx259 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 259));
auto mx260 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 260)));
auto mx261 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 1, 1}}, 261));
auto mx262 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 262)));
auto mx263 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 263));
auto mx264 = mm->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 264));
auto mx265 = mm->add_literal(migraphx::abs(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 265)));
auto mx266 = mm->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 3, 7, 7}}, 266));
migraphx::op::convolution convolution267;
convolution267.padding = {3, 3};
convolution267.stride = {2, 2};
convolution267.dilation = {1, 1};
convolution267.group = 1;
auto mx267 = mm->add_instruction(convolution267, m0, mx266);
migraphx::op::batch_norm_inference batch_norm_inference268;
batch_norm_inference268.epsilon = 1e-05;
batch_norm_inference268.momentum = 0.9;
auto mx268 = mm->add_instruction(batch_norm_inference268, mx267, mx265, mx264, mx263, mx262);
migraphx::op::relu relu269;
auto mx269 = mm->add_instruction(relu269, mx268);
migraphx::op::pooling pooling270;
pooling270.mode = migraphx::op::pooling_mode::max;
pooling270.padding = {1, 1};
pooling270.stride = {2, 2};
pooling270.lengths = {3, 3};
auto mx270 = mm->add_instruction(pooling270, mx269);
migraphx::op::convolution convolution271;
convolution271.padding = {0, 0};
convolution271.stride = {1, 1};
convolution271.dilation = {1, 1};
convolution271.group = 1;
auto mx271 = mm->add_instruction(convolution271, mx270, mx261);
migraphx::op::batch_norm_inference batch_norm_inference272;
batch_norm_inference272.epsilon = 1e-05;
batch_norm_inference272.momentum = 0.9;
auto mx272 = mm->add_instruction(batch_norm_inference272, mx271, mx260, mx259, mx258, mx257);
migraphx::op::relu relu273;
auto mx273 = mm->add_instruction(relu273, mx272);
migraphx::op::convolution convolution274;
convolution274.padding = {1, 1};
convolution274.stride = {1, 1};
convolution274.dilation = {1, 1};
convolution274.group = 1;
auto mx274 = mm->add_instruction(convolution274, mx273, mx256);
migraphx::op::batch_norm_inference batch_norm_inference275;
batch_norm_inference275.epsilon = 1e-05;
batch_norm_inference275.momentum = 0.9;
auto mx275 = mm->add_instruction(batch_norm_inference275, mx274, mx255, mx254, mx253, mx252);
migraphx::op::relu relu276;
auto mx276 = mm->add_instruction(relu276, mx275);
migraphx::op::convolution convolution277;
convolution277.padding = {0, 0};
convolution277.stride = {1, 1};
convolution277.dilation = {1, 1};
convolution277.group = 1;
auto mx277 = mm->add_instruction(convolution277, mx276, mx251);
migraphx::op::batch_norm_inference batch_norm_inference278;
batch_norm_inference278.epsilon = 1e-05;
batch_norm_inference278.momentum = 0.9;
auto mx278 = mm->add_instruction(batch_norm_inference278, mx277, mx250, mx249, mx248, mx247);
migraphx::op::convolution convolution279;
convolution279.padding = {0, 0};
convolution279.stride = {1, 1};
convolution279.dilation = {1, 1};
convolution279.group = 1;
auto mx279 = mm->add_instruction(convolution279, mx270, mx246);
migraphx::op::batch_norm_inference batch_norm_inference280;
batch_norm_inference280.epsilon = 1e-05;
batch_norm_inference280.momentum = 0.9;
auto mx280 = mm->add_instruction(batch_norm_inference280, mx279, mx245, mx244, mx243, mx242);
migraphx::op::add add281;
auto mx281 = mm->add_instruction(add281, mx278, mx280);
migraphx::op::relu relu282;
auto mx282 = mm->add_instruction(relu282, mx281);
migraphx::op::convolution convolution283;
convolution283.padding = {0, 0};
convolution283.stride = {1, 1};
convolution283.dilation = {1, 1};
convolution283.group = 1;
auto mx283 = mm->add_instruction(convolution283, mx282, mx241);
migraphx::op::batch_norm_inference batch_norm_inference284;
batch_norm_inference284.epsilon = 1e-05;
batch_norm_inference284.momentum = 0.9;
auto mx284 = mm->add_instruction(batch_norm_inference284, mx283, mx240, mx239, mx238, mx237);
migraphx::op::relu relu285;
auto mx285 = mm->add_instruction(relu285, mx284);
migraphx::op::convolution convolution286;
convolution286.padding = {1, 1};
convolution286.stride = {1, 1};
convolution286.dilation = {1, 1};
convolution286.group = 1;
auto mx286 = mm->add_instruction(convolution286, mx285, mx236);
migraphx::op::batch_norm_inference batch_norm_inference287;
batch_norm_inference287.epsilon = 1e-05;
batch_norm_inference287.momentum = 0.9;
auto mx287 = mm->add_instruction(batch_norm_inference287, mx286, mx235, mx234, mx233, mx232);
migraphx::op::relu relu288;
auto mx288 = mm->add_instruction(relu288, mx287);
migraphx::op::convolution convolution289;
convolution289.padding = {0, 0};
convolution289.stride = {1, 1};
convolution289.dilation = {1, 1};
convolution289.group = 1;
auto mx289 = mm->add_instruction(convolution289, mx288, mx231);
migraphx::op::batch_norm_inference batch_norm_inference290;
batch_norm_inference290.epsilon = 1e-05;
batch_norm_inference290.momentum = 0.9;
auto mx290 = mm->add_instruction(batch_norm_inference290, mx289, mx230, mx229, mx228, mx227);
migraphx::op::add add291;
auto mx291 = mm->add_instruction(add291, mx290, mx282);
migraphx::op::relu relu292;
auto mx292 = mm->add_instruction(relu292, mx291);
migraphx::op::convolution convolution293;
convolution293.padding = {0, 0};
convolution293.stride = {1, 1};
convolution293.dilation = {1, 1};
convolution293.group = 1;
auto mx293 = mm->add_instruction(convolution293, mx292, mx226);
migraphx::op::batch_norm_inference batch_norm_inference294;
batch_norm_inference294.epsilon = 1e-05;
batch_norm_inference294.momentum = 0.9;
auto mx294 = mm->add_instruction(batch_norm_inference294, mx293, mx225, mx224, mx223, mx222);
migraphx::op::relu relu295;
auto mx295 = mm->add_instruction(relu295, mx294);
migraphx::op::convolution convolution296;
convolution296.padding = {1, 1};
convolution296.stride = {1, 1};
convolution296.dilation = {1, 1};
convolution296.group = 1;
auto mx296 = mm->add_instruction(convolution296, mx295, mx221);
migraphx::op::batch_norm_inference batch_norm_inference297;
batch_norm_inference297.epsilon = 1e-05;
batch_norm_inference297.momentum = 0.9;
auto mx297 = mm->add_instruction(batch_norm_inference297, mx296, mx220, mx219, mx218, mx217);
migraphx::op::relu relu298;
auto mx298 = mm->add_instruction(relu298, mx297);
migraphx::op::convolution convolution299;
convolution299.padding = {0, 0};
convolution299.stride = {1, 1};
convolution299.dilation = {1, 1};
convolution299.group = 1;
auto mx299 = mm->add_instruction(convolution299, mx298, mx216);
migraphx::op::batch_norm_inference batch_norm_inference300;
batch_norm_inference300.epsilon = 1e-05;
batch_norm_inference300.momentum = 0.9;
auto mx300 = mm->add_instruction(batch_norm_inference300, mx299, mx215, mx214, mx213, mx212);
migraphx::op::add add301;
auto mx301 = mm->add_instruction(add301, mx300, mx292);
migraphx::op::relu relu302;
auto mx302 = mm->add_instruction(relu302, mx301);
migraphx::op::convolution convolution303;
convolution303.padding = {0, 0};
convolution303.stride = {1, 1};
convolution303.dilation = {1, 1};
convolution303.group = 1;
auto mx303 = mm->add_instruction(convolution303, mx302, mx211);
migraphx::op::batch_norm_inference batch_norm_inference304;
batch_norm_inference304.epsilon = 1e-05;
batch_norm_inference304.momentum = 0.9;
auto mx304 = mm->add_instruction(batch_norm_inference304, mx303, mx210, mx209, mx208, mx207);
migraphx::op::relu relu305;
auto mx305 = mm->add_instruction(relu305, mx304);
migraphx::op::convolution convolution306;
convolution306.padding = {1, 1};
convolution306.stride = {2, 2};
convolution306.dilation = {1, 1};
convolution306.group = 1;
auto mx306 = mm->add_instruction(convolution306, mx305, mx206);
migraphx::op::batch_norm_inference batch_norm_inference307;
batch_norm_inference307.epsilon = 1e-05;
batch_norm_inference307.momentum = 0.9;
auto mx307 = mm->add_instruction(batch_norm_inference307, mx306, mx205, mx204, mx203, mx202);
migraphx::op::relu relu308;
auto mx308 = mm->add_instruction(relu308, mx307);
migraphx::op::convolution convolution309;
convolution309.padding = {0, 0};
convolution309.stride = {1, 1};
convolution309.dilation = {1, 1};
convolution309.group = 1;
auto mx309 = mm->add_instruction(convolution309, mx308, mx201);
migraphx::op::batch_norm_inference batch_norm_inference310;
batch_norm_inference310.epsilon = 1e-05;
batch_norm_inference310.momentum = 0.9;
auto mx310 = mm->add_instruction(batch_norm_inference310, mx309, mx200, mx199, mx198, mx197);
migraphx::op::convolution convolution311;
convolution311.padding = {0, 0};
convolution311.stride = {2, 2};
convolution311.dilation = {1, 1};
convolution311.group = 1;
auto mx311 = mm->add_instruction(convolution311, mx302, mx196);
migraphx::op::batch_norm_inference batch_norm_inference312;
batch_norm_inference312.epsilon = 1e-05;
batch_norm_inference312.momentum = 0.9;
auto mx312 = mm->add_instruction(batch_norm_inference312, mx311, mx195, mx194, mx193, mx192);
migraphx::op::add add313;
auto mx313 = mm->add_instruction(add313, mx310, mx312);
migraphx::op::relu relu314;
auto mx314 = mm->add_instruction(relu314, mx313);
migraphx::op::convolution convolution315;
convolution315.padding = {0, 0};
convolution315.stride = {1, 1};
convolution315.dilation = {1, 1};
convolution315.group = 1;
auto mx315 = mm->add_instruction(convolution315, mx314, mx191);
migraphx::op::batch_norm_inference batch_norm_inference316;
batch_norm_inference316.epsilon = 1e-05;
batch_norm_inference316.momentum = 0.9;
auto mx316 = mm->add_instruction(batch_norm_inference316, mx315, mx190, mx189, mx188, mx187);
migraphx::op::relu relu317;
auto mx317 = mm->add_instruction(relu317, mx316);
migraphx::op::convolution convolution318;
convolution318.padding = {1, 1};
convolution318.stride = {1, 1};
convolution318.dilation = {1, 1};
convolution318.group = 1;
auto mx318 = mm->add_instruction(convolution318, mx317, mx186);
migraphx::op::batch_norm_inference batch_norm_inference319;
batch_norm_inference319.epsilon = 1e-05;
batch_norm_inference319.momentum = 0.9;
auto mx319 = mm->add_instruction(batch_norm_inference319, mx318, mx185, mx184, mx183, mx182);
migraphx::op::relu relu320;
auto mx320 = mm->add_instruction(relu320, mx319);
migraphx::op::convolution convolution321;
convolution321.padding = {0, 0};
convolution321.stride = {1, 1};
convolution321.dilation = {1, 1};
convolution321.group = 1;
auto mx321 = mm->add_instruction(convolution321, mx320, mx181);
migraphx::op::batch_norm_inference batch_norm_inference322;
batch_norm_inference322.epsilon = 1e-05;
batch_norm_inference322.momentum = 0.9;
auto mx322 = mm->add_instruction(batch_norm_inference322, mx321, mx180, mx179, mx178, mx177);
migraphx::op::add add323;
auto mx323 = mm->add_instruction(add323, mx322, mx314);
migraphx::op::relu relu324;
auto mx324 = mm->add_instruction(relu324, mx323);
migraphx::op::convolution convolution325;
convolution325.padding = {0, 0};
convolution325.stride = {1, 1};
convolution325.dilation = {1, 1};
convolution325.group = 1;
auto mx325 = mm->add_instruction(convolution325, mx324, mx176);
migraphx::op::batch_norm_inference batch_norm_inference326;
batch_norm_inference326.epsilon = 1e-05;
batch_norm_inference326.momentum = 0.9;
auto mx326 = mm->add_instruction(batch_norm_inference326, mx325, mx175, mx174, mx173, mx172);
migraphx::op::relu relu327;
auto mx327 = mm->add_instruction(relu327, mx326);
migraphx::op::convolution convolution328;
convolution328.padding = {1, 1};
convolution328.stride = {1, 1};
convolution328.dilation = {1, 1};
convolution328.group = 1;
auto mx328 = mm->add_instruction(convolution328, mx327, mx171);
migraphx::op::batch_norm_inference batch_norm_inference329;
batch_norm_inference329.epsilon = 1e-05;
batch_norm_inference329.momentum = 0.9;
auto mx329 = mm->add_instruction(batch_norm_inference329, mx328, mx170, mx169, mx168, mx167);
migraphx::op::relu relu330;
auto mx330 = mm->add_instruction(relu330, mx329);
migraphx::op::convolution convolution331;
convolution331.padding = {0, 0};
convolution331.stride = {1, 1};
convolution331.dilation = {1, 1};
convolution331.group = 1;
auto mx331 = mm->add_instruction(convolution331, mx330, mx166);
migraphx::op::batch_norm_inference batch_norm_inference332;
batch_norm_inference332.epsilon = 1e-05;
batch_norm_inference332.momentum = 0.9;
auto mx332 = mm->add_instruction(batch_norm_inference332, mx331, mx165, mx164, mx163, mx162);
migraphx::op::add add333;
auto mx333 = mm->add_instruction(add333, mx332, mx324);
migraphx::op::relu relu334;
auto mx334 = mm->add_instruction(relu334, mx333);
migraphx::op::convolution convolution335;
convolution335.padding = {0, 0};
convolution335.stride = {1, 1};
convolution335.dilation = {1, 1};
convolution335.group = 1;
auto mx335 = mm->add_instruction(convolution335, mx334, mx161);
migraphx::op::batch_norm_inference batch_norm_inference336;
batch_norm_inference336.epsilon = 1e-05;
batch_norm_inference336.momentum = 0.9;
auto mx336 = mm->add_instruction(batch_norm_inference336, mx335, mx160, mx159, mx158, mx157);
migraphx::op::relu relu337;
auto mx337 = mm->add_instruction(relu337, mx336);
migraphx::op::convolution convolution338;
convolution338.padding = {1, 1};
convolution338.stride = {1, 1};
convolution338.dilation = {1, 1};
convolution338.group = 1;
auto mx338 = mm->add_instruction(convolution338, mx337, mx156);
migraphx::op::batch_norm_inference batch_norm_inference339;
batch_norm_inference339.epsilon = 1e-05;
batch_norm_inference339.momentum = 0.9;
auto mx339 = mm->add_instruction(batch_norm_inference339, mx338, mx155, mx154, mx153, mx152);
migraphx::op::relu relu340;
auto mx340 = mm->add_instruction(relu340, mx339);
migraphx::op::convolution convolution341;
convolution341.padding = {0, 0};
convolution341.stride = {1, 1};
convolution341.dilation = {1, 1};
convolution341.group = 1;
auto mx341 = mm->add_instruction(convolution341, mx340, mx151);
migraphx::op::batch_norm_inference batch_norm_inference342;
batch_norm_inference342.epsilon = 1e-05;
batch_norm_inference342.momentum = 0.9;
auto mx342 = mm->add_instruction(batch_norm_inference342, mx341, mx150, mx149, mx148, mx147);
migraphx::op::add add343;
auto mx343 = mm->add_instruction(add343, mx342, mx334);
migraphx::op::relu relu344;
auto mx344 = mm->add_instruction(relu344, mx343);
migraphx::op::convolution convolution345;
convolution345.padding = {0, 0};
convolution345.stride = {1, 1};
convolution345.dilation = {1, 1};
convolution345.group = 1;
auto mx345 = mm->add_instruction(convolution345, mx344, mx146);
migraphx::op::batch_norm_inference batch_norm_inference346;
batch_norm_inference346.epsilon = 1e-05;
batch_norm_inference346.momentum = 0.9;
auto mx346 = mm->add_instruction(batch_norm_inference346, mx345, mx145, mx144, mx143, mx142);
migraphx::op::relu relu347;
auto mx347 = mm->add_instruction(relu347, mx346);
migraphx::op::convolution convolution348;
convolution348.padding = {1, 1};
convolution348.stride = {2, 2};
convolution348.dilation = {1, 1};
convolution348.group = 1;
auto mx348 = mm->add_instruction(convolution348, mx347, mx141);
migraphx::op::batch_norm_inference batch_norm_inference349;
batch_norm_inference349.epsilon = 1e-05;
batch_norm_inference349.momentum = 0.9;
auto mx349 = mm->add_instruction(batch_norm_inference349, mx348, mx140, mx139, mx138, mx137);
migraphx::op::relu relu350;
auto mx350 = mm->add_instruction(relu350, mx349);
migraphx::op::convolution convolution351;
convolution351.padding = {0, 0};
convolution351.stride = {1, 1};
convolution351.dilation = {1, 1};
convolution351.group = 1;
auto mx351 = mm->add_instruction(convolution351, mx350, mx136);
migraphx::op::batch_norm_inference batch_norm_inference352;
batch_norm_inference352.epsilon = 1e-05;
batch_norm_inference352.momentum = 0.9;
auto mx352 = mm->add_instruction(batch_norm_inference352, mx351, mx135, mx134, mx133, mx132);
migraphx::op::convolution convolution353;
convolution353.padding = {0, 0};
convolution353.stride = {2, 2};
convolution353.dilation = {1, 1};
convolution353.group = 1;
auto mx353 = mm->add_instruction(convolution353, mx344, mx131);
migraphx::op::batch_norm_inference batch_norm_inference354;
batch_norm_inference354.epsilon = 1e-05;
batch_norm_inference354.momentum = 0.9;
auto mx354 = mm->add_instruction(batch_norm_inference354, mx353, mx130, mx129, mx128, mx127);
migraphx::op::add add355;
auto mx355 = mm->add_instruction(add355, mx352, mx354);
migraphx::op::relu relu356;
auto mx356 = mm->add_instruction(relu356, mx355);
migraphx::op::convolution convolution357;
convolution357.padding = {0, 0};
convolution357.stride = {1, 1};
convolution357.dilation = {1, 1};
convolution357.group = 1;
auto mx357 = mm->add_instruction(convolution357, mx356, mx126);
migraphx::op::batch_norm_inference batch_norm_inference358;
batch_norm_inference358.epsilon = 1e-05;
batch_norm_inference358.momentum = 0.9;
auto mx358 = mm->add_instruction(batch_norm_inference358, mx357, mx125, mx124, mx123, mx122);
migraphx::op::relu relu359;
auto mx359 = mm->add_instruction(relu359, mx358);
migraphx::op::convolution convolution360;
convolution360.padding = {1, 1};
convolution360.stride = {1, 1};
convolution360.dilation = {1, 1};
convolution360.group = 1;
auto mx360 = mm->add_instruction(convolution360, mx359, mx121);
migraphx::op::batch_norm_inference batch_norm_inference361;
batch_norm_inference361.epsilon = 1e-05;
batch_norm_inference361.momentum = 0.9;
auto mx361 = mm->add_instruction(batch_norm_inference361, mx360, mx120, mx119, mx118, mx117);
migraphx::op::relu relu362;
auto mx362 = mm->add_instruction(relu362, mx361);
migraphx::op::convolution convolution363;
convolution363.padding = {0, 0};
convolution363.stride = {1, 1};
convolution363.dilation = {1, 1};
convolution363.group = 1;
auto mx363 = mm->add_instruction(convolution363, mx362, mx116);
migraphx::op::batch_norm_inference batch_norm_inference364;
batch_norm_inference364.epsilon = 1e-05;
batch_norm_inference364.momentum = 0.9;
auto mx364 = mm->add_instruction(batch_norm_inference364, mx363, mx115, mx114, mx113, mx112);
migraphx::op::add add365;
auto mx365 = mm->add_instruction(add365, mx364, mx356);
migraphx::op::relu relu366;
auto mx366 = mm->add_instruction(relu366, mx365);
migraphx::op::convolution convolution367;
convolution367.padding = {0, 0};
convolution367.stride = {1, 1};
convolution367.dilation = {1, 1};
convolution367.group = 1;
auto mx367 = mm->add_instruction(convolution367, mx366, mx111);
migraphx::op::batch_norm_inference batch_norm_inference368;
batch_norm_inference368.epsilon = 1e-05;
batch_norm_inference368.momentum = 0.9;
auto mx368 = mm->add_instruction(batch_norm_inference368, mx367, mx110, mx109, mx108, mx107);
migraphx::op::relu relu369;
auto mx369 = mm->add_instruction(relu369, mx368);
migraphx::op::convolution convolution370;
convolution370.padding = {1, 1};
convolution370.stride = {1, 1};
convolution370.dilation = {1, 1};
convolution370.group = 1;
auto mx370 = mm->add_instruction(convolution370, mx369, mx106);
migraphx::op::batch_norm_inference batch_norm_inference371;
batch_norm_inference371.epsilon = 1e-05;
batch_norm_inference371.momentum = 0.9;
auto mx371 = mm->add_instruction(batch_norm_inference371, mx370, mx105, mx104, mx103, mx102);
migraphx::op::relu relu372;
auto mx372 = mm->add_instruction(relu372, mx371);
migraphx::op::convolution convolution373;
convolution373.padding = {0, 0};
convolution373.stride = {1, 1};
convolution373.dilation = {1, 1};
convolution373.group = 1;
auto mx373 = mm->add_instruction(convolution373, mx372, mx101);
migraphx::op::batch_norm_inference batch_norm_inference374;
batch_norm_inference374.epsilon = 1e-05;
batch_norm_inference374.momentum = 0.9;
auto mx374 = mm->add_instruction(batch_norm_inference374, mx373, mx100, mx99, mx98, mx97);
migraphx::op::add add375;
auto mx375 = mm->add_instruction(add375, mx374, mx366);
migraphx::op::relu relu376;
auto mx376 = mm->add_instruction(relu376, mx375);
migraphx::op::convolution convolution377;
convolution377.padding = {0, 0};
convolution377.stride = {1, 1};
convolution377.dilation = {1, 1};
convolution377.group = 1;
auto mx377 = mm->add_instruction(convolution377, mx376, mx96);
migraphx::op::batch_norm_inference batch_norm_inference378;
batch_norm_inference378.epsilon = 1e-05;
batch_norm_inference378.momentum = 0.9;
auto mx378 = mm->add_instruction(batch_norm_inference378, mx377, mx95, mx94, mx93, mx92);
migraphx::op::relu relu379;
auto mx379 = mm->add_instruction(relu379, mx378);
migraphx::op::convolution convolution380;
convolution380.padding = {1, 1};
convolution380.stride = {1, 1};
convolution380.dilation = {1, 1};
convolution380.group = 1;
auto mx380 = mm->add_instruction(convolution380, mx379, mx91);
migraphx::op::batch_norm_inference batch_norm_inference381;
batch_norm_inference381.epsilon = 1e-05;
batch_norm_inference381.momentum = 0.9;
auto mx381 = mm->add_instruction(batch_norm_inference381, mx380, mx90, mx89, mx88, mx87);
migraphx::op::relu relu382;
auto mx382 = mm->add_instruction(relu382, mx381);
migraphx::op::convolution convolution383;
convolution383.padding = {0, 0};
convolution383.stride = {1, 1};
convolution383.dilation = {1, 1};
convolution383.group = 1;
auto mx383 = mm->add_instruction(convolution383, mx382, mx86);
migraphx::op::batch_norm_inference batch_norm_inference384;
batch_norm_inference384.epsilon = 1e-05;
batch_norm_inference384.momentum = 0.9;
auto mx384 = mm->add_instruction(batch_norm_inference384, mx383, mx85, mx84, mx83, mx82);
migraphx::op::add add385;
auto mx385 = mm->add_instruction(add385, mx384, mx376);
migraphx::op::relu relu386;
auto mx386 = mm->add_instruction(relu386, mx385);
migraphx::op::convolution convolution387;
convolution387.padding = {0, 0};
convolution387.stride = {1, 1};
convolution387.dilation = {1, 1};
convolution387.group = 1;
auto mx387 = mm->add_instruction(convolution387, mx386, mx81);
migraphx::op::batch_norm_inference batch_norm_inference388;
batch_norm_inference388.epsilon = 1e-05;
batch_norm_inference388.momentum = 0.9;
auto mx388 = mm->add_instruction(batch_norm_inference388, mx387, mx80, mx79, mx78, mx77);
migraphx::op::relu relu389;
auto mx389 = mm->add_instruction(relu389, mx388);
migraphx::op::convolution convolution390;
convolution390.padding = {1, 1};
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);
auto x_main_module_95 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 94));
auto x_main_module_96 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 95));
auto x_main_module_97 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 96));
auto x_main_module_98 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 97));
auto x_main_module_99 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 98));
auto x_main_module_100 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 99));
auto x_main_module_101 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 100));
auto x_main_module_102 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 101));
auto x_main_module_103 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 102));
auto x_main_module_104 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 103));
auto x_main_module_105 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 104));
auto x_main_module_106 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 105));
auto x_main_module_107 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 64, 1, 1}}, 106));
auto x_main_module_108 = mmain->add_literal(
migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 107));
auto x_main_module_109 = mmain->add_literal(migraphx::generate_literal(
migraphx::shape{migraphx::shape::float_type, {64, 3, 7, 7}}, 108));
auto x_main_module_110 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[3,3,3,3],padding_mode:0,stride:[2,2]}")),
x_input_1,
x_main_module_109);
auto x_main_module_111 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,112,112]}")),
x_main_module_108);
auto x_main_module_112 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_110, x_main_module_111);
auto x_main_module_113 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_112);
auto x_main_module_114 = mmain->add_instruction(
migraphx::make_op(
"pooling",
migraphx::from_json_string(
"{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[1,1,1,1],stride:[2,2]}")),
x_main_module_113);
auto x_main_module_115 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_114,
x_main_module_107);
auto x_main_module_116 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
x_main_module_106);
auto x_main_module_117 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_115, x_main_module_116);
auto x_main_module_118 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_117);
auto x_main_module_119 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_118,
x_main_module_105);
auto x_main_module_120 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
x_main_module_104);
auto x_main_module_121 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_119, x_main_module_120);
auto x_main_module_122 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_121);
auto x_main_module_123 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_122,
x_main_module_103);
auto x_main_module_124 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
x_main_module_102);
auto x_main_module_125 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_123, x_main_module_124);
auto x_main_module_126 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_114,
x_main_module_101);
auto x_main_module_127 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
x_main_module_100);
auto x_main_module_128 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_126, x_main_module_127);
auto x_main_module_129 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_125, x_main_module_128);
auto x_main_module_130 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_129);
auto x_main_module_131 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_130,
x_main_module_99);
auto x_main_module_132 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
x_main_module_98);
auto x_main_module_133 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_131, x_main_module_132);
auto x_main_module_134 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_133);
auto x_main_module_135 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_134,
x_main_module_97);
auto x_main_module_136 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
x_main_module_96);
auto x_main_module_137 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_135, x_main_module_136);
auto x_main_module_138 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_137);
auto x_main_module_139 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_138,
x_main_module_95);
auto x_main_module_140 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
x_main_module_94);
auto x_main_module_141 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_139, x_main_module_140);
auto x_main_module_142 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_141, x_main_module_130);
auto x_main_module_143 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_142);
auto x_main_module_144 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_143,
x_main_module_93);
auto x_main_module_145 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
x_main_module_92);
auto x_main_module_146 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_144, x_main_module_145);
auto x_main_module_147 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_146);
auto x_main_module_148 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_147,
x_main_module_91);
auto x_main_module_149 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
x_main_module_90);
auto x_main_module_150 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_148, x_main_module_149);
auto x_main_module_151 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_150);
auto x_main_module_152 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_151,
x_main_module_89);
auto x_main_module_153 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
x_main_module_88);
auto x_main_module_154 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_152, x_main_module_153);
auto x_main_module_155 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_154, x_main_module_143);
auto x_main_module_156 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_155);
auto x_main_module_157 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_156,
x_main_module_87);
auto x_main_module_158 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,56,56]}")),
x_main_module_86);
auto x_main_module_159 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_157, x_main_module_158);
auto x_main_module_160 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_159);
auto x_main_module_161 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
x_main_module_160,
x_main_module_85);
auto x_main_module_162 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
x_main_module_84);
auto x_main_module_163 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_161, x_main_module_162);
auto x_main_module_164 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_163);
auto x_main_module_165 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_164,
x_main_module_83);
auto x_main_module_166 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
x_main_module_82);
auto x_main_module_167 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_165, x_main_module_166);
auto x_main_module_168 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
x_main_module_156,
x_main_module_81);
auto x_main_module_169 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
x_main_module_80);
auto x_main_module_170 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_168, x_main_module_169);
auto x_main_module_171 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_167, x_main_module_170);
auto x_main_module_172 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_171);
auto x_main_module_173 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_172,
x_main_module_79);
auto x_main_module_174 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
x_main_module_78);
auto x_main_module_175 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_173, x_main_module_174);
auto x_main_module_176 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_175);
auto x_main_module_177 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_176,
x_main_module_77);
auto x_main_module_178 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
x_main_module_76);
auto x_main_module_179 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_177, x_main_module_178);
auto x_main_module_180 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_179);
auto x_main_module_181 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_180,
x_main_module_75);
auto x_main_module_182 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
x_main_module_74);
auto x_main_module_183 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_181, x_main_module_182);
auto x_main_module_184 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_183, x_main_module_172);
auto x_main_module_185 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_184);
auto x_main_module_186 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_185,
x_main_module_73);
auto x_main_module_187 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
x_main_module_72);
auto x_main_module_188 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_186, x_main_module_187);
auto x_main_module_189 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_188);
auto x_main_module_190 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_189,
x_main_module_71);
auto x_main_module_191 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
x_main_module_70);
auto x_main_module_192 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_190, x_main_module_191);
auto x_main_module_193 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_192);
auto x_main_module_194 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_193,
x_main_module_69);
auto x_main_module_195 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
x_main_module_68);
auto x_main_module_196 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_194, x_main_module_195);
auto x_main_module_197 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_196, x_main_module_185);
auto x_main_module_198 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_197);
auto x_main_module_199 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_198,
x_main_module_67);
auto x_main_module_200 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
x_main_module_66);
auto x_main_module_201 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_199, x_main_module_200);
auto x_main_module_202 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_201);
auto x_main_module_203 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_202,
x_main_module_65);
auto x_main_module_204 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
x_main_module_64);
auto x_main_module_205 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_203, x_main_module_204);
auto x_main_module_206 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_205);
auto x_main_module_207 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_206,
x_main_module_63);
auto x_main_module_208 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
x_main_module_62);
auto x_main_module_209 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_207, x_main_module_208);
auto x_main_module_210 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_209, x_main_module_198);
auto x_main_module_211 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_210);
auto x_main_module_212 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_211,
x_main_module_61);
auto x_main_module_213 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,28,28]}")),
x_main_module_60);
auto x_main_module_214 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_212, x_main_module_213);
auto x_main_module_215 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_214);
auto x_main_module_216 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
x_main_module_215,
x_main_module_59);
auto x_main_module_217 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_58);
auto x_main_module_218 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_216, x_main_module_217);
auto x_main_module_219 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_218);
auto x_main_module_220 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_219,
x_main_module_57);
auto x_main_module_221 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
x_main_module_56);
auto x_main_module_222 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_220, x_main_module_221);
auto x_main_module_223 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
x_main_module_211,
x_main_module_55);
auto x_main_module_224 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
x_main_module_54);
auto x_main_module_225 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_223, x_main_module_224);
auto x_main_module_226 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_222, x_main_module_225);
auto x_main_module_227 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_226);
auto x_main_module_228 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_227,
x_main_module_53);
auto x_main_module_229 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_52);
auto x_main_module_230 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_228, x_main_module_229);
auto x_main_module_231 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_230);
auto x_main_module_232 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_231,
x_main_module_51);
auto x_main_module_233 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_50);
auto x_main_module_234 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_232, x_main_module_233);
auto x_main_module_235 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_234);
auto x_main_module_236 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_235,
x_main_module_49);
auto x_main_module_237 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
x_main_module_48);
auto x_main_module_238 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_236, x_main_module_237);
auto x_main_module_239 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_238, x_main_module_227);
auto x_main_module_240 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_239);
auto x_main_module_241 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_240,
x_main_module_47);
auto x_main_module_242 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_46);
auto x_main_module_243 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_241, x_main_module_242);
auto x_main_module_244 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_243);
auto x_main_module_245 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_244,
x_main_module_45);
auto x_main_module_246 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_44);
auto x_main_module_247 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_245, x_main_module_246);
auto x_main_module_248 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_247);
auto x_main_module_249 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_248,
x_main_module_43);
auto x_main_module_250 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
x_main_module_42);
auto x_main_module_251 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_249, x_main_module_250);
auto x_main_module_252 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_251, x_main_module_240);
auto x_main_module_253 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_252);
auto x_main_module_254 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_253,
x_main_module_41);
auto x_main_module_255 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_40);
auto x_main_module_256 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_254, x_main_module_255);
auto x_main_module_257 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_256);
auto x_main_module_258 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_257,
x_main_module_39);
auto x_main_module_259 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_38);
auto x_main_module_260 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_258, x_main_module_259);
auto x_main_module_261 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_260);
auto x_main_module_262 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_261,
x_main_module_37);
auto x_main_module_263 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
x_main_module_36);
auto x_main_module_264 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_262, x_main_module_263);
auto x_main_module_265 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_264, x_main_module_253);
auto x_main_module_266 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_265);
auto x_main_module_267 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_266,
x_main_module_35);
auto x_main_module_268 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_34);
auto x_main_module_269 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_267, x_main_module_268);
auto x_main_module_270 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_269);
auto x_main_module_271 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_270,
x_main_module_33);
auto x_main_module_272 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_32);
auto x_main_module_273 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_271, x_main_module_272);
auto x_main_module_274 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_273);
auto x_main_module_275 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_274,
x_main_module_31);
auto x_main_module_276 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
x_main_module_30);
auto x_main_module_277 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_275, x_main_module_276);
auto x_main_module_278 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_277, x_main_module_266);
auto x_main_module_279 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_278);
auto x_main_module_280 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_279,
x_main_module_29);
auto x_main_module_281 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_28);
auto x_main_module_282 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_280, x_main_module_281);
auto x_main_module_283 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_282);
auto x_main_module_284 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_283,
x_main_module_27);
auto x_main_module_285 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
x_main_module_26);
auto x_main_module_286 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_284, x_main_module_285);
auto x_main_module_287 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_286);
auto x_main_module_288 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_287,
x_main_module_25);
auto x_main_module_289 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
x_main_module_24);
auto x_main_module_290 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_288, x_main_module_289);
auto x_main_module_291 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_290, x_main_module_279);
auto x_main_module_292 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_291);
auto x_main_module_293 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_292,
x_main_module_23);
auto x_main_module_294 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,512,14,14]}")),
x_main_module_22);
auto x_main_module_295 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_293, x_main_module_294);
auto x_main_module_296 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_295);
auto x_main_module_297 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
x_main_module_296,
x_main_module_21);
auto x_main_module_298 = mmain->add_instruction(
migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
x_main_module_20);
auto x_main_module_299 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_297, x_main_module_298);
auto x_main_module_300 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_299);
auto x_main_module_301 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_300,
x_main_module_19);
auto x_main_module_302 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
x_main_module_18);
auto x_main_module_303 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_301, x_main_module_302);
auto x_main_module_304 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
x_main_module_292,
x_main_module_17);
auto x_main_module_305 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
x_main_module_16);
auto x_main_module_306 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_304, x_main_module_305);
auto x_main_module_307 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_303, x_main_module_306);
auto x_main_module_308 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_307);
auto x_main_module_309 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_308,
x_main_module_15);
auto x_main_module_310 = mmain->add_instruction(
migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
x_main_module_14);
auto x_main_module_311 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_309, x_main_module_310);
auto x_main_module_312 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_311);
auto x_main_module_313 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_312,
x_main_module_13);
auto x_main_module_314 = mmain->add_instruction(
migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
x_main_module_12);
auto x_main_module_315 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_313, x_main_module_314);
auto x_main_module_316 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_315);
auto x_main_module_317 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_316,
x_main_module_11);
auto x_main_module_318 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
x_main_module_10);
auto x_main_module_319 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_317, x_main_module_318);
auto x_main_module_320 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_319, x_main_module_308);
auto x_main_module_321 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_320);
auto x_main_module_322 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_321,
x_main_module_9);
auto x_main_module_323 = mmain->add_instruction(
migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
x_main_module_8);
auto x_main_module_324 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_322, x_main_module_323);
auto x_main_module_325 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_324);
auto x_main_module_326 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
x_main_module_325,
x_main_module_7);
auto x_main_module_327 = mmain->add_instruction(
migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
x_main_module_6);
auto x_main_module_328 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_326, x_main_module_327);
auto x_main_module_329 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_328);
auto x_main_module_330 = mmain->add_instruction(
migraphx::make_op(
"convolution",
migraphx::from_json_string(
"{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
x_main_module_329,
x_main_module_5);
auto x_main_module_331 = mmain->add_instruction(
migraphx::make_op("broadcast",
migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
x_main_module_4);
auto x_main_module_332 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_330, x_main_module_331);
auto x_main_module_333 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_332, x_main_module_321);
auto x_main_module_334 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_333);
auto x_main_module_335 = mmain->add_instruction(
migraphx::make_op(
"pooling",
migraphx::from_json_string(
"{ceil_mode:0,lengths:[7,7],lp_order:2,mode:0,padding:[0,0,0,0],stride:[1,1]}")),
x_main_module_334);
auto x_main_module_336 = mmain->add_instruction(
migraphx::make_op("reshape", migraphx::from_json_string("{dims:[1,-1]}")),
x_main_module_335);
auto x_main_module_337 = mmain->add_instruction(
migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
x_main_module_2);
auto x_main_module_338 =
mmain->add_instruction(migraphx::make_op("dot"), x_main_module_336, x_main_module_337);
auto x_main_module_339 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
x_main_module_3);
auto x_main_module_340 = mmain->add_instruction(
migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
x_main_module_0);
auto x_main_module_341 =
mmain->add_instruction(migraphx::make_op("mul"), x_main_module_339, x_main_module_340);
auto x_main_module_342 =
mmain->add_instruction(migraphx::make_op("add"), x_main_module_338, x_main_module_341);
mmain->add_return({x_main_module_342});
return p;
}
} // namespace MIGRAPHX_INLINE_NS
} // namespace driver
} // namespace migraphx
src/fuse_pointwise.cpp
View file @ eb4dfb49
......@@ -142,7 +142,7 @@ static std::vector<instruction_ref> append_pointwise_module(instruction_ref ins,
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;
}
......
src/include/migraphx/module.hpp
View file @ eb4dfb49
......@@ -120,10 +120,34 @@ struct module
instruction_ref move_instructions(instruction_ref src, instruction_ref dst);
std::vector<instruction_ref>
insert_module_instructions(instruction_ref ins,
add_instructions(const std::vector<instruction_ref>& instructions,
std::unordered_map<instruction_ref, instruction_ref> map_ins = {});
std::vector<instruction_ref>
add_instructions(module_ref m,
std::unordered_map<instruction_ref, instruction_ref> map_ins = {});
std::vector<instruction_ref>
add_instructions(instruction_ref start,
instruction_ref last,
std::unordered_map<instruction_ref, instruction_ref> map_ins = {});
std::vector<instruction_ref>
insert_instructions(instruction_ref ins,
const std::vector<instruction_ref>& instructions,
std::unordered_map<instruction_ref, instruction_ref> map_ins = {});
std::vector<instruction_ref>
insert_instructions(instruction_ref ins,
module_ref m,
std::unordered_map<instruction_ref, instruction_ref> map_ins = {});
std::vector<instruction_ref>
insert_instructions(instruction_ref ins,
instruction_ref start,
instruction_ref last,
std::unordered_map<instruction_ref, instruction_ref> map_ins = {});
template <class... Ts>
instruction_ref add_literal(Ts&&... xs)
{
......@@ -179,7 +203,9 @@ struct module
void print_cpp(std::ostream& os) const;
std::unordered_map<instruction_ref, std::string>
print_cpp(std::ostream& os, std::unordered_map<instruction_ref, std::string> names) const;
print_cpp(std::ostream& os,
const std::string& mname,
std::unordered_map<instruction_ref, std::string> names) const;
void annotate(std::ostream& os, std::function<void(instruction_ref)> a) const;
......
src/include/migraphx/op/nonmaxsuppression.hpp
View file @ eb4dfb49
......@@ -196,16 +196,34 @@ struct nonmaxsuppression
return boxes_heap;
}
template <class H, class S>
void select_boxes(H& boxes_heap,
std::vector<std::pair<double, int64_t>>& selected_boxes_inside_class,
std::vector<int64_t>& selected_indices,
S batch_boxes_start,
template <class Output, class Boxes, class Scores>
std::size_t compute_nms(Output output,
Boxes boxes,
Scores scores,
const shape& max_output_shape,
std::size_t max_output_boxes_per_class,
double iou_threshold,
std::size_t batch_idx,
std::size_t class_idx) const
double score_threshold) const
{
std::fill(output.begin(), output.end(), 0);
const auto& lens = scores.get_shape().lens();
const auto num_batches = lens[0];
const auto num_classes = lens[1];
const auto num_boxes = lens[2];
// boxes of a class with NMS applied [score, index]
std::vector<std::pair<double, int64_t>> selected_boxes_inside_class;
std::vector<int64_t> selected_indices;
selected_boxes_inside_class.reserve(max_output_shape.elements());
// iterate over batches and classes
shape comp_s{shape::double_type, {num_batches, num_classes}};
shape_for_each(comp_s, [&](auto idx) {
auto batch_idx = idx[0];
auto class_idx = idx[1];
// index offset for this class
auto scores_start = scores.begin() + (batch_idx * num_classes + class_idx) * num_boxes;
// iterator to first value of this batch
auto batch_boxes_start = boxes.begin() + batch_idx * num_boxes * 4;
auto boxes_heap = filter_boxes_by_score(scores_start, num_boxes, score_threshold);
selected_boxes_inside_class.clear();
// Get the next box with top score, filter by iou_threshold
while(!boxes_heap.empty() &&
......@@ -233,6 +251,9 @@ struct nonmaxsuppression
}
boxes_heap.pop();
}
});
std::copy(selected_indices.begin(), selected_indices.end(), output.begin());
return selected_indices.size() / 3;
}
argument compute(const shape& output_shape, std::vector<argument> args) const
......@@ -253,40 +274,15 @@ struct nonmaxsuppression
result.visit([&](auto output) {
visit_all(args[0], args[1])([&](auto boxes, auto scores) {
const auto& lens = scores.get_shape().lens();
const auto num_batches = lens[0];
const auto num_classes = lens[1];
const auto num_boxes = lens[2];
// boxes of a class with NMS applied [score, index]
std::vector<std::pair<double, int64_t>> selected_boxes_inside_class;
std::vector<int64_t> selected_indices;
selected_boxes_inside_class.reserve(max_output_shape.elements());
// iterate over batches and classes
shape comp_s{shape::double_type, {num_batches, num_classes}};
shape_for_each(comp_s, [&](auto idx) {
auto batch_idx = idx[0];
auto class_idx = idx[1];
// index offset for this class
auto scores_start =
scores.begin() + (batch_idx * num_classes + class_idx) * num_boxes;
// iterator to first value of this batch
auto batch_boxes_start = boxes.begin() + batch_idx * num_boxes * 4;
auto boxes_heap =
filter_boxes_by_score(scores_start, num_boxes, score_threshold);
select_boxes(boxes_heap,
selected_boxes_inside_class,
selected_indices,
batch_boxes_start,
num_selected = compute_nms(output,
boxes,
scores,
max_output_shape,
max_output_boxes_per_class,
iou_threshold,
batch_idx,
class_idx);
});
std::copy(selected_indices.begin(), selected_indices.end(), output.begin());
num_selected = selected_indices.size() / 3;
score_threshold);
});
});
return result.reshape({output_shape.type(), {num_selected, 3}});
}
};
......
src/include/migraphx/stringutils.hpp
View file @ eb4dfb49
......@@ -44,8 +44,8 @@ auto with_char(F f)
return [=](unsigned char c) -> bool { return f(c); };
}
inline std::string
replace_string(std::string subject, const std::string& search, const std::string& replace)
inline void
replace_string_inplace(std::string& subject, const std::string& search, const std::string& replace)
{
size_t pos = 0;
while((pos = subject.find(search, pos)) != std::string::npos)
......@@ -53,6 +53,12 @@ replace_string(std::string subject, const std::string& search, const std::string
subject.replace(pos, search.length(), replace);
pos += replace.length();
}
}
inline std::string
replace_string(std::string subject, const std::string& search, const std::string& replace)
{
replace_string_inplace(subject, search, replace);
return subject;
}
......
src/inline_module.cpp
View file @ eb4dfb49
......@@ -35,7 +35,7 @@ static void inline_submodule(module& m, instruction_ref ins, bool cond)
{
const auto& mod_inputs = ins->module_inputs();
module_ref smod = cond ? mod_inputs.at(0) : mod_inputs.at(1);
auto mod_outputs = m.insert_module_instructions(ins, smod);
auto mod_outputs = m.insert_instructions(ins, smod);
auto ins_outputs = ins->outputs();
assert(mod_outputs.size() >= ins_outputs.size());
......
src/module.cpp
View file @ eb4dfb49
......@@ -35,6 +35,7 @@
#include <migraphx/make_op.hpp>
#include <migraphx/register_target.hpp>
#include <migraphx/make_op.hpp>
#include <migraphx/json.hpp>
#include <iostream>
#include <sstream>
#include <algorithm>
......@@ -196,6 +197,62 @@ void module::assign(const module& m)
}
}
template <class Range>
static std::vector<instruction_ref>
insert_generic_instructions(module& m,
instruction_ref ins,
Range&& instructions,
std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
assert(m.has_instruction(ins) or is_end(ins, m.end()));
std::vector<instruction_ref> mod_outputs;
instruction_ref last;
for(instruction_ref sins : instructions)
{
last = sins;
if(contains(map_ins, sins))
continue;
instruction_ref copy_ins;
if(sins->name() == "@literal")
{
auto l = sins->get_literal();
copy_ins = m.add_literal(l);
}
else if(sins->name() == "@param")
{
auto&& name = any_cast<builtin::param>(sins->get_operator()).parameter;
auto s = sins->get_shape();
copy_ins = m.add_parameter(name, s);
}
else if(sins->name() == "@outline")
{
auto s = sins->get_shape();
copy_ins = m.add_outline(s);
}
else
{
auto mod_args = sins->module_inputs();
auto inputs = sins->inputs();
std::vector<instruction_ref> copy_inputs(inputs.size());
std::transform(inputs.begin(), inputs.end(), copy_inputs.begin(), [&](auto i) {
return contains(map_ins, i) ? map_ins[i] : i;
});
if(sins->name() == "@return")
{
mod_outputs = copy_inputs;
break;
}
copy_ins = m.insert_instruction(ins, sins->get_operator(), copy_inputs, mod_args);
}
map_ins[sins] = copy_ins;
}
if(mod_outputs.empty() and instructions.begin() != instructions.end())
mod_outputs = {map_ins.at(last)};
return mod_outputs;
}
instruction_ref module::add_instruction(const operation& op, std::vector<instruction_ref> args)
{
return insert_instruction(impl->instructions.end(), op, std::move(args));
......@@ -334,53 +391,49 @@ instruction_ref module::move_instructions(instruction_ref src, instruction_ref d
return src;
}
std::vector<instruction_ref> module::insert_module_instructions(
instruction_ref ins, module_ref m, std::unordered_map<instruction_ref, instruction_ref> map_ins)
std::vector<instruction_ref>
module::add_instructions(const std::vector<instruction_ref>& instructions,
std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
std::vector<instruction_ref> mod_outputs;
for(auto sins : iterator_for(*m))
{
if(contains(map_ins, sins))
continue;
instruction_ref copy_ins;
if(sins->name() == "@literal")
{
auto l = sins->get_literal();
copy_ins = this->add_literal(l);
}
else if(sins->name() == "@param")
{
auto&& name = any_cast<builtin::param>(sins->get_operator()).parameter;
auto s = sins->get_shape();
copy_ins = this->add_parameter(name, s);
}
else if(sins->name() == "@outline")
{
auto s = sins->get_shape();
copy_ins = this->add_outline(s);
}
else
{
auto mod_args = sins->module_inputs();
auto inputs = sins->inputs();
std::vector<instruction_ref> copy_inputs(inputs.size());
std::transform(inputs.begin(), inputs.end(), copy_inputs.begin(), [&](auto i) {
return contains(map_ins, i) ? map_ins[i] : i;
});
return this->insert_instructions(this->end(), instructions, std::move(map_ins));
}
if(sins->name() == "@return")
{
mod_outputs = copy_inputs;
break;
}
std::vector<instruction_ref>
module::add_instructions(module_ref m, std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
return this->insert_instructions(this->end(), m, std::move(map_ins));
}
copy_ins = this->insert_instruction(ins, sins->get_operator(), copy_inputs, mod_args);
}
map_ins[sins] = copy_ins;
}
if(mod_outputs.empty())
mod_outputs = {map_ins.at(std::prev(m->end()))};
return mod_outputs;
std::vector<instruction_ref>
module::add_instructions(instruction_ref start,
instruction_ref last,
std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
return this->insert_instructions(this->end(), start, last, std::move(map_ins));
}
std::vector<instruction_ref>
module::insert_instructions(instruction_ref ins,
const std::vector<instruction_ref>& instructions,
std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
return insert_generic_instructions(*this, ins, instructions, std::move(map_ins));
}
std::vector<instruction_ref> module::insert_instructions(
instruction_ref ins, module_ref m, std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
return insert_generic_instructions(*this, ins, iterator_for(*m), std::move(map_ins));
}
std::vector<instruction_ref>
module::insert_instructions(instruction_ref ins,
instruction_ref start,
instruction_ref last,
std::unordered_map<instruction_ref, instruction_ref> map_ins)
{
auto r = range(start, last);
return insert_generic_instructions(*this, ins, iterator_for(r), std::move(map_ins));
}
instruction_ref module::add_literal(literal l)
......@@ -706,44 +759,33 @@ void module::print_graph(std::ostream& os, bool brief) const
os << "}" << std::endl;
}
static std::string cpp_var_name(const std::string& name)
static std::string to_c_id(const std::string& name, char rep = '_')
{
return "m" + replace_string(name, "@", "x");
std::string id = transform_string(name, [&](auto c) {
if(with_char(::isalnum)(c) or c == '_')
return c;
return rep;
});
while(contains(id, "__"))
replace_string_inplace(id, "__", "_");
return id;
}
static std::string cpp_op_var(const std::string& name, instruction_ref ins)
static std::string cpp_var_name(const std::string& name)
{
return replace_string(name, "@", ins->name());
return to_c_id("x_" + replace_string(name, ":", "_module_"));
}
static void print_op_attributes(std::ostream& os, const std::string& name, const operation& op)
static void print_make_op(std::ostream& os, const operation& op)
{
std::string x = to_string(op);
if(contains(x, "["))
{
auto start = x.find('[');
auto end = x.find(']');
std::string attribute_text = x.substr(start + 1, end - start - 1);
std::vector<std::string> attributes;
for(auto&& attribute : split_string(attribute_text, ','))
os << "migraphx::make_op(" << enclose_name(op.name());
auto v = op.to_value();
if(not v.empty())
{
if(contains(attribute, '='))
attributes.push_back(attribute);
else
attributes.back() += "," + attribute;
}
for(auto&& attribute : attributes)
{
auto p = split_string(attribute, '=');
auto key = p.front();
auto value = p.back();
if(contains({"bn_mode", "padding_mode"}, key))
continue;
if(key == "mode")
value = enclose_name(trim(value));
os << name << "." << key << " = " << value << ";" << std::endl;
}
os << ", "
<< "migraphx::from_json_string(" << enclose_name(to_json_string(v)) << ")";
}
os << ")";
}
static void print_cpp_shape(std::ostream& os, const migraphx::shape& s)
......@@ -756,22 +798,25 @@ static void print_cpp_shape(std::ostream& os, const migraphx::shape& s)
}
std::unordered_map<instruction_ref, std::string>
module::print_cpp(std::ostream& os, std::unordered_map<instruction_ref, std::string> names) const
module::print_cpp(std::ostream& os,
const std::string& mname,
std::unordered_map<instruction_ref, std::string> names) const
{
os << "migraphx::module p;" << std::endl;
unsigned long seed = 0;
// cppcheck-suppress variableScope
unsigned long seed = names.size();
auto last = std::prev(this->end());
names = this->print(
[&](auto ins, auto ins_names) {
auto op = cpp_op_var(ins_names.at(ins), ins);
if(ins->name().front() != '@')
{
os << "migraphx::op::" << ins->name() << " " << op << ";" << std::endl;
print_op_attributes(os, op, ins->get_operator());
}
std::vector<std::string> input_vars;
std::transform(ins->inputs().begin(),
ins->inputs().end(),
std::back_inserter(input_vars),
[&](auto input) { return cpp_var_name(ins_names.at(input)); });
if(ins != last)
os << "auto " << cpp_var_name(ins_names.at(ins)) << " = ";
if(ins->name() == "@literal")
{
os << "p.add_literal(";
os << mname << "->add_literal(";
bool use_abs = false;
ins->get_literal().visit([&](auto v) {
use_abs = std::none_of(v.begin(), v.end(), [](auto x) { return x < 0; });
......@@ -789,17 +834,22 @@ module::print_cpp(std::ostream& os, std::unordered_map<instruction_ref, std::str
else if(ins->name() == "@param")
{
std::string name = any_cast<builtin::param>(ins->get_operator()).parameter;
os << "p.add_parameter(" << enclose_name(name) << ",";
os << mname << "->add_parameter(" << enclose_name(name) << ",";
print_cpp_shape(os, ins->get_shape());
os << ");" << std::endl;
}
else
else if(ins->name() == "@return")
{
os << "p.add_instruction(" << op;
for(auto input : ins->inputs())
{
os << ", " << cpp_var_name(ins_names.at(input));
os << mname << "->add_return({";
os << join_strings(input_vars, ", ");
os << "});" << std::endl;
}
else
{
assert(ins->name().front() != '@');
os << mname << "->add_instruction(";
print_make_op(os, ins->get_operator());
os << ", " << join_strings(input_vars, ", ");
os << ");" << std::endl;
}
},
......@@ -808,7 +858,7 @@ module::print_cpp(std::ostream& os, std::unordered_map<instruction_ref, std::str
return names;
}
void module::print_cpp(std::ostream& os) const { this->print_cpp(os, {}); }
void module::print_cpp(std::ostream& os) const { this->print_cpp(os, this->name(), {}); }
void module::annotate(std::ostream& os, std::function<void(instruction_ref)> a) const
{
......
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