def check_fwd(model, tensor):
device = torch_mlir.mlir_device()
result = model(tensor)
device_model = copy.deepcopy(model).to(device)
device_tensor = tensor.clone().to(device)
device_result = device_model(device_tensor)
compare(result, device_result, "fwd")
return (device_model, device_result, result)
def main():
test_status = "PASS!"
# CHECK-LABEL: test_op_report_vgg_style_lenet
# CHECK: PASS!
print("test_op_report_vgg_style_lenet")
device = torch_mlir.mlir_device()
model = Net().to(device)
ref_tensor = torch.randn((8, 1, 30, 30))
tensor = ref_tensor.clone().to(device)
result = model(tensor)
target = torch.ones((8), dtype=torch.long).to(device)
loss = F.nll_loss(result, target)
loss.backward()
mlir0 = torch_mlir.get_mlir(model.conv1.weight.grad)
print(mlir0)
report = torch_mlir.op_report(mlir0)
print(report)
report_dict = report
expected = 32
if (len(report_dict) != expected):
print("### ERROR: Expecting", expected,
"items in the report, but got ", len(report_dict))
test_status = "FAIL!"
# Every item should have a read and a write
for key, value in report_dict.items():
if not 'reads' in value:
print(
f"### ERROR: {key} does not contain the required reads field")
test_status = "FAIL!"
if not 'writes' in value:
print(
f"### ERROR: {key} does not contain the required writes field")
test_status = "FAIL!"
if "convolution" in key:
if not 'ops:MAC' in value:
print(
f"### ERROR: convolution {key} does not contain the required MAC field"
)
test_status = "FAIL!"
if "mm" in key:
if not 'ops:MAC' in value:
print(
f"### ERROR: mm {key} does not contain the required MAC field"
)
test_status = "FAIL!"
print(test_status)
def check_back(fwd_path, target, lossmodel):
device = torch_mlir.mlir_device()
(device_model, device_result, result) = fwd_path
device_target = target.clone().to(device)
ref_loss = lossmodel(result, target)
ref_loss.backward()
device_loss = lossmodel(device_result, device_target)
device_loss.backward()
compare(ref_loss, device_loss, "back")
return (device_model, device_result)
def main():
device = torch_mlir.mlir_device()
model = Net()
tensor = torch.randn((64, 1, 28, 28), requires_grad=True)
# CHECK: PASS! fwd check
fwd_path = test.check_ref(model, tensor)
target = torch.ones((64), dtype=torch.long)
loss = F.nll_loss
# CHECK: PASS! back check
test.check_back(fwd_path, target, loss)
# CHECK: PASS! fc1_weight_grad check
test.compare(model.fc1.weight.grad, fwd_path[0].fc1.weight.grad,
"fc1_weight_grad")
def test_ResA_16(self):
dev = torch_mlir.mlir_device()
model = ResA(16).to(dev)
passed = self._test_model(model,
torch.ones((1, 16, 128, 128), device=dev))
# CHECK-LABEL: test_ResA_16
# CHECK: [[V0:%[a-zA-Z0-9]+]], %{{.*}}, %{{.*}} = "aten.native_batch_norm"({{.*}}) {layer_name = "L0-native_batch_norm-0"}
# CHECK: [[V1:%[a-zA-Z0-9]+]] = "aten.relu"([[V0]]) {layer_name = "L1-relu-0"}
# CHECK: [[V2:%[a-zA-Z0-9]+]] = "aten.convolution_overrideable"([[V1]], {{.*}}) {layer_name = "L2-convolution_overrideable-0"}
# CHECK: [[V3:%[a-zA-Z0-9_]+]], %{{.*}}, %{{.*}} = "aten.native_batch_norm"([[V2]]{{.*}}) {layer_name = "L3-native_batch_norm-1"}
# CHECK: [[V4:%[a-zA-Z0-9]+]] = "aten.relu"([[V3]]) {layer_name = "L4-relu-1"}
# CHECK: [[V5:%[a-zA-Z0-9]+]] = "aten.convolution_overrideable"([[V4]],{{.*}}) {layer_name = "L5-convolution_overrideable-1"}
# CHECK: [[V6:%[a-zA-Z0-9_]+]], %{{.*}}, %{{.*}} = "aten.native_batch_norm"([[V5]],{{.*}}) {layer_name = "L6-native_batch_norm-2"}
# CHECK: [[V7:%[a-zA-Z0-9]+]] = "aten.relu"([[V6]]) {layer_name = "L7-relu-2"}
# CHECK: [[V8:%[a-zA-Z0-9]+]] = "aten.convolution_overrideable"([[V7]],{{.*}}) {layer_name = "L8-convolution_overrideable-2"}
# CHECK: {{.*}} = "aten.add"(%arg0, [[V8]], {{.*}}) {layer_name = "L9-add-0"}
self.assertTrue(passed)
# -*- Python -*-
# This file is licensed under a pytorch-style license
# See frontends/pytorch/LICENSE for license information.
import torch
import npcomp.frontends.pytorch as torch_mlir
import npcomp.frontends.pytorch.test as test
# RUN: python %s | FileCheck %s
dev = torch_mlir.mlir_device()
t0 = torch.randn((4, 16, 4), device=dev)
t1 = torch.randn((4, 16, 4), device=dev)
t3 = torch.randn((4, 64), device=dev)
t4 = torch.randn((4, 64), device=dev)
t2 = t0 + t1
t5 = t3 + t4
t6 = t5.view((4, 4, 4, 4))
t7 = t2.view((4, 4, 4, 4))
t8 = t6 + t7
t0_cpu = t0.to('cpu')
t1_cpu = t1.to('cpu')
# CHECK: PASS! add_views_0 check
test.compare(t2, t0_cpu + t1_cpu, "add_views_0")
