replica
/
hanchenye-scalehls
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[Samples] Remove onnx-mlir folder completely

This commit is contained in:
Hanchen Ye 2022-02-23 17:38:50 -06:00
parent 02dcdd1438
commit a4b9e1fb7e
26 changed files with 0 additions and 7125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
samples/pytorch/torch-mlir/lenet/export_lenet_mlir.py → samples/pytorch/lenet/export_lenet_mlir.py
View File

@ -2,10 +2,7 @@ import sys
import torch.nn.functional as F
import torch.nn as nn
import torch
from torch_mlir.dialects.torch.importer.jit_ir import ClassAnnotator, ModuleBuilder
sys.path.append("../../models")
from lenet import LeNet

0
samples/pytorch/models/lenet.py → samples/pytorch/lenet/lenet.py
View File

0
samples/pytorch/models/mobilenet.py → samples/pytorch/mobilenet/mobilenet.py
View File

0
samples/pytorch/onnx-mlir/mobilenet/mobilenet_base.cpp → samples/pytorch/mobilenet/mobilenet_base.cpp
View File

0
samples/pytorch/onnx-mlir/mobilenet/mobilenet_g7l7d.cpp → samples/pytorch/mobilenet/mobilenet_g7l7d.cpp
View File

78
samples/pytorch/models/mobilenetv2.py
View File

