identifikasi daging babi dan sapi

By | April 16, 2022
Print Friendly, PDF & Email
264 Views

Identification of beef and pork- identifikasi daging babi dan sapi ada banyak teknik yang digunakan, salah satunya merujuk paper Identification of beef and pork using gray level cooccurrence matrix and probabilistic neural network (Clarita Magdalena, 2021). Disitu dijelaskan metode yang digunakan yaitu GLCM – gray level coocurance matrix, pembahasan mengenai bisa kalian bisa  Ciri Fitur dengan GLCM – Gray Level Coocurance Matrix

Dalam abstrak dijelaskan mengenai Desain/metode/pendekatan yaitu penerapan GLCM (sebagai ciri fitur) dan discrimator nya menggunakan  Probabilistic Neural Network untuk melakukan klasifikasi. Adapun Hasil yang didapat dari pengujian dengan validasi silang k-fold dan confussion matrix ini menunjukkan bahwa ekstraksi fitur Gray Level Co-Occurrence Matrix dan Probabilistic Neural Network Classifier mendapatkan rata-rata akurasi 87%, presisi 83%, dan recall 90%.

Judul tersebut membuat kami mencoba untuk melakukan teknik Deep Learning yaitu ciri fitur yang semula menggunakan GLCM akan digantikan dengan Convolution Neural Network dengan jenis Mengenal Arsitektur LeNet serta menggunakan loss function berupa Cara menggunakan loss function Negative log likelihood loss nn.NLLLoss

Batasan masalah disini yaitu untuk Identification of beef and pork tanpa dicampur/di mixing walaupun dalam kasus realnya pasti antara daging sapi dan babi akan dicampur untuk menyamparkan daging babi yang harganya lebih murah. Karena keterbatasan dataset yang ada di kaggle tersedia hanya daging tanpa dicampur.

Dataset

Dataset untuk Identification of beef and pork, kami peroleh di kaggle.com yang disimpan pada folder train yaitu sapi dan babi. Untuk mempermudah seragam data, dimension yang digunakan untuk LeNet yaitu 100 x 100 dalam mode grayscale

def TransformKu():
    transform = transforms.Compose([                    
            transforms.Resize((100,100)),
            transforms.RandomRotation(10),
            transforms.ToTensor(),
            transforms.Grayscale(),
            transforms.Normalize((0.5),(0.5),(0.5))])
    return transform

Mengingat serat setiap daging itu berbeda-beda maka agar tahan terhadap arah sudut perlu kita buat random rotate.

See also  Belajar Algoritma Multi Layer Percepton

Persiapan dataset

Untuk persiapan dataset serta mempercepat proses loading dataset menjadi trainloader, saya pakai imagefolder saja dariapda membuat class turunan dari dataset. Kalian bisa baca Membuat Dataset untuk Training Deep Learning disitu ada 2 cara yang digunakan.

transform = TransformKu()

#cara pertama
train_path = 'train'
dataset = datasets.ImageFolder(train_path,transform=transform)

Arsitektur LeNet

Arsitektur LeNet dipilih karena sederhana dan tidak butuh banyak komputasi. Perlu penyesuaian sedikit karena kita desain itu untuk ukuran 28×28 dan diubah untuk 100 x 100. Adapun untuk convolutional bisa dijabarkan berikut

ada 2 tahap convolutional yaitu

  • x = self.conv1(x)
  • x = self.act(x)
  • x = self.pool(x)

tahap convolutional kedua yaitu

  • x = self.conv2(x)
  • x = self.act(x)
  • x = self.pool(x)

Langkah selanjutnya dimasukan ke MLP terdiri dari 3 layer yang setiap layer dihubungkan dengan fungsi aktifasi bertipe ReLU

  • x = self.L1(x)
    • x = self.act(x)
  • x = self.L2(x)
    • x = self.act(x)
  • x = self.L3(x)
    • x = self.Log(x)

terakhir akan dimasukan ke nn.LogSoftmax(dim=1) karena kita menggunakan loss_fn = torch.nn.NLLLoss() jadi nanti outputnya itu ada 2 paramater dengan class 1: babi, dan class 2: sapi. Berikut detail dari arsitekturnya

