Merge pull request #38 from ROCmSoftwarePlatform/resnet18_fixes

ResNet / Cifar10 demo

src/onnx/CMakeLists.txt

@@ -17,11 +17,15 @@ rocm_clang_tidy_check(read_onnx)
 target_link_libraries(read_onnx migraph_onnx)
 
 
+if(MIGRAPH_ENABLE_GPU)
 add_executable(mnist mnist.cpp)
 rocm_clang_tidy_check(mnist)
-target_link_libraries(mnist migraph_cpu migraph_onnx)
+target_link_libraries(mnist migraph_cpu migraph_gpu migraph_onnx)
+
+add_executable(cifar10 cifar10.cpp)
+rocm_clang_tidy_check(cifar10)
+target_link_libraries(cifar10 migraph_cpu migraph_gpu migraph_onnx)
 
-if(MIGRAPH_ENABLE_GPU)
 add_executable(verify_onnx verify_onnx.cpp)
 rocm_clang_tidy_check(verify_onnx)
 target_link_libraries(verify_onnx migraph_onnx migraph_cpu migraph_gpu)

src/onnx/cifar10.cpp

+#include <cstdio>
+#include <string>
+#include <fstream>
+#include <numeric>
+#include <stdexcept>
+
+#include <migraph/onnx.hpp>
+
+#include <migraph/cpu/cpu_target.hpp>
+#include <migraph/gpu/target.hpp>
+#include <migraph/gpu/hip.hpp>
+#include <migraph/generate.hpp>
+
+#include "softmax.hpp"
+
+auto read_cifar10_images(const std::string& full_path)
+{
+    std::ifstream file(full_path, std::ios::binary);
+
+    const size_t nimages          = 10;
+    const size_t nbytes_per_image = 3072;
+    std::vector<uint8_t> raw_data(nimages * (nbytes_per_image + 1));
+    std::vector<uint8_t> labels(nimages);
+    std::vector<float> data(nimages * nbytes_per_image);
+    if(file.is_open())
+    {
+        file.read(reinterpret_cast<char*>(raw_data.data()),
+                  (nbytes_per_image + 1) * nimages * sizeof(uint8_t));
+        uint8_t* pimage = raw_data.data();
+        for(size_t i = 0; i < nimages; i++, pimage += nbytes_per_image)
+        {
+            labels[i] = *pimage++;
+            for(size_t j = 0; j < nbytes_per_image; j++)
+            {
+                float v                        = *(pimage + j) / 255.0f;
+                data[i * nbytes_per_image + j] = v;
+            }
+        }
+        return std::make_pair(labels, data);
+    }
+    else
+    {
+        throw std::runtime_error("Cannot open file `" + full_path + "`!");
+    }
+}
+
+int main(int argc, char const* argv[])
+{
+    if(argc < 4)
+    {
+        throw std::runtime_error("Usage:  cifar10 [gpu | cpu] <onnx file> <cifar10 data file>");
+    }
+    std::string gpu_cpu  = argv[1];
+    std::string file     = argv[2];
+    std::string datafile = argv[3];
+    auto prog            = migraph::parse_onnx(file);
+    std::cout << prog << std::endl;
+    auto imageset = read_cifar10_images(datafile);
+
+    if(gpu_cpu == "gpu")
+    {
+        // GPU target
+        prog.compile(migraph::gpu::target{});
+        migraph::program::parameter_map m;
+        auto s = migraph::shape{migraph::shape::float_type, {1, 3, 32, 32}};
+        for(auto&& x : prog.get_parameter_shapes())
+        {
+            m[x.first] = migraph::gpu::to_gpu(migraph::generate_argument(x.second));
+        }
+        auto labels = imageset.first;
+        auto input  = imageset.second;
+        auto ptr    = input.data();
+        for(int i = 0; i < 10; i++)
+        {
+            std::cout << "label: " << static_cast<uint32_t>(labels[i]) << "  ---->  ";
+            m["0"]      = migraph::gpu::to_gpu(migraph::argument{s, &ptr[3072 * i]});
+            auto result = migraph::gpu::from_gpu(prog.eval(m));
+            std::vector<float> logits;
+            result.visit([&](auto output) { logits.assign(output.begin(), output.end()); });
+            std::vector<float> probs = softmax<float>(logits);
+            for(auto x : probs)
+                std::cout << x << "    ";
+            std::cout << std::endl << std::endl;
+        }
+    }
+    else
+    {
+        // CPU target
+        prog.compile(migraph::cpu::cpu_target{});
+        auto s      = migraph::shape{migraph::shape::float_type, {1, 3, 32, 32}};
+        auto labels = imageset.first;
+        auto input  = imageset.second;
+        auto ptr    = input.data();
+        for(int i = 0; i < 10; i++)
+        {
+            std::cout << "label: " << static_cast<uint32_t>(labels[i]) << "  ---->  ";
+            auto input3 = migraph::argument{s, &ptr[3072 * i]};
+            auto result = prog.eval({{"0", input3}});
+            std::vector<float> logits;
+            result.visit([&](auto output) { logits.assign(output.begin(), output.end()); });
+            std::vector<float> probs = softmax<float>(logits);
+            for(auto x : probs)
+                std::cout << x << "    ";
+            std::cout << std::endl;
+        }
+    }
+}