@ -1,78 +0,0 @@
'''MobileNetV2 in PyTorch.
Modified based on (https://github.com/kuangliu/pytorch-cifar/blob/master/models/mobilenetv2.py)
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
'''expand + depthwise + pointwise'''
def __init__(self, in_planes, out_planes, expansion, stride):
super(Block, self).__init__()
self.stride = stride
planes = expansion * in_planes
self.conv1 = nn.Conv2d(
in_planes, planes, kernel_size=1, stride=1, padding=0, bias=False)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
stride=stride, padding=1, groups=planes, bias=False)
self.conv3 = nn.Conv2d(
planes, out_planes, kernel_size=1, stride=1, padding=0, bias=False)
self.shortcut = nn.Sequential()
if stride == 1 and in_planes != out_planes:
self.shortcut = nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=1,
stride=1, padding=0, bias=False)
)
def forward(self, x):
out = F.relu(self.conv1(x))
out = F.relu(self.conv2(out))
out = self.conv3(out)
out = out + self.shortcut(x) if self.stride == 1 else out
return out
class MobileNetV2(nn.Module):
# (expansion, out_planes, num_blocks, stride)
cfg = [(1, 16, 1, 1),
(6, 24, 2, 1), # NOTE: change stride 2 -> 1 for CIFAR10
(6, 32, 3, 2),
(6, 64, 4, 2),
(6, 96, 3, 1),
(6, 160, 3, 2),
(6, 320, 1, 1)]
def __init__(self, num_classes=10):
super(MobileNetV2, self).__init__()
# NOTE: change conv1 stride 2 -> 1 for CIFAR10
self.conv1 = nn.Conv2d(3, 32, kernel_size=3,
stride=1, padding=1, bias=False)
self.layers = self._make_layers(in_planes=32)
self.conv2 = nn.Conv2d(320, 1280, kernel_size=1,
stride=1, padding=0, bias=False)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.linear = nn.Linear(1280, num_classes)
def _make_layers(self, in_planes):
layers = []
for expansion, out_planes, num_blocks, stride in self.cfg:
strides = [stride] + [1]*(num_blocks-1)
for stride in strides:
layers.append(Block(in_planes, out_planes, expansion, stride))
in_planes = out_planes
return nn.Sequential(*layers)
def forward(self, x):
out = F.relu(self.conv1(x))
out = self.layers(out)
out = F.relu(self.conv2(out))
# NOTE: change pooling kernel_size 7 -> 4 for CIFAR10
out = self.avgpool(out)
out = torch.flatten(out, 1) # out.view(out.size(0), -1)
out = self.linear(out)
return out

16
samples/pytorch/onnx-mlir/README.md
View File

@ -1,16 +0,0 @@
## Using ONNX-MLIR front-end (deprecated, will be removed soon)
If you have installed [ONNX-MLIR](https://github.com/onnx/onnx-mlir) or established ONNX-MLIR docker, you should be able to run the following test:
```sh
$ cd resnet18
$ # Export PyTorch model to ONNX.
$ python3 export_resnet18.py
$ # Parse ONNX model to MLIR.
$ onnx-mlir -EmitMLIRIR resnet18.onnx
$ # Legalize the output of ONNX-MLIR, optimize and emit C++ code.
$ scalehls-opt resnet18.onnx.mlir -allow-unregistered-dialect \
-scalehls-pipeline="top-func=main_graph opt-level=2 frontend=onnx" \
| scalehls-translate -emit-hlscpp > resnet18.cpp
```

116
samples/pytorch/onnx-mlir/ablation_int_test.sh
View File

@ -1,116 +0,0 @@
#!/bin/bash
# This test is deprecated and will be removed soon!!
# Please run: source ablation_int_test.sh -m resnet18 -n 17 -c 0
# Script options.
while getopts 'm:n:c:' opt
do
case $opt in
m) model_name=$OPTARG ;;
n) ablation_number=$OPTARG ;;
c) rerun_csynth_from=$OPTARG ;;
esac
done
# Create directories.
if [ ! -d "${model_name}/cpp_src" ]
then
mkdir ${model_name}/cpp_src
fi
if [ ! -d "${model_name}/hls_proj" ]
then
mkdir ${model_name}/hls_proj
fi
# Legalization from ONNX.
legalize="-allow-unregistered-dialect -legalize-onnx -affine-loop-normalize -canonicalize"
# Different level graph optimization.
graph_O1=-legalize-dataflow="min-gran=8 insert-copy=true"
graph_O2=-legalize-dataflow="min-gran=7 insert-copy=true"
graph_O3=-legalize-dataflow="min-gran=6 insert-copy=true"
graph_O4=-legalize-dataflow="min-gran=5 insert-copy=true"
graph_O5=-legalize-dataflow="min-gran=4 insert-copy=true"
graph_O6=-legalize-dataflow="min-gran=3 insert-copy=true"
graph_O7=-legalize-dataflow="min-gran=2 insert-copy=true"
# Split and canonicalize function, convert to HLSCpp, and loop perfection.
split="-split-function -convert-linalg-to-affine-loops -quantize-onnx -canonicalize"
hlscpp=-legalize-to-hlscpp="top-func=main_graph"
perfect="-affine-loop-perfection"
# Different level loop optimization (tile + order opt + pipeline).
loop_O1="-affine-loop-order-opt -loop-pipelining"
loop_O2=-partial-affine-loop-tile="tile-size=2 apply-order-opt=true apply-pipeline=true"
loop_O3=-partial-affine-loop-tile="tile-size=4 apply-order-opt=true apply-pipeline=true"
loop_O4=-partial-affine-loop-tile="tile-size=8 apply-order-opt=true apply-pipeline=true"
loop_O5=-partial-affine-loop-tile="tile-size=16 apply-order-opt=true apply-pipeline=true"
loop_O6=-partial-affine-loop-tile="tile-size=32 apply-order-opt=true apply-pipeline=true"
loop_O7=-partial-affine-loop-tile="tile-size=64 apply-order-opt=true apply-pipeline=true"
# Loop pipelining, and other directive optimization.
pipeline="-loop-pipelining"
direct="-simplify-affine-if -affine-store-forward -simplify-memref-access -array-partition -cse -canonicalize"
# Ablation test.
echo -e "Name\tBRAM\tDSP\tLUT\tCycles\tInterval" > ${model_name}/${model_name}_result.log
n=0
while [ $n -lt $ablation_number ]
do
file=${model_name}/${model_name}.mlir
output=${model_name}/cpp_src/${model_name}_case$n.cpp
case $n in
# Non-opt.
0) scalehls-opt $file $legalize $split $hlscpp | scalehls-translate -emit-hlscpp -o $output ;;
# Only directive opt.
1) scalehls-opt $file $legalize $split $hlscpp $pipeline $direct | scalehls-translate -emit-hlscpp -o $output ;;
# Graph (level 7) + directive opt.
2) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $pipeline $direct | scalehls-translate -emit-hlscpp -o $output ;;
# Loop (level 7) + directive opt.
3) scalehls-opt $file $legalize $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
# Graph (level 7) + loop (level 7) + directive opt.
4) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
## Ablation study of loop opt.
# Graph (level 7) + loop (level 1 to 6) + directive opt.
5) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $perfect $loop_O1 $direct | scalehls-translate -emit-hlscpp -o $output ;;
6) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $perfect "$loop_O2" $direct | scalehls-translate -emit-hlscpp -o $output ;;
7) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $perfect "$loop_O3" $direct | scalehls-translate -emit-hlscpp -o $output ;;
8) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $perfect "$loop_O4" $direct | scalehls-translate -emit-hlscpp -o $output ;;
9) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $perfect "$loop_O5" $direct | scalehls-translate -emit-hlscpp -o $output ;;
10) scalehls-opt $file $legalize "$graph_O7" $split $hlscpp $perfect "$loop_O6" $direct | scalehls-translate -emit-hlscpp -o $output ;;
## Ablation study of graph opt.
# Graph (from level 1 to 6) + loop (level 7) + directive opt.
11) scalehls-opt $file $legalize "$graph_O1" $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
12) scalehls-opt $file $legalize "$graph_O2" $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
13) scalehls-opt $file $legalize "$graph_O3" $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
14) scalehls-opt $file $legalize "$graph_O4" $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
15) scalehls-opt $file $legalize "$graph_O5" $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
16) scalehls-opt $file $legalize "$graph_O6" $split $hlscpp $perfect "$loop_O7" $direct | scalehls-translate -emit-hlscpp -o $output ;;
esac
if [ $n -ge $rerun_csynth_from ]
then
# Run HLS synthesis.
cd ${model_name}/hls_proj
vivado_hls ../../hls_script.tcl "main_graph" "../cpp_src/${model_name}_case$n.cpp" "${model_name}_case$n"
cd ../..
fi
csynth_xml=${model_name}/hls_proj/${model_name}_case$n/main_graph/syn/report/csynth.xml
bram=$(awk '/<\/*BRAM_18K>/{gsub(/<\/*BRAM_18K>/,"");print $0;exit;}' $csynth_xml)
dsp=$(awk '/<\/*DSP48E>/{gsub(/<\/*DSP48E>/,"");print $0;exit;}' $csynth_xml)
lut=$(awk '/<\/*LUT>/{gsub(/<\/*LUT>/,"");print $0;exit;}' $csynth_xml)
cycles=$(awk '/<\/*Best-caseLatency>/{gsub(/<\/*Best-caseLatency>/,"");print $0}' $csynth_xml)
interval=$(awk '/<\/*Interval-min>/{gsub(/<\/*Interval-min>/,"");print $0}' $csynth_xml)
echo -e "Case_$n\t$bram\t$dsp\t$lut\t$cycles\t$interval" >> ${model_name}/${model_name}_result.log
let n++
done

15
samples/pytorch/onnx-mlir/hls_script.tcl
View File

@ -1,15 +0,0 @@
set name [lindex $argv 0]
set file [lindex $argv 1]
set proj [lindex $argv 2]
open_project $proj
set_top $name
add_files $file
open_solution $name
#set_part {xc7z020-clg400-1} -tool vivado
set_part {xcvu9p-flga2104-2L-e} -tool vivado
create_clock -period 5 -name default
#csim_design
csynth_design
#cosim_design
close_project

11
samples/pytorch/onnx-mlir/lenet/export_lenet_onnx.py
View File

@ -1,11 +0,0 @@
import sys
import torch.nn.functional as F
import torch.nn as nn
import torch
sys.path.append("../../models")
from lenet import LeNet
input_random = torch.randn((1, 3, 32, 32))
torch.onnx.export(LeNet(), input_random, 'lenet.onnx', opset_version=7)

208
samples/pytorch/onnx-mlir/lenet/lenet.mlir
View File

@ -1,208 +0,0 @@
#map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
#map1 = affine_map<(d0, d1) -> (d0 * 2 + d1)>
#map2 = affine_map<() -> (0)>
#map3 = affine_map<() -> (5)>
#map4 = affine_map<() -> (3)>
#map5 = affine_map<() -> (14)>
#map6 = affine_map<() -> (6)>
#map7 = affine_map<() -> (1)>
#map8 = affine_map<() -> (16)>
#map9 = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 + d1 * s2 + d0 * (s1 * s2))>
#map10 = affine_map<(d0, d1) -> (d0, d1)>
#map11 = affine_map<() -> (400)>
#map12 = affine_map<(d0) -> (d0)>
#map13 = affine_map<() -> (120)>
#map14 = affine_map<() -> (84)>
#map15 = affine_map<() -> (10)>
module {
%0 = "krnl.packed_const"() {file_name = "/tmp/packed_const-b6b002.tmp", is_le = true, size_in_bytes = 247896 : i64} : () -> i64
func @main_graph(%arg0: memref<1x3x32x32xf32>) -> memref<1x10xf32> attributes {input_names = ["input.1"], output_names = ["18"]} {
%c16 = arith.constant 16 : index
%c5 = arith.constant 5 : index
%cst = arith.constant 1.000000e+00 : f32
%cst_0 = arith.constant 0.000000e+00 : f32
%1 = memref.alloc() : memref<1x10xf32>
%2 = memref.alloc() : memref<1x84xf32>
%3 = memref.alloc() : memref<1x84xf32>
%4 = memref.alloc() : memref<1x120xf32>
%5 = memref.alloc() : memref<1x120xf32>
%6 = memref.alloc() : memref<1x400xf32>
%7 = memref.alloc() : memref<1x16x5x5xf32>
%8 = memref.alloc() : memref<1x16x5x5xf32>
%9 = memref.alloc() : memref<1x6x14x14xf32>
%10 = memref.alloc() : memref<1x6x14x14xf32>
%11 = "krnl.global"() {name = "arith.constant_0", offset = 0 : i64, shape = [6, 3, 5, 5]} : () -> memref<6x3x5x5xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 6 {
affine.for %arg3 = 0 to 14 {
affine.for %arg4 = 0 to 14 {
affine.store %cst_0, %10[%arg1, %arg2, %arg3, %arg4] : memref<1x6x14x14xf32>
affine.for %arg5 = 0 to 3 {
affine.for %arg6 = 0 to 5 {
affine.for %arg7 = 0 to 5 {
%19 = affine.apply #map1(%arg3, %arg6)
%20 = affine.apply #map1(%arg4, %arg7)
%21 = affine.load %arg0[%arg1, %arg5, %19, %20] : memref<1x3x32x32xf32>
%22 = affine.load %11[%arg2, %arg5, %arg6, %arg7] : memref<6x3x5x5xf32>
%23 = affine.load %10[%arg1, %arg2, %arg3, %arg4] : memref<1x6x14x14xf32>
%24 = arith.mulf %21, %22 : f32
%25 = arith.addf %23, %24 : f32
affine.store %25, %10[%arg1, %arg2, %arg3, %arg4] : memref<1x6x14x14xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 6 {
affine.for %arg3 = 0 to 14 {
affine.for %arg4 = 0 to 14 {
%19 = affine.load %10[%arg1, %arg2, %arg3, %arg4] : memref<1x6x14x14xf32>
%20 = arith.cmpf "olt", %19, %cst_0 : f32
%21 = select %20, %cst_0, %19 : f32
affine.store %21, %9[%arg1, %arg2, %arg3, %arg4] : memref<1x6x14x14xf32>
}
}
}
}
%12 = "krnl.global"() {name = "arith.constant_1", offset = 1800 : i64, shape = [16, 6, 5, 5]} : () -> memref<16x6x5x5xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 16 {
affine.for %arg3 = 0 to 5 {
affine.for %arg4 = 0 to 5 {
affine.store %cst_0, %8[%arg1, %arg2, %arg3, %arg4] : memref<1x16x5x5xf32>
affine.for %arg5 = 0 to 6 {
affine.for %arg6 = 0 to 5 {
affine.for %arg7 = 0 to 5 {
%19 = affine.apply #map1(%arg3, %arg6)
%20 = affine.apply #map1(%arg4, %arg7)
%21 = affine.load %9[%arg1, %arg5, %19, %20] : memref<1x6x14x14xf32>
%22 = affine.load %12[%arg2, %arg5, %arg6, %arg7] : memref<16x6x5x5xf32>
%23 = affine.load %8[%arg1, %arg2, %arg3, %arg4] : memref<1x16x5x5xf32>
%24 = arith.mulf %21, %22 : f32
%25 = arith.addf %23, %24 : f32
affine.store %25, %8[%arg1, %arg2, %arg3, %arg4] : memref<1x16x5x5xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 16 {
affine.for %arg3 = 0 to 5 {
affine.for %arg4 = 0 to 5 {
%19 = affine.load %8[%arg1, %arg2, %arg3, %arg4] : memref<1x16x5x5xf32>
%20 = arith.cmpf "olt", %19, %cst_0 : f32
%21 = select %20, %cst_0, %19 : f32
affine.store %21, %7[%arg1, %arg2, %arg3, %arg4] : memref<1x16x5x5xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 16 {
affine.for %arg3 = 0 to 5 {
affine.for %arg4 = 0 to 5 {
%19 = affine.load %7[%arg1, %arg2, %arg3, %arg4] : memref<1x16x5x5xf32>
%20 = affine.apply #map9(%arg2, %arg3, %arg4)[%c16, %c5, %c5]
affine.store %19, %6[%arg1, %20] : memref<1x400xf32>
}
}
}
}
%13 = "krnl.global"() {name = "arith.constant_2", offset = 11400 : i64, shape = [120, 400]} : () -> memref<120x400xf32>
%14 = "krnl.global"() {name = "arith.constant_3", offset = 203400 : i64, shape = [120]} : () -> memref<120xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 120 {
affine.store %cst_0, %5[%arg1, %arg2] : memref<1x120xf32>
affine.for %arg3 = 0 to 400 {
%24 = affine.load %6[%arg1, %arg3] : memref<1x400xf32>
%25 = affine.load %13[%arg2, %arg3] : memref<120x400xf32>
%26 = affine.load %5[%arg1, %arg2] : memref<1x120xf32>
%27 = arith.mulf %24, %25 : f32
%28 = arith.addf %26, %27 : f32
affine.store %28, %5[%arg1, %arg2] : memref<1x120xf32>
}
%19 = affine.load %5[%arg1, %arg2] : memref<1x120xf32>
%20 = arith.mulf %cst, %19 : f32
%21 = affine.load %14[%arg2] : memref<120xf32>
%22 = arith.mulf %cst, %21 : f32
%23 = arith.addf %20, %22 : f32
affine.store %23, %5[%arg1, %arg2] : memref<1x120xf32>
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 120 {
%19 = affine.load %5[%arg1, %arg2] : memref<1x120xf32>
%20 = arith.cmpf "olt", %19, %cst_0 : f32
%21 = select %20, %cst_0, %19 : f32
affine.store %21, %4[%arg1, %arg2] : memref<1x120xf32>
}
}
%15 = "krnl.global"() {name = "arith.constant_4", offset = 203880 : i64, shape = [84, 120]} : () -> memref<84x120xf32>
%16 = "krnl.global"() {name = "arith.constant_5", offset = 244200 : i64, shape = [84]} : () -> memref<84xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 84 {
affine.store %cst_0, %3[%arg1, %arg2] : memref<1x84xf32>
affine.for %arg3 = 0 to 120 {
%24 = affine.load %4[%arg1, %arg3] : memref<1x120xf32>
%25 = affine.load %15[%arg2, %arg3] : memref<84x120xf32>
%26 = affine.load %3[%arg1, %arg2] : memref<1x84xf32>
%27 = arith.mulf %24, %25 : f32
%28 = arith.addf %26, %27 : f32
affine.store %28, %3[%arg1, %arg2] : memref<1x84xf32>
}
%19 = affine.load %3[%arg1, %arg2] : memref<1x84xf32>
%20 = arith.mulf %cst, %19 : f32
%21 = affine.load %16[%arg2] : memref<84xf32>
%22 = arith.mulf %cst, %21 : f32
%23 = arith.addf %20, %22 : f32
affine.store %23, %3[%arg1, %arg2] : memref<1x84xf32>
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 84 {
%19 = affine.load %3[%arg1, %arg2] : memref<1x84xf32>
%20 = arith.cmpf "olt", %19, %cst_0 : f32
%21 = select %20, %cst_0, %19 : f32
affine.store %21, %2[%arg1, %arg2] : memref<1x84xf32>
}
}
%17 = "krnl.global"() {name = "arith.constant_6", offset = 244536 : i64, shape = [10, 84]} : () -> memref<10x84xf32>
%18 = "krnl.global"() {name = "arith.constant_7", offset = 247896 : i64, shape = [10], value = dense<[0.0802067816, 0.0380531251, -0.0453170575, 0.0238099229, -0.0322267264, 0.0956416651, -0.0513828322, -0.00329447933, 0.0870032906, -0.100006074]> : tensor<10xf32>} : () -> memref<10xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 10 {
affine.store %cst_0, %1[%arg1, %arg2] : memref<1x10xf32>
affine.for %arg3 = 0 to 84 {
%24 = affine.load %2[%arg1, %arg3] : memref<1x84xf32>
%25 = affine.load %17[%arg2, %arg3] : memref<10x84xf32>
%26 = affine.load %1[%arg1, %arg2] : memref<1x10xf32>
%27 = arith.mulf %24, %25 : f32
%28 = arith.addf %26, %27 : f32
affine.store %28, %1[%arg1, %arg2] : memref<1x10xf32>
}
%19 = affine.load %1[%arg1, %arg2] : memref<1x10xf32>
%20 = arith.mulf %cst, %19 : f32
%21 = affine.load %18[%arg2] : memref<10xf32>
%22 = arith.mulf %cst, %21 : f32
%23 = arith.addf %20, %22 : f32
affine.store %23, %1[%arg1, %arg2] : memref<1x10xf32>
}
}
memref.dealloc %10 : memref<1x6x14x14xf32>
memref.dealloc %9 : memref<1x6x14x14xf32>
memref.dealloc %8 : memref<1x16x5x5xf32>
memref.dealloc %7 : memref<1x16x5x5xf32>
memref.dealloc %6 : memref<1x400xf32>
memref.dealloc %5 : memref<1x120xf32>
memref.dealloc %4 : memref<1x120xf32>
memref.dealloc %3 : memref<1x84xf32>
memref.dealloc %2 : memref<1x84xf32>
return %1 : memref<1x10xf32>
}
"krnl.entry_point"() {func = @main_graph, numInputs = 1 : i32, numOutputs = 1 : i32} : () -> ()
}

11
samples/pytorch/onnx-mlir/mobilenet/export_mobilenet_onnx.py
View File

@ -1,11 +0,0 @@
import sys
import torch.nn.functional as F
import torch.nn as nn
import torch
sys.path.append("../../models")
from mobilenet import MobileNet
input_random = torch.randn((1, 3, 32, 32))
torch.onnx.export(MobileNet(), input_random, 'mobilenet.onnx', opset_version=7)

1562
samples/pytorch/onnx-mlir/mobilenet/mobilenet.mlir
View File

File diff suppressed because it is too large Load Diff

12
samples/pytorch/onnx-mlir/mobilenetv2/export_mobilenetv2_onnx.py
View File

@ -1,12 +0,0 @@
import sys
import torch.nn.functional as F
import torch.nn as nn
import torch
sys.path.append("../../models")
from mobilenetv2 import MobileNetV2
input_random = torch.randn((1, 3, 32, 32))
torch.onnx.export(MobileNetV2(), input_random,
'mobilenetv2.onnx', opset_version=7)

2777
samples/pytorch/onnx-mlir/mobilenetv2/mobilenetv2.mlir
View File

File diff suppressed because it is too large Load Diff

11
samples/pytorch/onnx-mlir/resnet18/export_resnet18_onnx.py
View File

@ -1,11 +0,0 @@
import sys
import torch.nn.functional as F
import torch.nn as nn
import torch
sys.path.append("../../models")
from resnet18 import ResNet18
input_random = torch.randn((1, 3, 32, 32))
torch.onnx.export(ResNet18(), input_random, 'resnet18.onnx', opset_version=7)

1366
samples/pytorch/onnx-mlir/resnet18/resnet18.mlir
View File

File diff suppressed because it is too large Load Diff

11
samples/pytorch/onnx-mlir/vgg16/export_vgg16_onnx.py
View File

@ -1,11 +0,0 @@
import sys
import torch.nn.functional as F
import torch.nn as nn
import torch
sys.path.append("../../models")
from vgg16 import VGG16
input_random = torch.randn((1, 3, 32, 32))
torch.onnx.export(VGG16(), input_random, 'vgg16.onnx', opset_version=7)

925
samples/pytorch/onnx-mlir/vgg16/vgg16.mlir
View File

@ -1,925 +0,0 @@
#map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
#map1 = affine_map<() -> (0)>
#map2 = affine_map<() -> (34)>
#map3 = affine_map<() -> (3)>
#map4 = affine_map<() -> (1)>
#map5 = affine_map<(d0) -> (d0 + 1)>
#map6 = affine_map<() -> (32)>
#map7 = affine_map<(d0, d1) -> (d0 + d1)>
#map8 = affine_map<() -> (64)>
#map9 = affine_map<(d0, d1) -> (d0 * 2 + d1)>
#map10 = affine_map<() -> (16)>
#map11 = affine_map<() -> (18)>
#map12 = affine_map<() -> (128)>
#map13 = affine_map<() -> (8)>
#map14 = affine_map<() -> (10)>
#map15 = affine_map<() -> (256)>
#map16 = affine_map<() -> (4)>
#map17 = affine_map<() -> (6)>
#map18 = affine_map<() -> (512)>
#map19 = affine_map<() -> (2)>
#map20 = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 + d1 * s2 + d0 * (s1 * s2))>
#map21 = affine_map<(d0, d1) -> (d0, d1)>
#map22 = affine_map<(d0) -> (d0)>
module {
%0 = "krnl.packed_const"() {file_name = "/tmp/packed_const-708c58.tmp", is_le = true, size_in_bytes = 58862336 : i64} : () -> i64
func @main_graph(%arg0: memref<1x3x32x32xf32>) -> memref<1x10xf32> attributes {input_names = ["input.1"], output_names = ["44"]} {
%c0 = arith.constant 0 : index
%c1_i64 = arith.constant 1 : i64
%c512 = arith.constant 512 : index
%c1 = arith.constant 1 : index
%cst = arith.constant 1.000000e+00 : f32
%cst_0 = arith.constant 0.000000e+00 : f32
%1 = memref.alloc() : memref<1x10xf32>
%2 = memref.alloc() : memref<1x512xf32>
%3 = memref.alloc() : memref<1x512x1x1xf32>
%4 = memref.alloc() : memref<1x512x1x1xf32>
%5 = memref.alloc() : memref<1x512x1x1xf32>
%6 = memref.alloc() : memref<1x512x4x4xf32>
%7 = memref.alloc() : memref<1x512x2x2xf32>
%8 = memref.alloc() : memref<1x512x2x2xf32>
%9 = memref.alloc() : memref<1x512x4x4xf32>
%10 = memref.alloc() : memref<1x512x2x2xf32>
%11 = memref.alloc() : memref<1x512x2x2xf32>
%12 = memref.alloc() : memref<1x512x4x4xf32>
%13 = memref.alloc() : memref<1x512x2x2xf32>
%14 = memref.alloc() : memref<1x512x2x2xf32>
%15 = memref.alloc() : memref<1x512x6x6xf32>
%16 = memref.alloc() : memref<1x512x4x4xf32>
%17 = memref.alloc() : memref<1x512x4x4xf32>
%18 = memref.alloc() : memref<1x512x6x6xf32>
%19 = memref.alloc() : memref<1x512x4x4xf32>
%20 = memref.alloc() : memref<1x512x4x4xf32>
%21 = memref.alloc() : memref<1x256x6x6xf32>
%22 = memref.alloc() : memref<1x256x4x4xf32>
%23 = memref.alloc() : memref<1x256x4x4xf32>
%24 = memref.alloc() : memref<1x256x10x10xf32>
%25 = memref.alloc() : memref<1x256x8x8xf32>
%26 = memref.alloc() : memref<1x256x8x8xf32>
%27 = memref.alloc() : memref<1x256x10x10xf32>
%28 = memref.alloc() : memref<1x256x8x8xf32>
%29 = memref.alloc() : memref<1x256x8x8xf32>
%30 = memref.alloc() : memref<1x128x10x10xf32>
%31 = memref.alloc() : memref<1x128x8x8xf32>
%32 = memref.alloc() : memref<1x128x8x8xf32>
%33 = memref.alloc() : memref<1x128x18x18xf32>
%34 = memref.alloc() : memref<1x128x16x16xf32>
%35 = memref.alloc() : memref<1x128x16x16xf32>
%36 = memref.alloc() : memref<1x64x18x18xf32>
%37 = memref.alloc() : memref<1x64x16x16xf32>
%38 = memref.alloc() : memref<1x64x16x16xf32>
%39 = memref.alloc() : memref<1x64x34x34xf32>
%40 = memref.alloc() : memref<1x64x32x32xf32>
%41 = memref.alloc() : memref<1x64x32x32xf32>
%42 = memref.alloc() : memref<1x3x34x34xf32>
%43 = "krnl.global"() {name = "arith.constant_0", offset = 0 : i64, shape = [64, 3, 3, 3]} : () -> memref<64x3x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 3 {
affine.for %arg3 = 0 to 34 {
affine.for %arg4 = 0 to 34 {
affine.store %cst_0, %42[%arg1, %arg2, %arg3, %arg4] : memref<1x3x34x34xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 3 {
affine.for %arg3 = 0 to 32 {
affine.for %arg4 = 0 to 32 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %arg0[%arg1, %arg2, %arg3, %arg4] : memref<1x3x32x32xf32>
affine.store %61, %42[%arg1, %arg2, %59, %60] : memref<1x3x34x34xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 32 {
affine.for %arg4 = 0 to 32 {
affine.store %cst_0, %41[%arg1, %arg2, %arg3, %arg4] : memref<1x64x32x32xf32>
affine.for %arg5 = 0 to 3 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %42[%arg1, %arg5, %59, %60] : memref<1x3x34x34xf32>
%62 = affine.load %43[%arg2, %arg5, %arg6, %arg7] : memref<64x3x3x3xf32>
%63 = affine.load %41[%arg1, %arg2, %arg3, %arg4] : memref<1x64x32x32xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %41[%arg1, %arg2, %arg3, %arg4] : memref<1x64x32x32xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 32 {
affine.for %arg4 = 0 to 32 {
%59 = affine.load %41[%arg1, %arg2, %arg3, %arg4] : memref<1x64x32x32xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %40[%arg1, %arg2, %arg3, %arg4] : memref<1x64x32x32xf32>
}
}
}
}
%44 = "krnl.global"() {name = "arith.constant_1", offset = 6912 : i64, shape = [64, 64, 3, 3]} : () -> memref<64x64x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 34 {
affine.for %arg4 = 0 to 34 {
affine.store %cst_0, %39[%arg1, %arg2, %arg3, %arg4] : memref<1x64x34x34xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 32 {
affine.for %arg4 = 0 to 32 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %40[%arg1, %arg2, %arg3, %arg4] : memref<1x64x32x32xf32>
affine.store %61, %39[%arg1, %arg2, %59, %60] : memref<1x64x34x34xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 16 {
affine.for %arg4 = 0 to 16 {
affine.store %cst_0, %38[%arg1, %arg2, %arg3, %arg4] : memref<1x64x16x16xf32>
affine.for %arg5 = 0 to 64 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map9(%arg3, %arg6)
%60 = affine.apply #map9(%arg4, %arg7)
%61 = affine.load %39[%arg1, %arg5, %59, %60] : memref<1x64x34x34xf32>
%62 = affine.load %44[%arg2, %arg5, %arg6, %arg7] : memref<64x64x3x3xf32>
%63 = affine.load %38[%arg1, %arg2, %arg3, %arg4] : memref<1x64x16x16xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %38[%arg1, %arg2, %arg3, %arg4] : memref<1x64x16x16xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 16 {
affine.for %arg4 = 0 to 16 {
%59 = affine.load %38[%arg1, %arg2, %arg3, %arg4] : memref<1x64x16x16xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %37[%arg1, %arg2, %arg3, %arg4] : memref<1x64x16x16xf32>
}
}
}
}
%45 = "krnl.global"() {name = "arith.constant_2", offset = 154368 : i64, shape = [128, 64, 3, 3]} : () -> memref<128x64x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 18 {
affine.for %arg4 = 0 to 18 {
affine.store %cst_0, %36[%arg1, %arg2, %arg3, %arg4] : memref<1x64x18x18xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 64 {
affine.for %arg3 = 0 to 16 {
affine.for %arg4 = 0 to 16 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %37[%arg1, %arg2, %arg3, %arg4] : memref<1x64x16x16xf32>
affine.store %61, %36[%arg1, %arg2, %59, %60] : memref<1x64x18x18xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 16 {
affine.for %arg4 = 0 to 16 {
affine.store %cst_0, %35[%arg1, %arg2, %arg3, %arg4] : memref<1x128x16x16xf32>
affine.for %arg5 = 0 to 64 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %36[%arg1, %arg5, %59, %60] : memref<1x64x18x18xf32>
%62 = affine.load %45[%arg2, %arg5, %arg6, %arg7] : memref<128x64x3x3xf32>
%63 = affine.load %35[%arg1, %arg2, %arg3, %arg4] : memref<1x128x16x16xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %35[%arg1, %arg2, %arg3, %arg4] : memref<1x128x16x16xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 16 {
affine.for %arg4 = 0 to 16 {
%59 = affine.load %35[%arg1, %arg2, %arg3, %arg4] : memref<1x128x16x16xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %34[%arg1, %arg2, %arg3, %arg4] : memref<1x128x16x16xf32>
}
}
}
}
%46 = "krnl.global"() {name = "arith.constant_3", offset = 449280 : i64, shape = [128, 128, 3, 3]} : () -> memref<128x128x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 18 {
affine.for %arg4 = 0 to 18 {
affine.store %cst_0, %33[%arg1, %arg2, %arg3, %arg4] : memref<1x128x18x18xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 16 {
affine.for %arg4 = 0 to 16 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %34[%arg1, %arg2, %arg3, %arg4] : memref<1x128x16x16xf32>
affine.store %61, %33[%arg1, %arg2, %59, %60] : memref<1x128x18x18xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
affine.store %cst_0, %32[%arg1, %arg2, %arg3, %arg4] : memref<1x128x8x8xf32>
affine.for %arg5 = 0 to 128 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map9(%arg3, %arg6)
%60 = affine.apply #map9(%arg4, %arg7)
%61 = affine.load %33[%arg1, %arg5, %59, %60] : memref<1x128x18x18xf32>
%62 = affine.load %46[%arg2, %arg5, %arg6, %arg7] : memref<128x128x3x3xf32>
%63 = affine.load %32[%arg1, %arg2, %arg3, %arg4] : memref<1x128x8x8xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %32[%arg1, %arg2, %arg3, %arg4] : memref<1x128x8x8xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
%59 = affine.load %32[%arg1, %arg2, %arg3, %arg4] : memref<1x128x8x8xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %31[%arg1, %arg2, %arg3, %arg4] : memref<1x128x8x8xf32>
}
}
}
}
%47 = "krnl.global"() {name = "arith.constant_4", offset = 1039104 : i64, shape = [256, 128, 3, 3]} : () -> memref<256x128x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 10 {
affine.for %arg4 = 0 to 10 {
affine.store %cst_0, %30[%arg1, %arg2, %arg3, %arg4] : memref<1x128x10x10xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 128 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %31[%arg1, %arg2, %arg3, %arg4] : memref<1x128x8x8xf32>
affine.store %61, %30[%arg1, %arg2, %59, %60] : memref<1x128x10x10xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
affine.store %cst_0, %29[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
affine.for %arg5 = 0 to 128 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %30[%arg1, %arg5, %59, %60] : memref<1x128x10x10xf32>
%62 = affine.load %47[%arg2, %arg5, %arg6, %arg7] : memref<256x128x3x3xf32>
%63 = affine.load %29[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %29[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
%59 = affine.load %29[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %28[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
}
}
}
}
%48 = "krnl.global"() {name = "arith.constant_5", offset = 2218752 : i64, shape = [256, 256, 3, 3]} : () -> memref<256x256x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 10 {
affine.for %arg4 = 0 to 10 {
affine.store %cst_0, %27[%arg1, %arg2, %arg3, %arg4] : memref<1x256x10x10xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %28[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
affine.store %61, %27[%arg1, %arg2, %59, %60] : memref<1x256x10x10xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
affine.store %cst_0, %26[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
affine.for %arg5 = 0 to 256 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %27[%arg1, %arg5, %59, %60] : memref<1x256x10x10xf32>
%62 = affine.load %48[%arg2, %arg5, %arg6, %arg7] : memref<256x256x3x3xf32>
%63 = affine.load %26[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %26[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
%59 = affine.load %26[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %25[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
}
}
}
}
%49 = "krnl.global"() {name = "arith.constant_6", offset = 4578048 : i64, shape = [256, 256, 3, 3]} : () -> memref<256x256x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 10 {
affine.for %arg4 = 0 to 10 {
affine.store %cst_0, %24[%arg1, %arg2, %arg3, %arg4] : memref<1x256x10x10xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 8 {
affine.for %arg4 = 0 to 8 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %25[%arg1, %arg2, %arg3, %arg4] : memref<1x256x8x8xf32>
affine.store %61, %24[%arg1, %arg2, %59, %60] : memref<1x256x10x10xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
affine.store %cst_0, %23[%arg1, %arg2, %arg3, %arg4] : memref<1x256x4x4xf32>
affine.for %arg5 = 0 to 256 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map9(%arg3, %arg6)
%60 = affine.apply #map9(%arg4, %arg7)
%61 = affine.load %24[%arg1, %arg5, %59, %60] : memref<1x256x10x10xf32>
%62 = affine.load %49[%arg2, %arg5, %arg6, %arg7] : memref<256x256x3x3xf32>
%63 = affine.load %23[%arg1, %arg2, %arg3, %arg4] : memref<1x256x4x4xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %23[%arg1, %arg2, %arg3, %arg4] : memref<1x256x4x4xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
%59 = affine.load %23[%arg1, %arg2, %arg3, %arg4] : memref<1x256x4x4xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %22[%arg1, %arg2, %arg3, %arg4] : memref<1x256x4x4xf32>
}
}
}
}
%50 = "krnl.global"() {name = "arith.constant_7", offset = 6937344 : i64, shape = [512, 256, 3, 3]} : () -> memref<512x256x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 6 {
affine.for %arg4 = 0 to 6 {
affine.store %cst_0, %21[%arg1, %arg2, %arg3, %arg4] : memref<1x256x6x6xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 256 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %22[%arg1, %arg2, %arg3, %arg4] : memref<1x256x4x4xf32>
affine.store %61, %21[%arg1, %arg2, %59, %60] : memref<1x256x6x6xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
affine.store %cst_0, %20[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
affine.for %arg5 = 0 to 256 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %21[%arg1, %arg5, %59, %60] : memref<1x256x6x6xf32>
%62 = affine.load %50[%arg2, %arg5, %arg6, %arg7] : memref<512x256x3x3xf32>
%63 = affine.load %20[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %20[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
%59 = affine.load %20[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %19[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
}
}
}
}
%51 = "krnl.global"() {name = "arith.constant_8", offset = 11655936 : i64, shape = [512, 512, 3, 3]} : () -> memref<512x512x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 6 {
affine.for %arg4 = 0 to 6 {
affine.store %cst_0, %18[%arg1, %arg2, %arg3, %arg4] : memref<1x512x6x6xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %19[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
affine.store %61, %18[%arg1, %arg2, %59, %60] : memref<1x512x6x6xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
affine.store %cst_0, %17[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
affine.for %arg5 = 0 to 512 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %18[%arg1, %arg5, %59, %60] : memref<1x512x6x6xf32>
%62 = affine.load %51[%arg2, %arg5, %arg6, %arg7] : memref<512x512x3x3xf32>
%63 = affine.load %17[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %17[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
%59 = affine.load %17[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %16[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
}
}
}
}
%52 = "krnl.global"() {name = "arith.constant_9", offset = 21093120 : i64, shape = [512, 512, 3, 3]} : () -> memref<512x512x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 6 {
affine.for %arg4 = 0 to 6 {
affine.store %cst_0, %15[%arg1, %arg2, %arg3, %arg4] : memref<1x512x6x6xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %16[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
affine.store %61, %15[%arg1, %arg2, %59, %60] : memref<1x512x6x6xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
affine.store %cst_0, %14[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
affine.for %arg5 = 0 to 512 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map9(%arg3, %arg6)
%60 = affine.apply #map9(%arg4, %arg7)
%61 = affine.load %15[%arg1, %arg5, %59, %60] : memref<1x512x6x6xf32>
%62 = affine.load %52[%arg2, %arg5, %arg6, %arg7] : memref<512x512x3x3xf32>
%63 = affine.load %14[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %14[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
%59 = affine.load %14[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %13[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
}
}
}
}
%53 = "krnl.global"() {name = "arith.constant_10", offset = 30530304 : i64, shape = [512, 512, 3, 3]} : () -> memref<512x512x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
affine.store %cst_0, %12[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %13[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
affine.store %61, %12[%arg1, %arg2, %59, %60] : memref<1x512x4x4xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
affine.store %cst_0, %11[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
affine.for %arg5 = 0 to 512 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %12[%arg1, %arg5, %59, %60] : memref<1x512x4x4xf32>
%62 = affine.load %53[%arg2, %arg5, %arg6, %arg7] : memref<512x512x3x3xf32>
%63 = affine.load %11[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %11[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
%59 = affine.load %11[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %10[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
}
}
}
}
%54 = "krnl.global"() {name = "arith.constant_11", offset = 39967488 : i64, shape = [512, 512, 3, 3]} : () -> memref<512x512x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
affine.store %cst_0, %9[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %10[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
affine.store %61, %9[%arg1, %arg2, %59, %60] : memref<1x512x4x4xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
affine.store %cst_0, %8[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
affine.for %arg5 = 0 to 512 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map7(%arg3, %arg6)
%60 = affine.apply #map7(%arg4, %arg7)
%61 = affine.load %9[%arg1, %arg5, %59, %60] : memref<1x512x4x4xf32>
%62 = affine.load %54[%arg2, %arg5, %arg6, %arg7] : memref<512x512x3x3xf32>
%63 = affine.load %8[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %8[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
%59 = affine.load %8[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %7[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
}
}
}
}
%55 = "krnl.global"() {name = "arith.constant_12", offset = 49404672 : i64, shape = [512, 512, 3, 3]} : () -> memref<512x512x3x3xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 4 {
affine.for %arg4 = 0 to 4 {
affine.store %cst_0, %6[%arg1, %arg2, %arg3, %arg4] : memref<1x512x4x4xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 2 {
affine.for %arg4 = 0 to 2 {
%59 = affine.apply #map5(%arg3)
%60 = affine.apply #map5(%arg4)
%61 = affine.load %7[%arg1, %arg2, %arg3, %arg4] : memref<1x512x2x2xf32>
affine.store %61, %6[%arg1, %arg2, %59, %60] : memref<1x512x4x4xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 1 {
affine.for %arg4 = 0 to 1 {
affine.store %cst_0, %5[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
affine.for %arg5 = 0 to 512 {
affine.for %arg6 = 0 to 3 {
affine.for %arg7 = 0 to 3 {
%59 = affine.apply #map9(%arg3, %arg6)
%60 = affine.apply #map9(%arg4, %arg7)
%61 = affine.load %6[%arg1, %arg5, %59, %60] : memref<1x512x4x4xf32>
%62 = affine.load %55[%arg2, %arg5, %arg6, %arg7] : memref<512x512x3x3xf32>
%63 = affine.load %5[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
%64 = arith.mulf %61, %62 : f32
%65 = arith.addf %63, %64 : f32
affine.store %65, %5[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
}
}
}
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 1 {
affine.for %arg4 = 0 to 1 {
%59 = affine.load %5[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
%60 = arith.cmpf "olt", %59, %cst_0 : f32
%61 = select %60, %cst_0, %59 : f32
affine.store %61, %4[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 1 {
affine.for %arg4 = 0 to 1 {
affine.store %cst_0, %3[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 1 {
affine.for %arg4 = 0 to 1 {
%59 = affine.load %4[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
%60 = affine.load %3[%arg1, %arg2, %c0, %c0] : memref<1x512x1x1xf32>
%61 = arith.addf %60, %59 : f32
affine.store %61, %3[%arg1, %arg2, %c0, %c0] : memref<1x512x1x1xf32>
}
}
}
}
%56 = arith.uitofp %c1_i64 : i64 to f32
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 1 {
affine.for %arg4 = 0 to 1 {
%59 = affine.load %3[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
%60 = arith.divf %59, %56 : f32
affine.store %60, %3[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
}
}
}
}
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 512 {
affine.for %arg3 = 0 to 1 {
affine.for %arg4 = 0 to 1 {
%59 = affine.load %3[%arg1, %arg2, %arg3, %arg4] : memref<1x512x1x1xf32>
%60 = affine.apply #map20(%arg2, %arg3, %arg4)[%c512, %c1, %c1]
affine.store %59, %2[%arg1, %60] : memref<1x512xf32>
}
}
}
}
%57 = "krnl.global"() {name = "arith.constant_13", offset = 58841856 : i64, shape = [10, 512]} : () -> memref<10x512xf32>
%58 = "krnl.global"() {name = "arith.constant_14", offset = 58862336 : i64, shape = [10], value = dense<[-0.0237901043, -0.0245888866, -0.0121503044, 0.0312467664, -0.0380312204, 0.0233059153, -0.0163965411, 0.0233793724, -0.0315366313, 0.0359465145]> : tensor<10xf32>} : () -> memref<10xf32>
affine.for %arg1 = 0 to 1 {
affine.for %arg2 = 0 to 10 {
affine.store %cst_0, %1[%arg1, %arg2] : memref<1x10xf32>
affine.for %arg3 = 0 to 512 {
%64 = affine.load %2[%arg1, %arg3] : memref<1x512xf32>
%65 = affine.load %57[%arg2, %arg3] : memref<10x512xf32>
%66 = affine.load %1[%arg1, %arg2] : memref<1x10xf32>
%67 = arith.mulf %64, %65 : f32
%68 = arith.addf %66, %67 : f32
affine.store %68, %1[%arg1, %arg2] : memref<1x10xf32>
}
%59 = affine.load %1[%arg1, %arg2] : memref<1x10xf32>
%60 = arith.mulf %cst, %59 : f32
%61 = affine.load %58[%arg2] : memref<10xf32>
%62 = arith.mulf %cst, %61 : f32
%63 = arith.addf %60, %62 : f32
affine.store %63, %1[%arg1, %arg2] : memref<1x10xf32>
}
}
memref.dealloc %42 : memref<1x3x34x34xf32>
memref.dealloc %41 : memref<1x64x32x32xf32>
memref.dealloc %40 : memref<1x64x32x32xf32>
memref.dealloc %39 : memref<1x64x34x34xf32>
memref.dealloc %38 : memref<1x64x16x16xf32>
memref.dealloc %37 : memref<1x64x16x16xf32>
memref.dealloc %36 : memref<1x64x18x18xf32>
memref.dealloc %35 : memref<1x128x16x16xf32>
memref.dealloc %34 : memref<1x128x16x16xf32>
memref.dealloc %33 : memref<1x128x18x18xf32>
memref.dealloc %32 : memref<1x128x8x8xf32>
memref.dealloc %31 : memref<1x128x8x8xf32>
memref.dealloc %30 : memref<1x128x10x10xf32>
memref.dealloc %29 : memref<1x256x8x8xf32>
memref.dealloc %28 : memref<1x256x8x8xf32>
memref.dealloc %27 : memref<1x256x10x10xf32>
memref.dealloc %26 : memref<1x256x8x8xf32>
memref.dealloc %25 : memref<1x256x8x8xf32>
memref.dealloc %24 : memref<1x256x10x10xf32>
memref.dealloc %23 : memref<1x256x4x4xf32>
memref.dealloc %22 : memref<1x256x4x4xf32>
memref.dealloc %21 : memref<1x256x6x6xf32>
memref.dealloc %20 : memref<1x512x4x4xf32>
memref.dealloc %19 : memref<1x512x4x4xf32>
memref.dealloc %18 : memref<1x512x6x6xf32>
memref.dealloc %17 : memref<1x512x4x4xf32>
memref.dealloc %16 : memref<1x512x4x4xf32>
memref.dealloc %15 : memref<1x512x6x6xf32>
memref.dealloc %14 : memref<1x512x2x2xf32>
memref.dealloc %13 : memref<1x512x2x2xf32>
memref.dealloc %12 : memref<1x512x4x4xf32>
memref.dealloc %11 : memref<1x512x2x2xf32>
memref.dealloc %10 : memref<1x512x2x2xf32>
memref.dealloc %9 : memref<1x512x4x4xf32>
memref.dealloc %8 : memref<1x512x2x2xf32>
memref.dealloc %7 : memref<1x512x2x2xf32>
memref.dealloc %6 : memref<1x512x4x4xf32>
memref.dealloc %5 : memref<1x512x1x1xf32>
memref.dealloc %4 : memref<1x512x1x1xf32>
memref.dealloc %3 : memref<1x512x1x1xf32>
memref.dealloc %2 : memref<1x512xf32>
return %1 : memref<1x10xf32>
}
"krnl.entry_point"() {func = @main_graph, numInputs = 1 : i32, numOutputs = 1 : i32} : () -> ()
}

3
samples/pytorch/torch-mlir/resnet18/export_resnet18_mlir.py → samples/pytorch/resnet18/export_resnet18_mlir.py
View File

@ -2,10 +2,7 @@ import sys
import torch.nn.functional as F
import torch.nn as nn
import torch
from torch_mlir.dialects.torch.importer.jit_ir import ClassAnnotator, ModuleBuilder
sys.path.append("../../models")
from resnet18 import ResNet18

0
samples/pytorch/models/resnet18.py → samples/pytorch/resnet18/resnet18.py
View File

0
samples/pytorch/onnx-mlir/resnet18/resnet18_base.cpp → samples/pytorch/resnet18/resnet18_base.cpp
View File

0
samples/pytorch/onnx-mlir/resnet18/resnet18_g7l7d.cpp → samples/pytorch/resnet18/resnet18_g7l7d.cpp
View File

0
samples/pytorch/models/vgg16.py → samples/pytorch/vgg16/vgg16.py
View File

0
samples/pytorch/onnx-mlir/vgg16/vgg16_base.cpp → samples/pytorch/vgg16/vgg16_base.cpp
View File

0
samples/pytorch/onnx-mlir/vgg16/vgg16_g7l7d.cpp → samples/pytorch/vgg16/vgg16_g7l7d.cpp
View File