class ModelLeNet(nn.Module):
    def __init__(self):
        super(ModelLeNet,self).__init__()
        #Here, we are plementing those layers which are having learnable parameters.
        #Start implementation of Layer 1 (C1) which has 6 kernels of size 5x5 with padding 0 and stride 1
        
        self.conv1 = nn.Conv2d(in_channels=1,out_channels=6,kernel_size=(5,5))
        
        #Start implementation of Layer 3 (C3) which has 16 kernels of size 5x5 with padding 0 and stride 1
        
        self.conv2 = nn.Conv2d(in_channels = 6, out_channels = 16,kernel_size = (5,5))
        
        #Start implementation of Layer 5 (C5) which is basically flattening the data 
            
        #self.L1 = nn.Linear(256, 120) #untuk ukuran 28*28        
        #self.L1 = nn.Linear(400, 120) #untuk ukuran 32*32
        self.L1 = nn.Linear(16*22*22, 120) #untuk ukuran 100*100
        
        
        #Start implementation of Layer 6 (F6) which has 85 Linear Neurons and input of 120
        
        self.L2 = nn.Linear(120,84)
        
        #Start implementation of Layer 7 (F7) which has 10 Linear Neurons and input of 84
        
        self.L3 = nn.Linear(84,2) #artinya 2 output
        
        #We have used pooling of size 2 and stride 2 in this architecture 
        
        self.pool = nn.AvgPool2d(kernel_size = 2, stride = 2)
        
        #We have used tanh as an activation function in this architecture so we will use tanh at all layers excluding F7.
        self.act = nn.ReLU()        
        self.Log = nn.LogSoftmax(dim=1)
        
    #Now we will implement forward function to produce entire flow of the architecture.
    
    def forward(self,x):
        x = self.conv1(x)
        #We have used tanh as an activation function in this architecture so we will use tanh at all layers excluding F7.
        x = self.act(x)
        #Now this will be passed from pooling 
        x = self.pool(x)
        #Next stage is convolution
        x = self.conv2(x)
        x = self.act(x)
        x = self.pool(x)
        #next we will pass from conv3, here we will not pass data from pooling as per Architecture 
        # print(x.shape)
        
        #Now the data should be flaten and it would be passed from FC layers. 
        x = x.view(x.size()[0], -1)
        # print(x.shape)
        x = self.L1(x)
        x = self.act(x)
        x = self.L2(x)
        x = self.act(x)
        x = self.L3(x)
        x = self.Log(x)
        
        return x

Saya kira untuk Identification of beef and pork sudah lebih dari cukup. Setelah semuanya sudah siap, kita persiapkan dataset loader yaitu jumlah batch dan shuffle (bila ingin random ditukar urutannya). Data training juga digunakan untuk testing

batch_size = 4
shuffle = True
pin_memory = False
num_workers = 0


train_loader = DataLoader(dataset=dataset, shuffle=shuffle, batch_size=batch_size,num_workers=num_workers,pin_memory=pin_memory)
test_loader = DataLoader(dataset=dataset, shuffle=shuffle, batch_size=batch_size,num_workers=num_workers,pin_memory=pin_memory)

Untuk minimal accuracy yaitu 98% berikut aturan lebih lanjut

model = ModelLeNet()
learning_rate = 0.001
optimizer = optim.Adam(model.parameters(),lr=learning_rate)
loss_fn = torch.nn.NLLLoss()

minimal_accuracy =  torch.tensor([0.98])

Untuk mengetahui jumlah waktu yang diperlukan kita butuh tic() dan toc() sebagai timmer serta melakukan ploting hasil accuracy tiap epoch

list_accuracy = list()
tic()
for epoch in range(100):    
    model.train()       
    for i, batch_train in enumerate(train_loader,0):
        input_train,target_train = batch_train
        prediksi_train = model(input_train)
        loss_train = loss_fn(prediksi_train,target_train)
        loss_train.backward()
        optimizer.step()
        optimizer.zero_grad()        
        i = i+1
    total_betul = torch.tensor([0])
    #valuasi model
    for i, batch_test in enumerate(test_loader,0):        
        model.eval()
        input_test,target_test = batch_test
        prediksi_test = model(input_test)
        prediksi_test = torch.argmax(prediksi_test,dim=1)
        total_betul = total_betul+torch.sum(prediksi_test==target_test)
    accuracy = total_betul/len(dataset)
    list_accuracy.append({'acc':accuracy.detach().numpy()[0]})
    print('epoch',epoch, accuracy)
    if accuracy>=minimal_accuracy:        
        break
   
        
print(toc())   
list_accuracy = pd.DataFrame(list_accuracy)
list_accuracy['acc'].plot()

Berikut hasil diperoleh Identification of beef and pork dengan CNN dengan waktu 37 detik

epoch 0 tensor([0.6400])
epoch 1 tensor([0.7400])
epoch 2 tensor([0.6800])
epoch 3 tensor([0.8000])
epoch 4 tensor([0.7800])
epoch 5 tensor([0.8600])
epoch 6 tensor([0.8000])
epoch 7 tensor([0.8400])
epoch 8 tensor([0.9600])
epoch 9 tensor([1.])
37.24626220000209

 

See also  Teknik Segmentasi Pelanggan

Dari proses diatas dengan target 100 epoch tercapai pada epoch ke 10 (karena dimulai dari angka 0) setiap epoch arsitektur LeNet mampu melakukan perbaikan secara increment

Berikut tampilan hasil proses Identification of beef and pork

Bila dilihat secara umum serat tekstur antara sapi (lembut) dan babi (kasar). Tulisan ini hanya sebagai inspirasi saja bila kalian ingin riset yang serius tentu butuh banyak dataset atau bahkan akan mengembakan alat yang dapat membaca campuran daging tersebut??

Leave a Reply

Your email address will not be published.




Enter Captcha Here :