Bagaimana mengubah model PyTorch menjadi ONNX

By | June 18, 2023
Print Friendly, PDF & Email
411 Views

Sebuah rangka kerja pembelajaran mesin dalam adalah perpustakaan atau alat yang memungkinkan praktisi pembelajaran mesin untuk membangun model pembelajaran mesin secara cepat dan mudah. Bersama dengan ledakan jumlah dan kemampuan aplikasi DL, juga terjadi peningkatan rangka kerja pembelajaran mesin. Beberapa rangka kerja pembelajaran mesin yang paling umum meliputi PyTorch, TensorFlow, MXNet, Cafe, dan Keras. Meskipun keragaman pilihan rangka kerja untuk komunitas AI bukan hal buruk, ini dapat menyebabkan masalah lain.

Tidak semua rangka kerja cocok untuk setiap perangkat keras. Ini berarti bahwa rangka kerja yang kita pilih untuk membangun model harus sesuai dengan perangkat keras tersebut. Jika tidak, kita harus melalui proses ribet mengubah model kita ke rangka kerja lain. Bertukar dari satu rangka kerja ke yang lain (yang sering kali diperlukan) merupakan tantangan karena mereka memiliki operasi dan tipe data yang berbeda.

Standar Terbuka untuk Interoperabilitas ML

ONNX, singkatan dari Open Neural Network Exchange, adalah sebuah kerangka sumber terbuka standar yang memungkinkan para pengembang untuk memindahkan model pembelajaran mesin dari berbagai kerangka ke ONNX. Interoperabilitas ini memungkinkan pengembang untuk dengan mudah berpindah antar berbagai kerangka pembelajaran mesin.

ONNX mendukung semua kerangka pembelajaran mesin populer termasuk Keras, TensorFlow, Scikit-learn, PyTorch, dan XGBoost. ONNX juga memungkinkan vendor produk hardware yang ditujukan untuk mempercepat pembelajaran mesin untuk berfokus pada satu representasi grafik ONNX.