src/onnx/mnist.cpp

@@ -6,9 +6,12 @@
 
 #include <migraph/onnx.hpp>
 
-#include <migraph/cpu/cpu_target.hpp>
+#include <migraph/gpu/target.hpp>
+#include <migraph/gpu/hip.hpp>
 #include <migraph/generate.hpp>
 
+#include "softmax.hpp"
+
 auto reverse_int(unsigned int i)
 {
     unsigned char c1, c2, c3, c4;
@@ -97,16 +100,6 @@ std::vector<int32_t> read_mnist_labels(const std::string& full_path, int& number
     }
 }
 
-std::vector<float> softmax(std::vector<float> p)
-{
-    size_t n = p.size();
-    std::vector<float> result(n);
-    std::transform(p.begin(), p.end(), result.begin(), [](auto x) { return std::exp(x); });
-    float s = std::accumulate(result.begin(), result.end(), 0.0f, std::plus<float>());
-    std::transform(result.begin(), result.end(), result.begin(), [=](auto x) { return x / s; });
-    return result;
-}
-
 int main(int argc, char const* argv[])
 {
     if(argc > 3)
@@ -121,15 +114,19 @@ int main(int argc, char const* argv[])
 
         std::string file = argv[1];
         auto prog        = migraph::parse_onnx(file);
-        prog.compile(migraph::cpu::cpu_target{});
+        std::cout << prog << std::endl << std::endl;
+        prog.compile(migraph::gpu::target{});
         auto s = migraph::shape{migraph::shape::float_type, {1, 1, 28, 28}};
         std::cout << s << std::endl;
         auto ptr = input.data();
+        migraph::program::parameter_map m;
+        m["output"] =
+            migraph::gpu::to_gpu(migraph::generate_argument(prog.get_parameter_shape("output")));
         for(int i = 0; i < 20; i++)
         {
             std::cout << "label: " << labels[i] << "  ---->  ";
-            auto input3 = migraph::argument{s, &ptr[784 * i]};
-            auto result = prog.eval({{"Input3", input3}});
+            m["0"]      = migraph::gpu::to_gpu(migraph::argument{s, &ptr[784 * i]});
+            auto result = migraph::gpu::from_gpu(prog.eval(m));
             std::vector<float> logits;
             result.visit([&](auto output) { logits.assign(output.begin(), output.end()); });
             std::vector<float> probs = softmax(logits);

src/onnx/onnx.cpp

@@ -234,7 +234,7 @@ struct onnx_parser
         }
         if(contains(attributes, "momentum"))
         {
-            epsilon = parse_value(attributes.at("momentum")).at<float>();
+            momentum = parse_value(attributes.at("momentum")).at<float>();
         }
         if(contains(attributes, "is_test"))
         {

src/onnx/softmax.hpp

+#include <vector>
+#include <algorithm>
+#include <cmath>
+
+template <typename T>
+std::vector<T> softmax(const std::vector<T>& p)
+{
+    size_t n = p.size();
+    std::vector<T> result(n);
+    std::transform(p.begin(), p.end(), result.begin(), [](auto x) { return std::exp(x); });
+    T s = std::accumulate(result.begin(), result.end(), 0.0f, std::plus<T>());
+    std::transform(result.begin(), result.end(), result.begin(), [=](auto x) { return x / s; });
+    return result;
+}