ONNX mencegah pengembang terjebak pada kerangka pembelajaran mesin tertentu dengan menyediakan alat yang membuat mudah untuk berpindah dari satu kerangka ke yang lain. ONNX melakukan ini dengan cara berikut:

  1. Mendefinisikan grafik komputasi yang dapat diperluas – Awalnya, berbagai kerangka akan memiliki representasi grafik yang berbeda. ONNX menyediakan representasi grafik standar untuk semuanya. Grafik ONNX mewakili grafik model melalui berbagai node komputasi dan dapat dilihat menggunakan alat seperti Netron.
  2. Membuat tipe data standar – Setiap node dalam grafik biasanya memiliki tipe data tertentu. Untuk menyediakan interoperabilitas antar berbagai kerangka, ONNX mendefinisikan tipe data standar termasuk int8, int16, dan float16, hanya untuk sebagian.
  3. Operator built-in – Operator ini bertanggung jawab untuk memetakan tipe operator dalam ONNX ke kerangka yang diperlukan. Jika Anda mengubah model PyTorch ke ONNX, semua operator PyTorch diterjemahkan ke operator yang terkait dalam ONNX. Misalnya, operasi sigmoid PyTorch akan dikonversi menjadi operasi sigmoid yang sesuai dalam ONNX.
  4. Penyediaan format file tunggal – Setiap perpustakaan pembelajaran mesin memiliki format file sendiri. Misalnya, model Keras dapat disimpan dengan ekstensi h5, PyTorch sebagai pt, dan model scikit-learn sebagai file pickle. ONNX menyediakan standar tunggal untuk menyimpan dan mengekspor file model. Format tersebut adalah ekstensi file `onnx’
See also  #Video Tutorial - Belajar Python Bagian 5

ONNX juga mempermudah optimasi model pembelajaran mesin dengan menggunakan runtime yang kompatibel dengan ONNX dan alat yang dapat meningkatkan performa model pada perangkat keras yang berbeda. Sekarang kita mengerti apa itu ONNX, mari kita lihat bagaimana mengkonversi model PyTorch ke ONNX. Misalkan kita punya model sederhana berikut ini

import torch
import torch.nn as nn

x = torch.tensor([[1,1],[1,0],[0,1],[0,0]],dtype=torch.float)
y = torch.tensor([[1],[1],[1],[0]],dtype=torch.float)


class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(2,10)
        self.layer2 = nn.Linear(10,5)
        self.layer3 = nn.Linear(5,1)
        self.sigmoid = nn.Sigmoid()
    def forward(self,x):
        x = self.layer1(x)
        x = self.sigmoid(x)
        x = self.layer2(x)
        x = self.sigmoid(x)
        x = self.layer3(x)
        x = self.sigmoid(x)
        return x
    
model = Model()
optimizer = torch.optim.Adam(model.parameters(),lr=0.01)
loss_function = nn.MSELoss()

loss_epoch = list()
for i in range(0,1000):
    optimizer.zero_grad()
    prediksi = model(x)
    loss = loss_function(prediksi,y)
    loss.backward()
    optimizer.step()
    loss_epoch.append(loss.item())
    if (i%100)==0:
        print("epoch \t",i,"\t",loss.item())

Convert Pytorch Model ke ONNX

Sekarang kita akan melakukan convert model pytorch ke ONXX

input_names = [ "actual_input" ]
output_names = [ "output" ]

dummy_input = torch.tensor([[1,0]],dtype=torch.float)
torch.onnx.export(model,
                 dummy_input,
                 "model boolean and.onnx",
                 verbose=False,
                 input_names=input_names,
                 output_names=output_names,
                 export_params=True,
                 )

Visualisasi Model dengan Netron

Untuk visualisasi model, kalian bisa menggunakan netron https://netron.app/

Menggunakan ONNX

Sedangkan untuk menggunakan onnx yaitu

import numpy as np
import onnxruntime as ort

ort_session = ort.InferenceSession("model boolean and.onnx")

outputs = ort_session.run(
    None,
    {"actual_input": np.array([[0,0]]).astype(np.float32)},
)
print(outputs[0])

ONNX menggunakan Java

Salah satu keunggulan ONNX yaitu bisa dipakai menggunakan bahasa yang lain, misalkan dalam bahasa java. Berikut ketika menggunakan gradle java, dengan menambahkan kode berikut pada build.gradle

// This dependency is used by the application.
implementation 'com.google.guava:guava:30.1.1-jre'
implementation 'com.microsoft.onnxruntime:onnxruntime:1.13.1'

contoh penerapannya yaitu

/*
 * This Java source file was generated by the Gradle 'init' task.
 */
package gradleproject1;

import ai.onnxruntime.OnnxTensor;
import ai.onnxruntime.OrtEnvironment;
import ai.onnxruntime.OrtException;
import ai.onnxruntime.OrtSession;
import java.util.Map;

public class App {
    public static void main(String[] args) throws OrtException {
        
        var env = OrtEnvironment.getEnvironment();
        var session = env.createSession("D:/model boolean and.onnx",new OrtSession.SessionOptions());
        float[][] sourceArray = new float[1][2];  // assume your data is loaded into a float array 
        sourceArray[0][0] = 1;
        sourceArray[0][1] = 1;
        var tensorFromArray = OnnxTensor.createTensor(env,sourceArray);
        var inputs = Map.of("actual_input",tensorFromArray);
        try (var results = session.run(inputs)) {
            // manipulate the results
            
            //float [] buffer = (float[]) inputs.get("actual_input").getFloatBuffer().array();
            float [][] hasil = (float[][]) results.get("output").get().getValue();
            int endl = 0;
        }


    }
}

Visualisasi Model yang lain seperti AlexNet

Untuk visualisasi model ada banyak kok, seperti di http://alexlenail.me/NN-SVG/LeNet.html

See also  Integrasi Machine Learning API WEKA dengan Java

 

 

 

Leave a Reply