Ethereum, yang merupakan jaringan terbesar kedua setelah Bitcoin, saat ini merupakan ekosistem paling populer untuk membangun aplikasi blockchain. Maka dari itu, belajar Ethereum ibarat memegang kunci masuk ke berbagai blockchain lain yang kompatibel dengannya, khususnya yang menggunakan runtime EVM.

Transaksi di Ethereum

Jika kita bedah lebih dalam. Pada dasarnya suatu transaksi di dalam blockchain ethereum melalui tahapan berikut:

1. Pembuatan transaksi.

2. Penandatanganan transaksi (signature membuktikan otoritas).

3. Transaksi disiarkan ke jaringan.

4. Transaksi masuk ke mempool (antrian).

5. Pengecekan oleh validator (apakah signature valid dan saldo cukup).

6. Transaksi masuk ke blok (block inclusion).

Setiap transaksi di Ethereum memerlukan biaya yang disebut dengan gas. Besaran gas ini dikalikan dengan harga gas (ditentukan pasar berdasarkan supply dan demand) untuk menghasilkan biaya transaksi.

Smart Contract

Kemudian ada smart contract, yaitu suatu program yang berjalan di jaringan blockchain. Karakteristik dari smart contract antara lain:

• Self-executing: bisa berjalan sendiri ketika triggernya dipenuhi.

• Immutable: setelah di-deploy ke dalam jaringan, datanya tidak bisa diubah sama sekali.

• Deterministic: input yang sama akan menghasilkan output yang sama di semua node.

• Transparent: bisa dicek oleh siapa saja.

Inilah yang menghilangkan peran middleman. Meskipun juga di sisi lain menimbulkan tantangan baru. Misalnya kalau ada bug ditemukan, tidak ada cara mudah untuk memperbaikinya. Oleh karena itu, sangat penting agar sebelum di deploy, smart contract perlu melalui rangkaian tes ketat agar bisa dipastikan keamanannya. Dari sini juga lahirlah kebutuhan akan profesi seperti smart contract auditor.

Aplikasi Terdesentralisasi (Decentralized Application / dApp)

Sumber Gambar: wikimedia

Istilah lain yang akan familiar ketika kita mulai belajar blockchain adalah Aplikasi Terdesentralisasi (Decentralized Application / dApp). Kalau dianalogikan vending machine, smart contract ibarat mesin di dalamnynya, dan dApp ibarat fisik mesin yang berinteraksi dengan pembeli.

Pada dasarnya, dApp adalah aplikasi frontend yang sama seperti aplikasi web pada umumnya. Akan tetapi ada unsur backend yang digantikan dengan smart contract on-chain. Keberadaan dApp lah yang menjadi jembatan interaksi blockchain dengan pengguna casual.

Manfaat integrasi blockchain yang terdapat pada dApp adalah transparansi yang lebih baik karena state-state penting tersimpan dengan baik di blockchain dan bisa dilihat siapa saja. Pada umumnya, suatu dApp setidaknya memiliki komponen berikut:

• Frontend: UI/UX seperti biasa (misalnya React/Vue). Tugasnya memanggil fungsi smart contract dan menampilkan data on-chain.

• Wallet (MetaMask, RabbyWallet, Phantom dll): bertugas menandatangani transaksi/permintaan (signature), memastikan user benar-benar menyetujui aksi yang dilakukan.

• Provider / RPC node: Provider ini adalah layanan yang menerima RPC JSON calls dari frontend dan meneruskannya ke jaringan. Contoh providernya antara lain Infura, Alchemy, QuickNode.

• Smart contract: kode otomatis yang mengeksekusi kode-kode on-chain (transfer token, update state, dsb)

Tantangan dApp

Karena terkoneksi dengan blockchain, maka otomatis juga dApp akan berkutat dengan tantangan-tantangan yang ada di teknologi blockchain pada umumnya. Misalnya dari masalah gas, otomatis user harus paham konsekuensi bahwa ada biaya dari aktivitas mereka. Kemudian untuk terkoneksi juga perlu memiliki wallet beserta addressnya. Lalu ada juga masalah latensi yang mungkin bisa terjadi ketika jaringan blockchain sedang padat-padatnya.

Blockchain pada dApp memang sebagian berfungsi sebagai penyimpanan data. Tapi bagaimana kalau datanya besar seperti gambar dan video?

Untuk kasus seperti ini, penyimpanan on chain tidak cocok karena akan memakan biaya yang sangat mahal. Sehingga praktik yang umum adalah menyimpan file di ipfs dan yang dicatat di blockchain hanyalah Content Identifier (CID) saja.

Selain itu, jika sebuah dApp hanya mengandalkan provider tertentu (misalnya Infura), maka ada risiko sentralisasi. Solusi bagi developer adalah menyediakan fallback provider, atau bahkan menjalankan node sendiri, meski hal ini akan butuh biaya dan tenaga lebih.

Penutup

Jika dari sudut pandang awam. Mungkin banyak orang mengira bahwa teknologi blockchain hanya berkaitan dengan membuat koin baru. Padahal, saat ini yang menjadi inti pengembangan Web3 adalah dApp.

Blockchain adalah fondasi teknologinya.
Smart contract adalah mesinnya.
Dan dApp adalah wajah yang berinteraksi langsung dengan kita.

Artikel ini berdasarkan catatan pembelajaran dari sesi kedua blockchain developer bootcamp di Pelita Bangsa Academy.

English Version: https://medium.com/p/994f340352ee

Agar bisa paham perlahan, mari kita kembali dari pertanyaan dasar.

Kenapa blockchain perlu ada?

Kita coba melihat ke dalam hal-hal yang ada sekarang di sekitar kita. Bank dengan segala transaksinya, lembaga pemerintah yang menyimpan dokumen negara, sampai rumah sakit yang memiliki rekam medis pasien, mereka semua menyimpan data ke dalam suatu server.

Nah, masalahnya adalah, misalnya server ini rusak atau diretas oleh orang jahat, panjang lah urusannya. Permasalahan inilah yang coba dipecahkan oleh blockchain, yaitu membuat sistem pencatatan digital yang tidak bergantung pada satu pihak dan tidak gampang diubah-ubah.

Kriptografi

Sumber Gambar: emrecicek.net

Lalu bagaimana caranya agar catatan-catatan itu bisa dipercaya tanpa perlu tergantung sebagai lembaga sentral? Di sinilah kriptografi berperan.

“Kriptografi adalah praktik melindungi informasi melalui penggunaan algoritme kode, hash, dan tanda tangan.”

Pertama-tama, diperlukan semacam “sidik jari digital”. Hal ini bisa diperoleh dengan menggunakan hashing. Hashing sendiri adalah proses satu arah menggunakan suatu algoritma yang mengubah data input dengan ukuran berapa pun menjadi string karakter dengan ukuran tetap. Begitu suatu data di-hash, akan selalu didapat hasil yang unik. Ketika mengubah satu huruf saja, kodenya bisa berubah total.

Lalu bagaimana agar bisa terkirim dan diterima secara aman? Di sini ada tahapan enkripsi dan dekripsi terhadap pesan yang dikirim. Terdapat dua metode di sini, yang pertama enkripsi simetris di mana hanya ada satu kunci untuk mengunci dan membuka kunci dan enkripsi asimetris di mana terdapat sepasang kunci, yaitu kunci publik dan privat.

Model asimetris inilah yang menjadi dasar dari crypto address, kita memiliki private key yang hanya untuk pribadi dan public key yang bisa dilihat oleh semua orang. Kalau kita pernah membuat wallet, mungkin kita akan familiar dengan istilah “seed phrase“, nah di situ umumnya menjadi dasar dari provider-provider wallet untuk menghasilkan pasangan key yang bisa digunakan untuk berinteraksi dengan jaringan blockchain.

Ethereum

Sumber Gambar: Kanchanara on Unsplash

Oke dengan kriptografi, hashing dkk data kita aman. Tapi bukankah implementasi blokchain di hari ini bukan sekadar tempat menyimpan data transaksi? Bagaimana kalau kita ingin menjalankan program di dalam blockchain?

Ethereum kemudian muncul sebagai jawaban. Diperkenalkan oleh Vitalik Buterin pada 2013 dan diluncurkan resmi pada tahun 2015, Ethereum memperluas use case blokchain dengan smart contract. Suatu konsep yang diperkenalkan oleh Nick Szabo pada tahun 90-an. Pada konteks ethereum, smart contract adalah program yang berjalan otomatis di blockchain, tanpa perlu adanya perantara.

Sama seperti Bitcoin, Ethereum juga pada awalnya menggunakan mekanisme Proof of Work (PoW). Di mana di baliknya ada ribuan komputer yang berlomba memecahkan fungsi matematis untuk membuat blok baru dan mendapatkan hadiah koin, proses perlombaan inilah yang biasa disebut dengan mining.

Namun pada saat ini, Ethereum menggunakan mekanisme Proof Of Stake (PoS). Artinya, saat ini pembuatan blok baru ditentukan dengan “jaminan” ETH yang disetorkan oleh suatu node. Implikasinya adalah resource yang digunakan oleh ethereum saat ini lebih rendah dibandingkan saat masih menggunakan mekanisme PoW.

Tantangan Skalabilitas pada Ethereum

Sumber Gambar: Pintu.co.id

Kemudian muncul masalah baru, semakin banyak yang menggunakan Ethereum, semakin padat jaringannya, ibarat jalan protokol di dalamnya sudah macet. Akibatnya, biaya transaksi di jaringan ethereum menjadi mahal.

Sebagai solusi, muncul istilah Layer 2. Sederhananya, Layer 2 ini mengumpulkan transaksi dalam satu bundel baru memasukkan ke dalam jaringan ethereum. Setidaknya ada dua jenis yang populer saat in:

• Optimistic Rollup → Mengasumsikan transaksi sebagai valid, kecuali ada yang menggugat validitasnya.

• ZK-Rollup → Menggunakan metode kriptografi (Zero-Knowledge Proof) untuk membuktikan validitas transaksi.

Dengan hadirnya Layer 2, transaksi bisa lebih mudah dan cepat, tapi tetap mendapatkan benefit keamanan dari ethereum.

Akun, Wallet, dan Gas

Lalu bagaimana caranya kita bisa nyambung ke blockchain?

Kalau kita bicara ethereum, ada dua jenis akun:

• EOA (Externally Owned Account) → akun yang diakses oleh private key

• Contract Account → alamat dari smart contract yang berjalan sesuai dengan kodenya.

Misalnya kita melakukan interaksi dengan smart contract menggunakan Metamask. Pada dasarnya EOA kita yang berinteraksi dengan menandatangani transaksi tersebut. Kemudian Blockchain mencatat dan menjalankan kontrak tersebut.

Nah, agar transaksi itu bisa diproses, kita perlu yang namanya gas. Seperti namanya, dia ibarat bensin untuk mobil. Tanpa adanya gas, transaksi tidak bisa berjalan. Besaran biayanya dipengaruhi oleh kompleksitas kode yang ada di dalanya (apakah sekadar kirim mengirim atau ada fungsi yang rumit) dan kondisi dari jaringannya (sedang sepi atau sedang padat).

Kemana larinya biaya gas yang kita bayarkan? Sebagian akan diberikan sebagai insentif kepada node validator yang memproses, sebagian akan dibakar. Tujuannya agar perputaran ekonomi di jaringan ethereum lebih sehat dan harganya stabil untuk jangka panjang.

Penutup

Kalau kita tarik benang merah sejak awal. Teknologi ini masih terus berkembang, bahkan bisa ditarik benang merahnya sejak tahun 90-an saat Nick Szabo merumuskan konsep smart contract. Kemudian diimplementasikan oleh ethereum puluhan tahun kemudian. Lalu ada layer 2 dan semacamnya.

Maka dari itu, semakin mendalaminya, semakin kita bisa merasa bahwa teknologi ini bukan hanya sekadar hype. Tapi menjadi infrastruktur masa depan yang mungkin saja akan mengubah cara kita bertransaksi, berorganisasi, dan belajar.

Artikel ini berdasarkan catatan pembelajaran dari sesi pertama blockchain developer bootcamp di Pelita Bangsa Academy.

Sekarang, perkembangan AI bisa dibilang cukup diluar nalar. Jika kita ingat saat GPT 3.5 pertama diperkenalkan secara luas di akhir 2022, model ini masih kesulitan melakukan banyak tugas terkait pemrograman. Tapi coba kita tengok sekarang (setidaknya tahun 2025 saat saya menulis ini), kita bisa melihat AI bisa membuat aplikasi full hanya dengan beberapa kali klik. GPT 3.5 yang sangat kuat di tahun 2022 mungkin tidak berkutik dengam model Open Source keluaran terbaru tahun 2025. Meskipun model GPT 3.5 sendiri jauh lebih kuat jika dibandingkan dengan pendahulunya termasuk model-model dasar yang banyak dipelajari sewaktu kuliah.

Layaknya pisau bermata dua, perkembangan AI juga menimbulkan kekhawatiran tersendiri. Dari sisi penulisan misalnya, semakin banyak tulisan-tulisan yang terindikasi dibuat oleh AI. Konten-konten ini membanjiri banyak platform seperti medium bahkan sampai jurnal ilmiah. Hal yang perlu direnungkan, bagaimana arah tulisan manusia nantinya?

Apa yang Bisa Diberikan AI?

Secara umum, AI bekerja dengan mempelajari pola yang ada pada data. Dia dilatih sedemikian rupa dengan data yang besar sehingga bisa menjawab masalah dalam banyak topik. Maka dari itu, kita mungkin bisa mendapatkan jawaban yang baik dari AI pada hal-hal yang sudah baku atau terdokumentasi dengan baik.

Sebagai seseorang yang juga pernah membuat konten menggunakan AI. Saya mengakui bahwa dalam banyak hal, AI bisa membuat tulisan yang lebih baik dari saya sendiri. Anda mungkin bisa melihat di sebagian konten-konten awal saya di medium.

Jika kita yang sering menggunakan AI, mungkin kita akan bisa mengenali pola tulisan yang dibuat oleh AI dibandingkan dengan manusia. Saya sendiri masih belum sepeka itu, tapi setidaknya menurut saya, hal yang menjadi kelebihan dari tulisan manusia adalah “ketidaksempurnaannya“.

Tulisan Bukan Hanya Soal Hasil, Tapi Proses

Bagi banyak orang, menulis bukan hanya sekadar untuk berbagi kepada orang lain, tapi juga refleksi untuk diri sendiri. Lewat tulisan, kita bisa melihat sekilas cara seseorang berfikir dan bercerita. Bagaimana seseorang bisa merefleksikan isi kepalanya ke dalam media tulisan.

Hal inilah yang membedakan manusia dengan AI. Sebagai program komputer, memang dia bisa membuat tulisan, tapi mungkin tidak memiliki “jiwa“ tersendiri seperti tulisan manusia. Tulisan AI cenderung teratur beserta dan memiliki style yang flat, hal ini disesuaikan dengan prompt yang ditentukan oleh user.

Keteraturan ini mungkin akan membuat kita sulit menemukan ikatan emosional antara pembaca dengan tulisan AI. Karena pada sebagian orang, menulis adalah proses eksistensial yang didalamnya juga menampung emosi dan perasaan penulisnya. Di sinilah tulisan manusia saya rasa akan tetap memiliki pangsa pasarnya tersendiri.

Berkolaborasi atau Berkompetisi?

Di satu sisi, AI juga bisa membantu seseorang menulis tanpa harus bergantung 100% ataupun menghilangkan style penulisannya sendiri. Seorang penulis bisa saja menggunakan AI sebagai teman diskusi untuk tulisan-tulisannya. Ini tidak ada bedanya seperti peralihan penerimaan informasi dari yang dulu terpusat di buku kepada zaman internet.

Bisa dikatakan, saat ini kita berada di masa transisi pengumpulan informasi awal dari browsing ke prompting.

Tulisan-tulisan full AI memang bisa memberikan penjelasan yang lebih baik saat menjelaskan suatu dokumentasi kode misalnya dibandingkan manusia. Tapi, bagaimana pada topik yang berkaitan dengan pengalaman-pengalaman pribadi manusia? Tentu hal ini tidak bisa digantikan dengan AI.

Pilihan akhirnya kembali kepada kita, entah pesimis dan hanya meratapi dunia kita dipenuhi tulisan oleh AI atau tetap percaya bahwa akan selalu ada tempat untuk konten tulisan yang dibuat oleh manusia?

Belajar dari Dunia Catur

Kita perlu sedikit menengok ke ranah yang pertama kali “dianggap kalah“ oleh komputer, dunia catur. Pada tahun 1997 (Jauh sebelum GPT 3.5 pada 2022), juara dunia catur Gary Kasparov kalah dalam pertandingan catur klasik melawan komputer Deep Blue. Lalu pertanyaannya, apakah dunia catur setelah itu? Kenyataannya tidak, dunia catur justru tetap bertumbuh.

Meskipun saat ini mungkin bisa dikatakan mustahil pemain manusia bisa mengalahkan mesin catur terbaik. Cabang olahraga catur yang dimainkan manusia tetap menjadi primadona tersendiri karena adanya sentuhan kreativitas manusia yang ditunggu-tunggu setiap pertandingannya. Adanya AI justru menjadi rekan latihan yang baik bagi para grandmaster untuk mengembangkan permainannya.

Begitu juga dengan tulisan, bisa saja bombardir tulisan AI yang membanjiri linimasa kita menjadi tonggak awal dari “gaya baru“ menulis manusia di era ini. Mungkin kita melihat bahwa tulisan hasil AI lebih baik pada sebagian topik. Tapi tetap saja, akan ada sisi di mana tulisan asli manusia akan lebih bersinar.

Penutup

AI memang bisa menulis dengan baik, ia bisa membuat tulisan dengan analogi, penjelasan deskriptif dan hal-hal teknis lainnya.

Meskipun demikian, di tengah gempuran tulisan yang dibuat oleh mesin. Tulisan asli manusia tetap akan hidup dan akan selalu memiliki pasarnya tersendiri.

Terlebih lagi, menulis bukan hanya membagikan pemikiran kita kepada orang lain. Tetapi juga sebagai refleksi dari apa yang kita baca dan apa saja yang kita alami.

Smart contract sendiri merupakan program yang dapat berjalan sendiri dan berjalan dalam jaringan blockchain blockchain. Yang mana tiap transaksi ketika selesai akan bisa dilacak dan tidak dapat dibatalkan.

Jika kita mulai terjun ke dunia blockchain, belajar bahasa pemrograman Solidity yang digunakan untuk membuat smart contract di jaringan ethereum bisa dikatakan menjadi suatu keharusan. Karena meskipun banyak jaringan blockchain yang memiliki bahasa pemrograman tersendiri dalam pembuat smart contract, ethereum merupakan jaringan blockhain dengan kapitalisasi pasar terbesar kedua setelah bitcoin.

Pada artikel ini, kita akan mulai belajar dari sejumlah tipe nilai dasar bahasa pemrograman solidity yaitu boolean, unsigned integers, signed integers, string , dan enums.

Unsigned Integers (uint)

Unsigned Integer merupakan jenis angka yang hanya bisa berisikan nilai positif. Tipe data ini ideal untuk digunakan pada kondisi-kondisi ketika kita tidak memerlukan angka negatif seperti membuat hitungan, id pengguna, dan lain-lain. Contoh:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract UnsignedIntegerExample {
  uint8 public a = 100; // 0 -> 255
  uint16 public b = 10000; // 0 -> 65535

  // uint is an alias for uint256
  uint public c = 1000000000000;
  uint256  public d = 1000000000000;
}

Di sini kita melihat beberapa tipe data unsigned integer yaitu uint8, uint16, uint, uint256. Lalu apa perbedaannya?

• uint8 mendeklarasikan unsigned integer 8-bit yang bisa menampung nilai dari 0 sampai 255.

• uint16 mendeklarasikan unsigned integer 16-bit yang bisa menampung nilai dari 0 sampai 65535

• uint dan uint256 sama-sama mendeklarasikan unsigned integer 256-bit, yang mana nilainya cukup besar yaitu 2^256 - 1 atau

Tipe-tipe unsigned integer sendiri bervariasi tergantung pada maksimal bit data yang bisa ditampungya. Bervariasi di kelipatan delapan dari uint8 sampai uint256.

Signed Integers (int)

Signed Integer merupakan jenis angka yang bisa berisikan positif dan negatif. Tipe ini cocok digunakan untuk nilai-nilai yang memerlukan bilangan negatif seperti temperatur, perbedaan, ataupun skor. Contoh:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SignedIntegerExample {
  int8 public a = 10; 
  int16 public b = 50; 

  int256 public c = a - b; // result: -40
}

Meskipun memiliki jumlah bit yang sama dengan unsigned integers. Rentang nilai yang direpresentasikan sedikit berbeda, karena signed integer bisa merepresentasikan angka negatif. Contohnya pada uint8 rentang nilai ada dari 0 sampai 255, sedangkan pada int8 rentang nilai ada dari -128 sampai 127.

Sama seperti unsigned integers, signed integers bisa dideklarasikan setiap 8 step yang mana setiap angka merepresentasikan jumlah bit yang dimiliki. Contoh int8,int16,int32,int40 dan seterusnya sampai int256.

Boolean (bool)

Boolean merupakan tipe data yang hanya bisa berisikan dua nilai, true atau false. Umumnya boolean digunakan untuk pengkondisian ataupun state management.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract BooleanExample {
  bool public isActive = true; 
}

Kode bool public isActive = true; mendeklarasikan suatu state variable isActive, dan diinisialisasikan nilai true. Boolean akan banyak digunakan nantinya ketika kita ingin mengontrol suatu fitur di dalam kontrak terutama pada hal-hal yang berkaitan dengan pengkondisian.

String (string)

String merupakan rangkaian karakter yang digunakan untuk menyimpan data teks. Contoh penggunaan string yang banyak digunakan adalah seperti menyimpan nama, deskripsi, ataupun suatu pesan di dalam smart contract.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract StringExample {
  string public greeting = "Hello, World!";
}

Kode string public greeting = "Hello, World!"; menunjukkan pendeklarasian variabel greeting dan inisialisasi nilainya ke "Hello, World!".

Enums (enum)

Enum merupakan singkatan dari enumeration. Enum merupakan tipe data yang didefinisikan oleh user dan berisikan himpunan nama-nama opsi. Adanya enum akan membuat kode yang lebih mudah dibaca karena penamaannya yang sesuai dengan keinginnan pengguna.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract EnumExample {
  enum Choice { Up, Down, Left, Right } // Define an enum
  Choice public choice = Choice.Up; // Declare an enum state variable
}

Pada kode enum Choice { Up, Down, Left, Right }, kita mendefinisikan suatu enum yang kita beri nama Choice, di dalamnya terdapat empat pilihan yaitu Up, Down, Left, dan Right.

Kemudian pada Choice public choice = Choice.Up; dideklarasikan variabel choice lalu diinisalisasikan dengan Up. Penggunaan enum biasanya untuk merepresentasikan suatu state ataupun opsi-opsi pada smart contract seperti status pemesanan ataupun pilihan pada suatu mekanisme voting.

Penutup

Pepatah lama mengatakan perjalanan 1000 mil dimulai dengan satu langkah dasar. Belajar tipe nilai seperti boolean, unsigned integers, signed integers, string, dan enums akan berguna sebagai pondasi awal smart contract yang akan kita buat.

Dengan memahami dasar, kita bisa memiliki pengetahuan untuk memilih jenis dan alur data yang akan kita gunakan saat membuat smart contract yang lebih kompleks nantinya.

Terimakasih sudah membaca artikel ini, sampai jumpa di artikel-artikel lainnya.

Source Code : Github

Pada artikel ini, kita akan membahas sekilas dasar dari pemrograman solidity beserta contoh praktik membuat smart contract sederhana untuk ilustrasi penjualan rumah.

Variabel

Variabel digunakan untuk menyimpan data di dalam smart contract. Terdapat dua jenis variabel pada solidity:

• State Variable : Data tersimpan di dalam blockchain secara permanen dan hanya bisa diubah nilainya melalui fungsi.

• Local Variable : Data tidak disimpan di dalam blockchain dan hanya tersedia selama fungsi berjalan.

// State variable
uint public totalSupply;

// Local variable
function incrementSupply(uint _amount) public {
    uint newSupply = totalSupply + _amount; 
    totalSupply = newSupply; 
}

Pada contoh ini totalSupply merupakan state variable dan newSupply merupakan local variable.

Tipe Data

Solidity memiliki sejumlah tipe data yang bisa digunakan, di antaranya:

• Integer : Menyimpan data bilangan bulat positif.

  Contoh:

    uint public number = 100;
  

• Boolean : Menyimpan nilai true dan false.
  Contoh:

    bool public isNumber = true;
  

• Address : Menyimpan alamat Ethereum.
  Contoh:

    address public owner = msg.sender;
  

• String : Menyimpan data teks.
  Contoh:

    string public name = "This is solidity";
  

Fungsi

Fungsi merupakan blok kode yang digunakan untuk melakukan operasi dalam smart contract. Fungsi bisa digunakan untuk mengakses dan memodifikasi data. Struktur fungsi di dalam solidity terdiri dari nama, parameter, dan kode yang dieksekusi.

Fungsi juga memiliki visibilitas seperti public, private, internal, dan external.

Contoh:

function addNumbers(uint a, uint b) public pure returns (uint) {
    return a + b;
}

Fungsi addNumbers menerima parameter integer berupa a dan b, kemudian mengembalikan hasil penjumlahan keduanya.

Pure View

Pada contoh fungsi sebelumnya, kita melihat ada term pure. Dalam solidity, keberadaan pure menandakan bahwa fungsi tersebut tidak membaca ataupun mengubah state dari smart contract. Selain pure terdapat juga modifier view, yang bisa digunakan untuk mengambil data dari state smart contract, namun tidak mengubahnya.

Contoh:

uint public totalSupply = 100;

function getTotalSupply() public view returns (uint) {
    return totalSupply;
}

Jika suatu fungsi tidak menggunakan modifier pure dan view maka ia merupakan fungsi standar yang bisa membaca dan mengubah state.

Event & Emit

Ketika kita membuat smart contract, kita ingin memberi informasi terkait sesuatu yang terjadi di dalamnya ke luar (aplikasi frontend). Pada kasus ini, kita menggunakan event dan emit.

• Event : Mendefinisikan log yang bisa dipantau oleh aplikasi eksternal.

• Emit : Memicu event dan menulis log ke dalam blockchain.

Contoh:

event Transfer(address indexed from, address indexed to, uint amount);

function transfer(address _to, uint _amount) public {
    emit Transfer(msg.sender, _to, _amount); 
}

Pada hal ini, emit digunakan untuk memicu transfer, yang kemudian bisa ditangkap oleh aplikasi eksternal.

Require

Fungsi require digunakan untuk memberikan validasi syarat sebelum eksekusi lanjut. Jika syarat yang diberikan tidak terpenuhi, maka eksekusi smart contract akan dihentikan.

Contoh:

function withdraw(uint _amount) public {
    require(_amount <= address(this).balance, "Insufficient funds");
    msg.sender.transfer(_amount); 
}

Pada fungsi withdraw di atas, require melakukan validasi apakah jumlah yang ingin ditarik lebih kecil atau sama dengan saldo yang tersedia di kontrak.

Mapping

Konsep mapping mirip dengan hash atau dictionary pada bahasa pemrograman lain. Kegunaannya untuk memetakan nilai dari key yang unik pada nilai tertentu.

Contoh:

mapping(address => uint) public balance;

function deposit() public payable {
    balance[msg.sender] += msg.value;
}

Pada fungsi deposit, mapping balance menyimpan saldo ether pengguna berdasarkan alamat mereka. Ketika kita ingin menerima ether, fungsi harus menggunakan modifier payable. Jika tidak ada payable, fungsi tidak akan bisa menerima transaksi ether.

Msg

Untuk menyimpan informasi tentang transaksi yang sedang dijalankan, Solidity menyediakan variabel global bernama msg. Di antara property yang sering di gunakan pada msg adalah msg.sender yang memuat alamat pengirim transaksi dan msg.value yang memuat jumlah ether yang dikirim bersama transaksi.

Contoh:

function buyToken() public payable {
    require(msg.value >= 1 ether, "Not enough ether sent");
}

Pada fungsi buyToken, msg.value digunakan untuk memeriksa apakah jumlah ether yang dikirim mencukupi.

Contoh Smart Contract : Penjualan Rumah

Sekarang mari kita praktekkan pembuatan smart contract. Di sini kita akan membuat smart contract sederhana untuk penjualan dan pembelian rumah. Berikut kode lengkap smart contract yang akan kita buat:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract Houses{
    struct House{
        uint id;
        string houseAddress;
        uint price;
        address payable owner;
        bool availability;
    }

    mapping(uint => House) public housesList;

    mapping(address => uint) public sellerBalance;

    uint public housesCount;

    event HouseAdded(uint id, string homeAddress, uint price, address owner);

    event HouseTransaction(uint id, address buyer, uint price);

    function addHouse( string memory _houseAddress, uint _price) public {
        require(_price > 0, "Price must be above 0");

        housesCount++;

        housesList[housesCount] = House(
            housesCount,
            _houseAddress,
            _price,
            payable(msg.sender),
            true
        );

        emit HouseAdded(housesCount, _houseAddress, _price, msg.sender);
    }

    function buyHouse(uint _id) public payable {
        House memory house = housesList[_id];

        require(house.availability, "House not available");
        require(msg.value == house.price, "The ether entered does not match the price of the item");
        require(house.owner != msg.sender, "The owner");

        house.owner.transfer(msg.value); 
        sellerBalance[house.owner]+= msg.value; 

        house.owner = payable(msg.sender);
        house.availability = false; 

        housesList[_id] = house;

        emit HouseTransaction(_id, msg.sender, house.price);
    }

    function withdraw() public {
        uint balance = sellerBalance[msg.sender];
        require(balance > 0, "There is no balance to withdraw");

        sellerBalance[msg.sender] = 0;
        payable(msg.sender).transfer(balance); 
    }

    function checkBalance() public view returns (uint){
        return sellerBalance[msg.sender];
    }

}

Penjelasan Kode:

Inisialisasi Kontrak dan Variabel

Untuk memulai smart contract, kita menentukan lisensi source kode dan versi solidity yang digunakan. // SPDX-License-Identifier: MIT menunjukkan bahwa kode ini memiliki lisensi MIT, pragma solidity ^0.8.18; menuntukan bahwa versi Solidity yang digunakan versi 0.8.18 atau lebih tinggi.

Selanjutnya pada contract Houses{, kita mendeklarasikan kontrak bernama Houses. Kode-kode berikutnya akan berada dalam ruang lingkup kontrak Houses ini.

    struct House{
        uint id;
        string houseAddress;
        uint price;
        address payable owner;
        bool availability;
    }

Pada blok ini kita mendefinisikan tipe data struct bernama House, yang nantinya akan digunakan untuk merepresentasikan rumah yang terdiri dari atribut bernama id, houseAddress, price, owner, dan availability.

Kode mapping(uint => House) public housesList; berfungsi untuk menyimpan rumah berdasarkan ID. Dan setiap ID akan dipetakan ke dalam struct House dan disimpan ke dalam variabel bernama housesList. Modifier public menunjukkan bahwa variabel ini bisa diakses baik dari dalam maupun luar kontrak.

Begitu juga dengan mapping(address => uint) public sellerBalance; yang memetakan saldo ether setiap penjual berdasarkan alamat mereka.

Lalu ada variabel houseCount yang didefinisikan sebagai integer dengan uint public housesCount; .

Selanjutnya adalah membuat event untuk mencatat peristiwa yang terjadi pada blockchain. event HouseAdded(uint id, string homeAddress, uint price, address owner); mencatat peristiwa ketika rumah baru ditambah ke marketplace. Yang dicatat berupa ID rumah, alamat, harga, dan pemilik rumah. Kemudian event HouseTransaction(uint id, address buyer, uint price); dicatat ketika terjadi transaksi pembelian rumah. Yang dicatat berupa ID, alamat pembeli, dan harga.

Fungsi addHouse

 // function to add house into marketplace
    function addHouse( string memory _houseAddress, uint _price) public {
        require(_price > 0, "Price must be above 0");

Kita membuat fungsi publik function addHouse(string memory _houseAddress, uint _price) public untuk menambahkan rumah baru. Parameter yang dimasukkan adalah alamat rumah (_houseAddress) dan harga rumah (_price). Kemudian memverifikasi bahwa harga rumah lebih besar dari 0 dengan require(_price > 0, "Price must be above 0");.

        housesCount++;

        // add house into mapping
        housesList[housesCount] = House(
            housesCount,
            _houseAddress,
            _price,
            payable(msg.sender),
            true
        );

Setiap kali ada rumah baru yang ditambahkan, variabel houseCount ditambah ke housesCount++;. Rumah yang baru ditambahkan dimasukkan ke dalam variabel mapping houseList menggunakan ID baru (houseCount). Fungsi ini pada akhirnya memicu event HouseAdded untuk mencatat bahwa rumah telah berhasil ditambahkan ke marketplace.

Fungsi buyHouse

     function buyHouse(uint _id) public payable {
        House memory house = housesList[_id];

Fungsi buyHouse merupakan fungsi publik untuk membeli rumah berdasarkan ID-nya (_id). Fungsi ini menggunakan modifier payable sehingga bisa menerima ether.

Pertama-tama , House memory house = housesList[_id]; mengambil data berdasarkan ID lalu menyimpannya ke dalam variabel house yang bertipe memory.

        require(house.availability, "House not available");
        require(msg.value == house.price, "The ether entered does not match the price of the item");
        require(house.owner != msg.sender, "The owner");

Selanjutnya kita melakukan pengecekan dengan tiga buah fungsi require. Pertama require(house.availability, "House not available"); untuk menmeriksa apakah rumah tersedia untuk dijual. Kedua require(msg.value == house.price, "The ether entered does not match the price of the item"); untuk memeriksa apakah jumlah ether yang dikirim oleh pembeli sama dengan harga rumah. Ketiga require(house.owner != msg.sender, "The owner"); untuk memastikan pemilik rumah tidak membeli rumahnya sendiri.

        house.owner.transfer(msg.value); // transfer ether to seller
        sellerBalance[house.owner]+= msg.value; // add seller balance

Kode house.owner.transfer(msg.value); berfungsi untuk mengirim ether dari pembeli ke penjual. Lalu menambahkan saldo penjual yang tercatat di sellerBalance.

        house.owner = payable(msg.sender);
        house.availability = false;

Setelah dana dipindahkan, kepemilikan diubah dengan house.owner = payable(msg.sender); beserta dengan status ketersediannya house.availability = false; yang menandakan bahwa rumah tersebut sudah terjual. Lalu pada housesList[_id] = house; mapping housesList diperbarui dengan detail terbaru setelah transaksi berlangsung.

        emit HouseTransaction(_id, msg.sender, house.price);
    }

Terakhir, fungsi ini memicu event HouseTransaction untuk mencatat transaksi penjualan rumah beserta ID rumah, pembeli, dan harga.

Fungsi withdraw

function withdraw() public {
        uint balance = sellerBalance[msg.sender];
        require(balance > 0, "There is no balance to withdraw");

Fungsi withdraw merupakan fungsi publik yang berfungsi agar penjual menarik saldo mereka. Pertama-tama, saldo penjual didapatkan dari sellerBalance. Selanjutnya kita pastikan dengan require(balance > 0, "There is no balance to withdraw"); kita pastikan bahwa saldo penjual lebih besar dari 0.

        sellerBalance[msg.sender] = 0;
        payable(msg.sender).transfer(balance); // transfer balance to seller
    }

Setelah terjadi penarikan, saldo penjual diubah menjadi 0 dan saldo tersebut ditransfer ke address penjual yang memanggil fungsi.

Fungsi checkBalance

  function checkBalance() public view returns (uint){
        return sellerBalance[msg.sender];
    }
}

Fungsi terakhis adalah checkBalance yang merupakan publik dengan modifier view. Kegunaannya adalah untuk melihat saldo penjual yang disimpan di mapping sellerBalance.

Penutup

Pada artikel ini, kita sudah membahas dasar-dasar dari Solidity yang merupakan bahasa pemrograman untuk membuat smart contract pada jaringan ethereum. Selanjutnya, kita juga mempraktekkan pembuatan smart contract sederhana untuk penjualan rumah.

Implementasi smart contract seperti ini nantinya bisa dikembangkan lebih lanjut untuk banyak aplikasi, dari yang skalanya sederhana sampai kompleks. Terima kasih sudah membaca artikel ini, selamat belajar dan semoga bermanfaat!.

Setiap generasi memiliki outlier asset, dan outlier asset generasi sekarang adalah Cryptocurrency.

Setidaknya ungkapan seperti ini sering diucapkan oleh para influencer-influencer yang terjun ke dunia cryptocurrency. Semakin digandrunginya crypto pada saat ini tidak terlepas dari suatu teknologi bernama blockchain.

Pada artikel ini, kita akan membahas pengenalan singkat tentang Blockchain, teknologi, serta kelebihan-kelebihan yang ada di dalamnya.

Apa itu Blockchain

Menurut kamus oxford, blockchain didefinisikan sebagai:

a system in which a record of transactions, especially those made in a cryptocurrency, is maintained across computers that are linked in a peer-to-peer network.

Blockchain juga sering diibaratkan seperti buku besar yang di dalamnya terdapat blok-blok dan pencatatannya tersebar di seluruh jaringan.

Blok sendiri bisa dianalogikan seperti satu halaman di dalam buku besar tersebut. Di mana blok tersebut berisikan data, kode hash untuk blok tersebut dan blok sebelumnya.

Keberadaan kode hash ini lah yang seakan membuat suatu rantai yang menghubungkan antar blok di dalam satu jaringan blockchain.

Konsep-konsep ini menjadi asal dari fitur-fitur kunci dalam blockchain seperti desentralisasi, imutabilitas, transparansi, dan keamanan.

Fitur Utama di dalam Blockchain

Mari kita bahas fitur-fitur utama di dalam blockchain itu sendiri:

Terdesentralisasi, Jika kita melihat pada sistem yang ada sekarang, terdapat satu entitas seperti server yang memiliki kendali penuh di dalam sistem. Pada sistem blockchain, kendali ada pada banyak entitas yang disebut node, sehingga tidak ada pemegang kendali mutlak di dalamnya.

Imutablitas, ketika suatu data masuk ke dalam blok, data tersebut tidak akan bisa diubah tanpa mengubah data-data yang ada setelahnya, oleh karena itu membuat perubahan di dalam blockchain sangat sulit bahkan hampir mustahil karena ia memerlukan persetujuan dari semua node yang ada.

Transparansi, akuntabilitas dan transparansi sangat terjaga di dalam blockchain karena seluruh peserta yang ada di jaringan blockchain bisa melihat semua transaksi yang terjadi.

Keamanan, blockchain memanfaatkan teknik hash dari kriptografi untuk mengamankan seluruh transaksi dan data di dalam jaringannya. Sehingga segala sesuatu yang terjadi di dalam blockhain sulit untuk dimanipulasi dan diretas.

Bagaimana Blockchain bekerja?

Sebagaimana sudah disebutkan sebelumnya, setiap blok berisikan kumpulan transaksi yang terjadi.

Blok pertama di dalam jaringan dikenal dengan Genesis Block. Blok merupakan dasar dari seluruh jaringan, karena semua blok lainnya terhubung ke dalam blok ini.

Sebagai penghubung, tiap blok memiliki tanda pengenal unik yang disebut dengan hash, nilainya dihasilkan berdasarkan data yang ada di dalam blok. Hash ini ibaratkan cap unik atau tanda sidik jari dari blok dan memastikan setiap blok di dalamnya unik.

Sebelum ditambahkan, transaksi-transaksi yang ada di dalam jaringan blockchain harus disepakati oleh seluruh nodes yang ada di dalamnya. Konsep ini dikenal juga dengan mekanisme konsensus.

Mekanisme ini memastikan keberadaan versi tunggal yang valid di dalam jaringan. Sehingga bisa mengantisipasi pihak-pihak yang mencoba mengubah transaksi di dalam. Karena jika hal ini terjadi, misalnya ada perubahan di salah satu node, anggota lain di dalam jaringan bisa mengeluarkan node tersebut karena isinya yang menyalahi konsensus yang ada.

Manfaat Blockchain

Dari konsep dan fitur di dalamnya, penerapan blockchain memiliki potensi manfaat yang tinggi.

Prinsipnya yang terdesentralisasi bisa memecahkan masalah efisiensi yang banyak terjadi di dunia saat ini. Karena blockchain menghilangkan keperluan akan perantara, misalnya bank dalam konteks keuangan, maka transaksi yang terjadi bisa lebih cepat dan lebih murah.

Sifatnya yang transparan juga memberikan kemudahan dalam penelusuran, karena setiap transaksi yang ada tersedia dan tercatat secara lengkap dan akurat.

Penutup

Blockchain merupakan teknologi revolusioner yang dimanfaatkan dengan baik, blockchain akan mampu memberikan suatu sistem yang lebih transparan, aman, dan efisien dibandingkan sistem tradisional.

Perkembangannya juga sangat pesat mengingat semakin populernya pasar kripto. Oleh karena itu, meskipun mungkin tidak bersentuhan secara langsung. Mempelajari konsep dari blockchain seperti menjadi keniscayaan yang perlu dilakukan oleh orang-orang di masa sekarang.

Pada postingan kali ini, kita akan membuat contoh studi kasus penggunaan AI dengan membuat generator post di media sosial. Tujuan dari adanya generator ini adalah untuk membantu perorangan ataupun bisnis untuk memberikan inspirasi postingan yang bisa dilakukan untuk membantu bisnis ataupun personal branding perseorangan.

Mempersiapkan Folder dan Requirements

Library yang akan kita gunakan pada project ini adalah openai dan streamlit, jika belum terinstall kita bisa mengunduhnya di package manager pip ataupun conda.

Struktur folder proyek yang akan kita buat adalah sebagai berikut

- postgenerator
|--app.py
|--gpt.py

Agar lebih mudah di maintenance, di sini kita akan memisahkan file ke dalam app.py dan gpt.py, file app.py berisikan UI untuk aplikasi streamlit kita dan gpt.py berisikan logic dari aplikasi yang akan kita buat.

Membuat gpt.py

Kode di dalam app.py adalah sebagai berikut:

import openai

def generate_post(api_key, platform, topic, temperature, length, use_hashtags, use_emojis):
    try:
        client = openai.OpenAI(api_key=api_key)
        prompt = f"Generate a {length} social media post for {topic} in {platform}."

        if use_hashtags:
            prompt += " Include relevant hashtags."
        else:
            prompt += " Do not include hashtags."
        if use_emojis:
            prompt += " Include appropriate emojis."
        else:
            prompt += " Do not include emojis."
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a social media expert with 20 years experience on Cupywriting"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=1000,
            temperature=temperature  
        )
        post = response.choices[0].message.content
        return post
    except openai.AuthenticationError:
        return "Invalid API key"
    except Exception as e:
        return str(e)

Pada file ini, kita akan membuat fungsi yang kita beri nama generate_post. Fungsi ini akan menerima tujuh parameter yaitu api_key, platform, topic, temperature, length, use_hashtags, use_emojis.

Karena kita akan melakukan request ke OpenAI API, maka kita membungkus kode kita dengan error handling try-except. Tujuannya agar ketika ada error, diharapkan aplikasi kita tidak crash.

Selanjutnya kita membuat objek client dari openai.OpenAI, di sini api_key yang kita masukkan divalidasi. Lalu membuat variabel prompt yang berisikan template dari perintah yang akan kita berikan.

Parameter use_hashtag dan use_emojis bekerja dengan cara memberikan prompt tambahan yang menentukan apakah hashtag dan emoji akan dimasukkan ke dalam post yang akan kita buat.

Kemudian kita menampung response dari method client.chat.completions.create, di sini kita memasukkan parameter berupa model, messages, max_tokens, dan temperature. Untuk model yang digunakan adalah gpt-4o-mini, versi kecil dari model terbaik openai saat ini.

Parameter messages memberikan petunjuk terhadap model terkait role yang diberikan kepadanya dan prompt yang dimasukkan oleh user. Di sini kita memberikan system prompt kepada model bahwa ia adalah seorang social media expert yang juga berpengalaman di bidang copywriting.

Parameter max_tokens mengatur jumlah maksimal token yang akan di generate. Di sini kita memasukkan 1000 karena kita akan mengatur panjang dari post yang dibuat bisa ke dalam tiga kategori.

Selanjutnya parameter temperature yang mengatur kreativitas dari response model, semakin tinggi maka akan semakin kreatif, begitu pula sebaliknya.

Keseluruhan fungsi generate_post akan mengembalikan post yang merupakan respon dari model terhadap prompt yang diberikan user.

Membuat app.py

Setelah logic pada gpt.py telah selesai dibuat, kita lanjut membuat tampilan menggunakan streamlit. Keseluruhan kode app.py adalah sebagai berikut:

import streamlit as st
from gpt import generate_post

def main():
    st.title("Social Media Post Generator")

    st.sidebar.title("Configuration")
    api_key = st.sidebar.text_input("Enter your OpenAI API key:", type="password")

    if api_key:
        topic = st.text_input("What is your post for?")

        platform = st.selectbox("Platform:", ["Facebook", "Instagram", "Twitter", "LinkedIn"])

        temperature = st.slider("Creativity Level (temperature):", min_value=0.0, max_value=1.0, value=0.5, step=0.05)

        length = st.selectbox("Choose the length:", ["Short", "Medium", "Long"])

        use_hashtags = st.radio("Include hashtags?", ("Yes", "No"))
        use_emojis = st.radio("Include emojis?", ("Yes", "No"))

        use_hashtags = use_hashtags == "Yes"
        use_emojis = use_emojis == "Yes"

        # Generate Post Button
        if st.button("Generate Post"):
            if topic:
                post = generate_post(api_key, platform, topic, temperature, length, use_hashtags, use_emojis)
                if post == "Invalid API key":
                    st.error("Invalid API key. Please check and try again.")
                elif "error" in post.lower():
                    st.error(f"An error occurred: {post}")
                else:
                    st.success("Generated Post:")
                    st.write(post)
            else:
                st.warning("What is your post for?")
    else:
        st.warning("Please enter your OpenAI API key in the sidebar to generate a post.")

if __name__ == "__main__":
    main()

Secara keseluruhan, tampilan UI yang kita buat terdiri dari tampilan utama dan sidebar. Agar bisa menggunakan aplikasi ini, terlebih dahulu pengguna harus memasukkan openAI masing-masing. Sidebar berfungsi untuk menampung api key yang digunakan oleh pengguna.

Input yang bisa dimasukkan oleh pengguna adalah topic, platform, temperature, length, use_hashtag, dan use_emojis.

Topic berupa text input dan berisikan tujuan dari post yang akan kita generate. Selanjutnya input platform dan length berupa select box yang berisikan pilihan nilai. Untuk platform, kita bisa memilih antara facebook, linkedin, twitter, ataupun linkedin. Sedangkan length kita bisa memilih antara pendek, sedang, dan panjang.

Parameter temperature berupa slider dengan rentang antara 0 dan 1. Dan terakhir use_hashtag dan use_emojis berupa radio button.

Terakhir adalah button Generate Post yang akan memanggil fungsi generate_post yang sudah kita buat sebelumnya pada file gpt.py, parameter yang diteruskan disesuaikan dengan input pengguna yang sudah dimasukkan pada streamlit UI.

Menjalankan Aplikasi

Untuk menjalankan aplikasi, kita bisa menjalankan perintah streamlit run app.py di terminal. Berikut adalah tampilan aplikasi ketika dijalankan.

Untuk percobaan, saya akan meminta untuk dibuatkan post untuk

an Arabic food restaurant in Jakarta city called "Kebulimu"

Selanjutnya dicoba tiga buah kombinasi parameter:

• Length: short, Hashtag: no, Emojis: no

• Length: medium, Hashtag: yes, Emojis: no

• Lenght: long, Hashtag: yes, Emojis: no

Untuk temperature kita set ke 0.75 dan platform tujuan adalah instagram. Berikut hasilnya:

1. Hasil Kombinasi parameter pertama:

2. Hasil Kombinasi parameter kedua:

3. Hasil Kombinasi parameter ketiga:

Bisa dilihat bahwa hasil yang diberikan sesuai dengan parameter yang kita tentukan.

Penutup

Dari projek sederhana ini, kita bisa belajar tentang bagaimana pengaruh suatu prompt yang diberikan terhadap output yang dihasilkan. Untuk saat ini, kita masih mengandalkan knowledge dari model yang sudah ada, pengembangan selanjutnya bisa dilakukan dengan menambahkan knowledge dari file kita sendiri menggunakan teknik seperti retrieval augmented generation (RAG).

Terima kasih sudah membaca artikel ini, semoga bermanfaat dan jangan lelah untuk terus belajar!.

Kode Sumber : Github

Dilanjutkan juga dengan membuat web app sederhana menggunakan streamlit.

Pada blog post kali ini, kita kembali akan melakukan analisis sentimen dan menggunakan streamlit untuk membuat tampilan web sederhana. Perbedaannya adalah, alih-alih menggunakan traditional machine learning, kali ini kita akan menggunakan LLM dalam hal ini model GPT dari OpenAI.

Membuat Sentiment Analyzer dan UI

Hasil akhir dari project yang kita buat bisa dicoba pada link berikut:

https://sentimentgpt.streamlit.app/

Untuk ini, kita akan membuat dua buah file yaitu gpt.py untuk melakukan request ke model Open AI dan app.py untuk membuat tampilan UI untuk berinteraksi dengan user. Adapun requirement library yang digunakan adalah:

openai==1.41.0
streamlit==1.32.0

Membuat file logic gpt.py

import openai

def get_sentiment(text, user_api_key):
    try:
        client = openai.OpenAI(api_key=user_api_key)
        prompt = f"Analyze the sentiment of the following text, and classify it as positive, negative, or neutral:\n\n{text}"
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a sentiment analyzer, your must answer with only positive, negative, or neutral"},
                {"role": "user", "content": prompt}
            ],
            max_tokens=140,
            temperature=0.7,
        )
        sentiment = response.choices[0].message.content
        return sentiment
    except openai.AuthenticationError:
        return "Invalid API key"
    except Exception as e:
        return str(e)

Kode di atas berisikan logic untuk berinteraksi ke OpenAI API dan melakukan analisis sentimen. Pertama-tama kita import library openai, di sini kita lalu membuat fungsi get_sentiment yang menerima input dua buah parameter yaitu text yang merupakan input dari pengguna dan user_api_key yang merupakan api key dari pengguna.

Kita membungkus fungsi dengan try-except karena request ke API sangat rawan terkena error sehingga penggunaan error handler bisa dikatakan sebagai sesuatu yang layak dilakukan.

Selanjutnya adalah membuat instance client dengan memanggil openai dan memasukkan api key yang dimiliki oleh masing-masing pengguna.

Kita lalu memanggil method client.chat.completions.create yang bertujuan untuk mengirimkan prompt ke model untuk diproses, method ini berisikan parameter:

• model: model yang digunakan untuk melakukan analisis sentimen, di sini kita menggunakan gpt-4o-mini.

• messages: parameter ini mendefinisikan konteks dalam percakapan yang akan dilakukan, isinya berupa dictionary berupa:

  • {"role": "system", "content": ...} : membuat system message, bertujuan untuk memberitahu model tugasnya sebagai sentiment analyzer yang hanya akan merespon sesuai dengan yang diminta, dalam hal ini positive, negative, atau neutral.

  • {"role": "user", "content": prompt}: membuat user message yang berisikan prompt berupa teks yang akan dianalisis.

• max_tokens: maksimal jumlah token yang ada di dalam respon model.

• temperature: parameter ini digunakan untuk mengontrol kreativitas model.

Respon yang dikembalikan berupa objek yang berisikan detail chat itu sendiri. Oleh karena itu, kita perlu mengekstraknya dengan memanggil response.choices[0].message.content dan menyimpannya ke variabel sentiment agar output dari fungsi yang kita buat bisa dipahami oleh pengguna.

Membuat UI Streamlit app.py

import streamlit as st
from gpt import get_sentiment

# Streamlit UI
st.sidebar.title("Configuration 🔧")
api_key = st.sidebar.text_input("Enter your OpenAI API key 🔑:", type="password")

st.title("Sentiment Analysis with LLM")

text_input = st.text_area("Enter text to analyze:")

if st.button("Analyze Sentiment"):
    if not api_key:
        st.error("Please enter your OpenAI API key in the sidebar.")
    elif text_input:
        sentiment = get_sentiment(text_input, api_key).lower()

        if sentiment == "invalid api key":
            st.error("Invalid API key. Please check and try again.")
        elif "error" in sentiment.lower():
            st.error(f"An error occurred: {sentiment}")
        else:
            if "positive" in sentiment:
                st.success(f"Sentiment: {sentiment.capitalize()}", icon="✅")
            elif "negative" in sentiment:
                st.error(f"Sentiment: {sentiment.capitalize()}", icon="🚫")
            elif "neutral" in sentiment:
                st.warning(f"Sentiment: {sentiment.capitalize()}", icon="⚖️")
            else:
                st.info(f"Sentiment: {sentiment.capitalize()}")
    else:
        st.warning("Please enter some text to analyze.")

Di sini kita membuat UI sederhana menggunakan streamlit agar pengguna bisa berinteraksi dengan sentiment analyzer yang sudah kita buat sebelumnya.

Pertama kita membuat sidebar yang berisikan kolom input agar pengguna bisa memasukkan api keynya masing-masing.

Selanjutnya untuk konten utama, hanya ada 3 komponen yaitu judul, text area dan tombol untuk melakukan analisis sentimen. Setelah tombol ditekan, proses analisis sentimen akan dilakukan.

Ketika ada kesalahan seperti text area yang masih kosong, api key yang salah ataupun api key yang belum terisi, program akan memberikan pemberitahuan seperti error yang didapatkan.

Menjalankan Aplikasi

Untuk menjalankan aplikasi pastikan struktur folder aplikasi sebagai berikut:

.
├── app.py                 # The Streamlit UI code
├── gpt.py                 # The sentiment analysis logic using OpenAI API
├── requirements.txt       # (Optional) Required Python packages
└── README.md              # (Optional) Project documentation (this file)

Setelah kode dan struktur sesuai, kita bisa mencoba aplikasi kita dengan menjalankan:

streamlit run app.py

Berikut tampillan dari aplikasi yang telah kita buat

Tampilan awal aplikasi,

Tampilan ketika kita lupa memasukkan api key,

Tampilan ketika api key yang dimasukkan salah,

Tampilan ketika teks yang dimasukkan memiliki sentimen positif,

Tampilan ketika teks yang dimasukkan memiliki sentimen negatif,

Tampilan ketika teks yang dimasukkan memiliki sentimen netral,

Penutup

Selamat, kita telah berhasil menggunakan model Large Language Model (LLM) dalam hal ini GPT untuk melakukan analisis sentimen. Mungkin akan ada pertanyaan, bukankah akan lebih murah jika kita menggunakan traditional machine learning untuk keperluan sederhana seperti analisis sentimen?

Jawabannya adalah iya, namun penggunaan LLM untuk melakukan analisis sentimen setidaknya patut dipertimbangkan pada kondisi seperti ketika belum ada data yang memadai. Saat tidak adanya data yang memungkinkan kita untuk melakukan training pada model buatan sendiri, kita bisa membuat model sementara menggunakan llm sambil kemudian hasil darinya kita cek agar kemudian kita bisa membuat dataset tersendiri yang bisa digunakan untuk melakukan mentraining model sentiment analyzer menggunakan metode traditional machine learning.

Demikian, semoga tulisan ini bermanfaat, terima kasih, dan selamat belajar.

Kode Sumber: Github

Deteksi objek bisa memiliki peranan penting dalam kehidupan sehari-hari, mulai dari aspek keamanan, untuk pengendalian lalu lintas, sampai hingga teknologi kendaraan otonom. Kompleksitas tugas ini terletak pada dua aspek utama: pertama, bagaimana mendeteksi objek dengan berbagai ukuran, bentuk, dan orientasi di dalam gambar; kedua, bagaimana melakukan deteksi ini dengan cepat dan akurat, bahkan dalam kondisi dunia nyata yang sering kali penuh dengan kebisingan dan latar belakang yang rumit.

Mengenal Sekilas Faster R-CNN

Salah satu metode yang paling populer untuk deteksi objek adalah Faster R-CNN (Region-based Convolutional Neural Network). Faster R-CNN merupakan pengembangan dari metode R-CNN dan Fast R-CNN yang sudah dikembangkan sebelumnya, kelebihan dari Faster R-CNN adalah peningkatan signifikan dalam hal kecepatan dan akurasi deteksi objek. Meskipun untuk saat ini, sudah banyak metode lain yang lebih baru dan cepat dibandingkan Faster R-CNN. Mengetahui dan mencoba metode ini tetap layak dilakukan sebagai pengenalan terhadap metode-metode untuk object detection

Faster R-CNN memperkenalkan pendekatan melakukan integrasi Region Proposal Network (RPN) ke dalam arsitektur deteksi objek. Dengan adanya RPN, Faster R-CNN bisa menghasilkan proposal region (wilayah yang kemungkinan mengandung objek) secara lebih efisien dan dari fitur yang diekstraksi oleh jaringan konvolusi. Sehingga dimungkinkan proses deteksi objek secara end-to-end dalam satu jaringan, menghilangkan bottleneck yang ada pada metode sebelumnya yang mengandalkan proses eksternal seperti selective search. Penjelasan lebih lanjut tentang bagaimana Faster RCNN bekerja bisa dilihat lebih lanjut pada paper ini.

Implementasi Faster RCNN untuk Deteksi Objek

Di sini kita tidak melakukan pelatihan model dari awal, melainkan menggunakan pretrained model yang ada di torchvision. Sedangkan untuk gambar-gambar pada artikel ini bisa didapatkan di Kaggle. Pertama-tama kita perlu mengimpor beberapa library untuk projek ini:

import cv2
import torch
import requests
import numpy as np
import torchvision
from PIL import Image
from torch import no_grad
import matplotlib.pyplot as plt
from torchvision import transforms

Library yang kita impor merupakan library yang berhubungan dengan computer vision. Seperti OpenCV cv2 untuk pemrosesan gambar, kemudian numpy np untuk keperluan komputasi, PIL untuk memuat gambar, matplotlib plt untuk visualisasi dan Request untuk mengunduh gambar dari web.

Membuat Helper Function

# Function to get predictions with optional filtering by object and threshold
def get_predictions(pred, threshold=0.8, objects=None):
    """
    Assign a string name to predicted classes and filter out predictions below a given threshold.

    Args:
        pred: List containing tuples with class labels, probabilities, and bounding boxes.
        threshold: Minimum probability required to consider a prediction valid.
        objects: Optional list of object names to filter predictions.

    Returns:
        List of tuples containing class name, probability, and bounding box for each valid prediction.
    """
    predicted_classes = [(COCO_INSTANCE_CATEGORY_NAMES[i], p, [(box[0], box[1]), (box[2], box[3])])
                         for i, p, box in zip(list(pred[0]['labels'].numpy()),
                                              pred[0]['scores'].detach().numpy(),
                                              list(pred[0]['boxes'].detach().numpy()))]
    predicted_classes = [stuff for stuff in predicted_classes if stuff[1] > threshold]

    if objects and predicted_classes:
        predicted_classes = [(name, p, box) for name, p, box in predicted_classes if name in objects]

    return predicted_classes

Fungsi get_predictions dibuat untuk memproses dan menyaring prediksi yang dibuat oleh model deteksi objek. Fungsi ini menerima tiga parameter: pred sebagai output mentah dari model, threshold untuk menyaring hasil prediksi yang memiliki tingkat confidence rendah, dan objects dalam bentuk list yang sifatnya opsional berfungsi berdasarkan kelas tertentu. Pertama, fungsi ini mengubah prediksi mentah menjadi format yang lebih mudah dibaca dengan membuat daftar tuple yang berisi nama kelas, probabilitas deteksi, dan koordinat kotak pembatas. Kemudian, fungsi menyaring prediksi yang tidak memenuhi ambang batas probabilitas dan, jika parameter objects diberikan, hanya menyisakan prediksi yang sesuai dengan nama objek yang ditentukan. Hasil akhirnya adalah daftar tuple yang sudah difilter, yang siap digunakan untuk analisis atau visualisasi lebih lanjut.

# Function to draw bounding boxes around detected objects
def draw_box(predicted_classes, image, rect_th=1, text_size=1, text_th=1):
    """
    Draw bounding boxes and labels around detected objects in an image.

    Args:
        predicted_classes: List of tuples containing class name, probability, and bounding box.
        image: Image tensor on which boxes and labels will be drawn.
        rect_th: Thickness of the rectangle.
        text_size: Font size of the label text.
        text_th: Thickness of the label text.
    """
    img = (np.clip(cv2.cvtColor(np.clip(image.numpy().transpose((1, 2, 0)), 0, 1), cv2.COLOR_RGB2BGR), 0, 1) * 255).astype(np.uint8).copy()
    for predicted_class in predicted_classes:
        label, probability, box = predicted_class
        t, l = box[0]
        r, b = box[1]
        t, l, r, b = [round(item) for item in [t, l, r, b]]
        cv2.rectangle(img, (t, l), (r, b), (0, 255, 0), rect_th)  # Draw Rectangle
        cv2.putText(img, f"{label}: {str(round(probability, 2))}", (t, l), cv2.FONT_HERSHEY_SIMPLEX, text_size, (0, 255, 0), thickness=text_th)
    plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.show()

Fungsi draw_box dibuat untuk memvisualisasikan hasil model deteksi objek dengan menggambar bounding box dan label di sekitar objek yang terdeteksi. Fungsi ini juga menerima parameter berupa daftar kelas yang diprediksi, gambar yang akan diolah, ketebalan kotak pembatas, serta ukuran dan ketebalan teks label. Fungsi ini mengubah gambar dari format tensor ke array NumPy. Selanjutnya, fungsi ini mengiterasi daftar kelas yang diprediksi, mengekstrak informasi kelas, probabilitas, dan koordinat kotak pembatas untuk digambar di atas gambar menggunakan OpenCV. Setelah itu, label yang berisi nama kelas dan probabilitas ditambahkan di sudut kiri atas bounding box. Akhirnya, gambar dikonversi kembali ke format RGB (dan ditampilkan menggunakan Matplotlib, sehingga kita bisa melihat objek yang terdeteksi beserta bounding box dan labelnya.

# Function to clear GPU memory and delete images to free up RAM
def save_RAM(image_=False):
    """
    Clear GPU memory and delete image variables to free up RAM.

    Args:
        image_: Boolean flag to indicate if the image object should be deleted.
    """
    torch.cuda.empty_cache()
    global image, img, pred
    del img, pred
    if image_:
        image.close()
        del image

Fungsi save_RAM berfungsi untuk mengelola dan membebaskan memori, terutama dalam lingkungan di mana memori GPU terbatas dan perlu dikelola dengan hati-hati, seperti saat melakukan inferensi model deep learning. Fungsi ini berfokus pada pembersihan memori GPU dan secara opsional menghapus variabel gambar dari RAM. Caranya adalah dengan memanggil torch.cuda.empty_cache() untuk membersihkan cache memori GPU yang tidak terpakai, menggunakan del untuk menghapus variabel img dan pred dari memori, serta secara opsional menghapus variabel image jika parameter image_ diatur ke True.

Persiapan Model

# Load Pre-Trained Faster RCNN Model
model_ = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
model_.eval()  # Set the model to evaluation mode

# Disable gradient computation for all parameters
for name, param in model_.named_parameters():
    param.requires_grad = False

print("Model loaded successfully.")

Selanjutnya adalah memuat model Faster R-CNN (Region-based Convolutional Neural Network) dengan backbone ResNet-50 dan Feature Pyramid Network (FPN) yang sudah dilatih sebelumnya untuk tugas deteksi objek. Model dimuat menggunakan fungsi torchvision.models.detection.fasterrcnn_resnet50_fpn() dengan argumen pretrained=True, yang berarti bobot model diinisialisasi dengan versi yang sudah dilatih sebelumnya. Kemudan model diatur ke mode evaluasi dengan model_.eval() untuk memastikan lapisan-lapisan yang ada berfungsi secara deterministik selama inferensi. Kode kemudian membekukan bobot model dengan mengatur requires_grad = False untuk setiap parameter, mencegah pembaruan selama inferensi.

# Function to get predictions from the model
def model(x):
    with no_grad():
        yhat = model_(x)
    return yhat

Fungsi model di atas digunakan menghasilkan prediksi dari model deteksi objek yang sudah dilatih sebelumnya.

# COCO class names
COCO_INSTANCE_CATEGORY_NAMES = [
    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat',
    'traffic light', 'fire hydrant', 'N/A', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
    'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A', 'handbag',
    'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',
    'skateboard', 'surfboard', 'tennis racket', 'bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon',
    'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',
    'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table', 'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop',
    'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book',
    'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]

List di atas COCO_INSTANCE_CATEGORY_NAMES berisikan nama-nama kelas yang digunakan dalam dataset COCO (Common Objects in Context).

Deteksi Model

Setelah model siap, selanjutnya kita akan mencoba menggunakan model faster rcnn untuk memprediksi objek dalam berbagai gambar. Berikut beberapa contoh gambar yang akan kita lakukan deteksi objek di dalamnya

1. Deteksi pada gambar berisikan satu orang.

2. Deteksi pada gambar berisikan beberapa orang dalam satu gambar.

3. Deteksi anjing dan kucing.

4. Deteksi mobil dan pesawat

5. Deteksi pada gambar yang diunduh dari internet.

# 1. Predicting a Person
img_path = '/kaggle/input/sample-images-for-object-detection/ronaldo.jpg'
image = Image.open(img_path)
image = image.resize([int(0.5 * s) for s in image.size])
plt.imshow(image)
plt.show()

transform = transforms.Compose([transforms.ToTensor()])
img = transform(image)
pred = model([img])
pred_class = get_predictions(pred, objects=["person"])
draw_box(pred_class, img)
save_RAM(image_=True)

# 2. Predicting People
img_path = '/kaggle/input/sample-images-for-object-detection/people.jpg'
image = Image.open(img_path)
image = image.resize([int(0.5 * s) for s in image.size])
plt.imshow(image)
plt.show()

img = transform(image)
pred = model([img])
pred_thresh = get_predictions(pred, threshold=0.9, objects=["person"])
draw_box(pred_thresh, img, rect_th=1, text_size=1, text_th=1)
save_RAM(image_=True)

# 3. Predicting Cat and Dog
img_path = '/kaggle/input/sample-images-for-object-detection/catanddog.jpg'
image = Image.open(img_path)
image = image.resize([int(0.5 * s) for s in image.size])
plt.imshow(image)
plt.show()

img = transform(image)
pred = model([img])
pred_thresh = get_predictions(pred, threshold=0.8)
draw_box(pred_thresh, img, rect_th=10, text_size=10, text_th=10)
save_RAM(image_=True)

# 4. Predicting a Car and a Plane
img_path = '/kaggle/input/sample-images-for-object-detection/carandplane.jpg'
image = Image.open(img_path)
image = image.resize([int(0.5 * s) for s in image.size])
plt.imshow(image)
plt.show()

img = transform(image)
pred = model([img])
pred_thresh = get_predictions(pred, threshold=0.9)
draw_box(pred_thresh, img)
save_RAM(image_=True)

# 5. Predicting on an Uploaded Image
url = 'https://www.plastform.ca/wp-content/themes/plastform/images/slider-image-2.jpg'
image = Image.open(requests.get(url, stream=True).raw).convert('RGB')
plt.imshow(image)
plt.show()

img = transform(image)
pred = model([img])
pred_thresh = get_predictions(pred, threshold=0.95)
draw_box(pred_thresh, img, rect_th=2, text_size=1.5, text_th=2)
save_RAM(image_=True)

Penutup

Pada artikel ini, kita sudah mencoba menggunakan model Faster R-CNN untuk melakukan deteksi objek. Apa yang kita lakukan barusan hanya bagian kecil, sehingga masih banyak eksplorasi lanjutan yang bisa kita coba sendiri nantinya. Seperti mencobanya pada data lain, otak-atik pada nilai threshold yang ada, sampai melakukan fine tuning pada model agar bisa melakukan deteksi objek pada benda-benda yang lebih banyak. Semoga artikel ini bermanfaat, terima kasih dan selamat belajar.

Source Code : Github / Kaggle

Pada artikel ini, kita akan menggunakan PyTorch untuk membuat model sederhana untuk klasifikasi digit tulisan tangan. Kita akan belajar dari mulai membuat model, melatih, dan melakukan evaluasi. Serta bagaimana cara menyimpan model yang telah dilatih agar bisa digunakan kembali di masa yang akan datang.

Mengimpor Library yang Diperlukan

Berikut library-library yang akan digunakan pada project ini

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
from ignite.engine import Events, create_supervised_trainer, create_supervised_evaluator
from ignite.metrics import Accuracy, Loss
from ignite.handlers import EarlyStopping
from ignite.contrib.handlers import ProgressBar

Pada blok kode di atas, kami mengimpor modul-modul terkait yang esensial. torch adalah pustaka inti PyTorch. nn digunakan untuk membuat neural network. DataLoader digunakan untuk memuat data dalam batch, membuatnya lebih mudah dikelola saat pelatihan. datasets dan transforms dari torchvision digunakan untuk mengunduh dataset MNIST dan mengubah gambar menjadi tensor. ignite digunakan membuat proses pelatihan model lebih transparan.

Mengunduh Dataset dan Membuat Data Loader

Di sini kita akan menggunakan dataset MNIST, dataset ini terdiri dari 60.000 gambar digit tulisan tangan. Dataset akan dibagi menjadi dua subset terpisah untuk melatih dan menguji model AI. Gambar-gambar dalam dataset MNIST berukuran 28x28 piksel.

training_data = datasets.MNIST(
    root="data",
    train=True,
    download=True,
    transform=transforms.ToTensor()
)

test_data = datasets.MNIST(
    root="data",
    train=False,
    download=True,
    transform=transforms.ToTensor()
)

batch_size = 64
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

Kode di atas menunjukkan proses mengunduh data train dan data test MNIST. Dataset ini telah tersedia di library torchvision dan bisa dengan dengan mudah digunakan untuk eksperimen. Parameter root digunakan untuk menentukan lokasi penyimpanan data, train=True menunjukkan bahwa ini adalah data latih, download=True mengindikasikan bahka kita akan mengunduhnya jika belum ada, dan transform=transforms.ToTensor() mengonversi gambar menjadi tensor PyTorch. Selanjutnya menggunakan DataLoader kita membuat iterator untuk data train dan data test, yang mana akan memuat data dalam batch berukuran 64.

Mendefinisikan Model

Selanjutnya adalah mendefinisakn model jaringan saraf dengan lapisan input, lapisan hidden, dan lapisan output. Model ini menggunakan fungsi aktivasi ReLU di antara lapisan-lapisan tersebut. Karena gambar input adalah tensor 1x28x28, maka kita akan meratakannya menjadi tensor 784 elemen sebelum meneruskannya ke model:

class NeuralNetwork(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(input_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, num_classes)
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

input_size = 28 * 28
hidden_size = 512
num_classes = 10
model = NeuralNetwork(input_size, hidden_size, num_classes)

Kelas NeuralNetwork mewarisi dari nn.Module, yang merupakan kelas dasar untuk semua modul jaringan saraf di PyTorch. Dalam metode __init__, kita mendefinisikan lapisan-lapisan jaringan. nn.Flatten() digunakan untuk meratakan tensor input. Lapisan nn.Linear merupakan lapisan fully connected yang menjadi inti dari model kita, dan nn.ReLU adalah fungsi aktivasi.

Pelatihan dan Evaluasi

Selanjutnya adalah membuat loop untuk pelatihan dan evaluasi, proses ini merupakan inti dari pelatihan model menggunakan PyTorch

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

Di sini kita tentukan perangkat yang akan digunakan untuk pelatihan model. Apabila kita memiliki GPU, maka perangkat tersebut akan digunakan. Jika tidak, maka CPU yang akan digunakan. Selanjutnya adalah memindahkan model yang telah dibuat ke perangkat yang telah ditentukan (entah CPU atau GPU).

learning_rate = 1e-3
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

Selanjutnya adalah mengatur laju learning rate untuk optimizer. Di sini kita memilih 0,001 (1e-3). Learning rate akan menentukan seberapa besar pembaharuan bobot yang akan dilakukan oleh model selama pelatihan. Selanjutnya adalah menentukan nn.CrossEntropyLoss adalah fungsi kerugian yang umum digunakan untuk tugas klasifikasi dengan beberapa kelas. Terakhir kita mendefinisikan optimizer yang akan digunakan untuk memperbarui parameter model. Kita menggunakan torch.optim.Adam, dan model.parameters() untuk memberikan parameter model yang akan diperbarui oleh optimizer. Di sini juga kita memasukkan learning rate yang sudah ditetapkan sebelumnya.

trainer = create_supervised_trainer(model, optimizer, loss_fn, device=device)

evaluator = create_supervised_evaluator(model, 
                                        metrics={'accuracy': Accuracy(), 'loss': Loss(loss_fn)}, 
                                        device=device)
pbar = ProgressBar(persist=True)
pbar.attach(trainer)

Kemudian kita membuat objek trainer dan evaluator menggunakan ignite. Jika biasanya membuat kode untuk training dan evaluasi secara manual, di sini kita menggunakan create_supervised_trainer dan create_supervised_evaluator dari ignite. Dengan menggunakan Ignite, kode kita bisa lebih bersih dan lebih mudah dipahami. Selanjutnya adalah progress bar menggunakan ignite.contrib.handlers.ProgressBar untuk memantau proses pelatihan. Progress bar ini kemudian dihubungkan ke objek trainer.

train_losses = []
val_losses = []

Sebelum memulai pelatihan kita menginisialisasi dua list kosong untuk menyimpan nilai loss pada proses training dan validasi yang nantinya akan divisualisasikan.

@trainer.on(Events.EPOCH_COMPLETED)
def log_training_results(trainer):
    evaluator.run(train_dataloader)
    metrics = evaluator.state.metrics
    train_loss = metrics['loss']
    train_losses.append(train_loss)
    print(f"Training Results - Epoch: {trainer.state.epoch}  Avg loss: {train_loss:.2f}")

@trainer.on(Events.EPOCH_COMPLETED)
def log_validation_results(trainer):
    evaluator.run(test_dataloader)
    metrics = evaluator.state.metrics
    val_loss = metrics['loss']
    val_losses.append(val_loss)
    print(f"Validation Results - Epoch: {trainer.state.epoch}  Avg loss: {val_loss:.2f}")

Blok kode di atas adalah fungsi-fungsi yang akan dijalankan setiap kali satu epoch pelatihan selesai. Evaluator training dijalankan pada data pelatihan untuk menghitung metrik (akurasi dan loss). Nilai loss training disimpan dalam list train_losses dan ditampilkan. Begitu juga evaluator validation dijalankan pada data tes untuk menghitung metrik (akurasi dan loss). Nilai validation loss disimpan dalam list val_losses dan ditampilkan.

handler = EarlyStopping(patience=5, score_function=lambda engine: -engine.state.metrics['loss'], trainer=trainer)
evaluator.add_event_handler(Events.COMPLETED, handler)
trainer.run(train_dataloader, max_epochs=10)

Kemudian kita juga akan menerapkan early stopping menggunakan ignite.handlers.EarlyStopping. Adanya Early stopping berfungsi untuk menghentikan proses training ketika validation loss tidak membaik setelah sejumlah epoch tertentu (dalam hal ini 5 epoch). Handler early stopping ini kemudian ditambahkan ke evaluator. Dan terakhir kita menjalankan pelatihan model menggunakan objek trainer pada data pelatihan sebanyak 10 epoch.

plt.plot(train_losses, label='Training loss')
plt.plot(val_losses, label='Validation loss')
plt.legend()
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.title('Training and Validation Loss')
plt.show()

Setelah proses pelatihan selesai kita lakukan plotting loss pada data training dan validation untuk melihat progres kinerja model sepanjang pelatihan.

Menyimpan Model dan Visualisasi Hasil

Setelah model dilatih, kita dapat menyimpan parameter model dan agar bisa digunakan kembali untuk melakukan inferensi. Agar bisa lebih mudah dipahami, kita juga akan memvisualisasikan gambar-gambar yang diprediksi beserta labelnya.

torch.save(model.state_dict(), "ml_with_pytorch_model.pth")
print("Saved PyTorch Model State to ml_with_pytorch_model.pth")

model = NeuralNetwork(input_size, hidden_size, num_classes)
model.load_state_dict(torch.load("ml_with_pytorch_model.pth"))
model.to(device)

model.eval()
fig, axes = plt.subplots(1, 10, figsize=(15, 3))
for i in range(10):
    x, y = test_data[i][0], test_data[i][1]
    with torch.no_grad():
        x = x.unsqueeze(0).to(device)
        pred = model(x)
        predicted, actual = pred[0].argmax(0).item(), y

    axes[i].imshow(x.cpu().squeeze(), cmap='gray')
    axes[i].set_title(f'Pred: {predicted}\nAct: {actual}')
    axes[i].axis('off')

plt.show()

Dengan melakukan visualisasi terhadap hasil, kita bisa mendapatkan bayangan bagaimana model bisa melakukan prediksi.

Kesimpulan

Pada artikel ini, kita telah membahas bagaimana menggunakan PyTorch untuk membuat, melatih, dan mengevaluasi model neural network sederhana untuk klasifikasi digit tulisan tangan menggunakan dataset MNIST. PyTorch merupakan salah satu framework yang paling banyak digunakan saat ini. Mengetahui banyak framework akan sangat berguna karena akan membuat kita lebih fleksibel dan untuk bekerja dan eksplorasi dalam bidang machine learning. Terimakasih sudah membaca artikel ini, terus berlatih dan selamat belajar.

Source Code : Kaggle / Github

Apa itu LangChain?

LangChain merupakan ekosistem yang menyediakan sejumlah modul dan tools untuk membangun aplikasi LLMs. Dengan LangChain, pengembang dapat dengan mudah mengintegrasikan berbagai model LLM, baik itu yang berbayar seperti GPT-3 dari OpenAI, maupun model open source melalui platform seperti Hugging Face. LangChain memungkinkan penggunaan modul-modul penting yang diperlukan untuk membangun chatbot, seperti template prompt, parser output, dan lainnya.

Mengapa Menggunakan LangChain?

LangChain menawarkan beberapa keuntungan utama bagi pengembang:

1. Kemudahan Integrasi: LangChain mempermudah integrasi berbagai model LLMs ke dalam aplikasi. Dengan modul yang telah terstruktur dengan baik, pengembang tidak perlu menulis banyak kode boilerplate untuk menghubungkan model dengan aplikasi mereka.

2. Fleksibilitas: LangChain mendukung penggunaan berbagai model, baik berbayar maupun open source, sehingga pengembang dapat memilih model yang paling sesuai dengan kebutuhan mereka.

3. Monitoring dan Tracing: LangChain memiliki fitur monitoring dan tracing yang memungkinkan pengembang melacak performa dan penggunaan model dalam aplikasi mereka secara real-time. Ini membantu dalam debugging dan pengoptimalan aplikasi.

Langkah Awal dalam Membangun Chatbot

Untuk memulai pembangunan chatbot dengan LangChain, ada beberapa langkah dasar yang perlu dilakukan:

1. Membuat Virtual Environment: Penting untuk membuat lingkungan virtual menggunakan tools seperti conda atau venv agar dependensi proyek terisolasi dan mudah dikelola.

2. Mengatur Environment Variable: Menyimpan kunci API dan informasi penting lainnya dalam variabel lingkungan untuk menjaga keamanan dan kemudahan akses dalam kode.

3. Menggunakan Template Prompt: Template prompt digunakan untuk mendefinisikan cara chatbot merespon input dari pengguna. Ini termasuk sistem prompt yang memberi instruksi dasar pada model dan user prompt yang menerima input dari pengguna.

4. Menggunakan Output Parser: Output parser digunakan untuk memproses output dari model LLM sehingga dapat ditampilkan atau digunakan lebih lanjut dalam aplikasi.

Studi Kasus: Chatbot dengan GPT-3 dan Model Open Source

Dalam tutorial ini, kita akan membuat dua jenis chatbot:

1. Chatbot dengan API Berbayar: Menggunakan GPT-4o dari OpenAI, kita akan menunjukkan bagaimana cara mengatur dan mengintegrasikan model ini ke dalam aplikasi chatbot menggunakan LangChain.

2. Chatbot dengan Model Open Source: Menggunakan model open source seperti Phi3, kita akan melihat bagaimana cara mendownload dan menggunakan model ini secara lokal dalam aplikasi chatbot.

Implementasi Kode Chatbot dengan GPT-4o Mini dan Ollama Phi 3

Kode 1: Chatbot dengan OpenAI GPT-4o Mini

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser 

import streamlit as st
import os
from dotenv import load_dotenv

Bagian ini mengimpor berbagai library yang diperlukan, termasuk ChatOpenAI dari langchain_openai, ChatPromptTemplate dan StrOutputParser dari langchain_core, serta streamlit untuk membangun antarmuka web. Library os dan dotenv digunakan untuk mengelola variabel lingkungan yang menyimpan kunci API.

os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")

Mengatur variabel lingkungan OPENAI_API_KEY dan LANGCHAIN_API_KEY untuk mengaktifkan tracing dan pemantauan menggunakan LangChain.

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Please respond to the queries"),
    ("user", "Question:{question}"),
])

Template prompt dibuat menggunakan ChatPromptTemplate yang berisi dua bagian: instruksi sistem dan pertanyaan pengguna. Template ini akan digunakan untuk memandu model dalam memberikan respon.

st.set_page_config(
    page_title="Chatbot",
    page_icon=":robot:"
)

st.header("GPT 4o Mini Chatbot")

input_text = st.text_input("Search the topic u want")

Antarmuka Streamlit diatur dengan menambahkan konfigurasi halaman, termasuk judul dan ikon, serta menampilkan header dan input teks untuk pengguna memasukkan pertanyaan.

llm =ChatOpenAI(model="gpt-4o-mini")
output_parser = StrOutputParser()
chain=prompt|llm|output_parser

Model GPT-4o Mini dikonfigurasi menggunakan ChatOpenAI, dan keluaran model diproses menggunakan StrOutputParser. Semua komponen ini dirangkai menjadi satu rantai menggunakan operator |.

if input_text:
    st.write(chain.invoke({"question": input_text}))

Jika ada input dari pengguna, rantai dieksekusi dengan input tersebut dan hasilnya ditampilkan menggunakan st.write.

Kode 2: Chatbot dengan Phi 3

Untuk model open source, kita akan menggunakan Ollama untuk menjalankannya dari local. Di sini kita menggunakan model Phi3, model ini dipilih karena ukurannya yang relatif kecil. Anda dipersilahkan untuk menggunakan model lainnya jika memiliki sumber daya komputasi yang mencukupi. Untuk melihat model-model yang tersedia anda bisa melihatnya di github Ollama.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser 
from langchain_ollama import ChatOllama
import streamlit as st
import os
from dotenv import load_dotenv

load_dotenv()

Di sini kita modul yang sama dan mengganti ChatOpenAI dengan ChatOllama untuk model Ollama untuk menggunakan Phi 3. Kita juga mengatur variabel lingkungan dengan cara yang sama untuk mengaktifkan tracing dan pemantauan dengan LangChain.

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")

Mengatur variabel lingkungan sama seperti pada kode sebelumnya.

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Please respond to the queries"),
    ("user", "Question:{question}"),
])

Template prompt yang sama digunakan untuk memberikan instruksi kepada model.

st.set_page_config(
    page_title="Chatbot",
    page_icon=":robot:"
)

st.header("Phi 3 Chatbot")

input_text = st.text_input("Search the topic u want")

Antarmuka Streamlit diatur dengan header yang berbeda untuk membedakan antara chatbot GPT-4o Mini dan Phi 3.

llm =ChatOllama(model="phi3")
output_parser = StrOutputParser()
chain=prompt|llm|output_parser

Model Phi 3 dikonfigurasi menggunakan ChatOllama, dan keluaran model diproses dengan StrOutputParser. Komponen ini dirangkai menjadi satu rantai menggunakan operator |.

if input_text:
    st.write(chain.invoke({"question": input_text}))

Jika ada input dari pengguna, hasilnya ditampilkan menggunakan st.write.

Gambar di atas merupakan contoh kedua chatbot ketika menerima prompt "tell me a funny dad joke". Kita bisa melihat bahwa meskipun memiliki ukuran lebih kecil dan gratis, phi3 tetap bisa memberikan jawaban yang relevan. Oleh karena itu, kita bisa mempertimbangkan penggunaan model-model open source pada project kita sebagai alternatif dari model GPT.

Penutup

Mengembangkan chatbot yang efisien dan responsif kini semakin mudah dengan adanya ekosistem seperti LangChain. Melalui integrasi yang mulus dan penggunaan modul-modul yang terstruktur dengan baik, LangChain mempermudah pengembang untuk menghubungkan berbagai model bahasa, baik berbayar seperti GPT dari OpenAI maupun open source seperti Phi-3.

Pada artikel ini, kita telah melihat langkah-langkah dasar dalam membangun chatbot, mulai dari membuat lingkungan virtual hingga menggunakan template prompt dan output parser. Dengan contoh implementasi menggunakan GPT-4o Mini dan Phi-3, kita dapat melihat bagaimana kedua model ini bisa diintegrasikan ke dalam aplikasi chatbot dengan mudah dan efisien.

Meskipun model berbayar seperti GPT menawarkan kinerja yang sangat baik, model open source seperti Phi-3 juga menunjukkan potensi besar dalam memberikan respons yang relevan dan berguna. Oleh karena itu, pengembang dapat mempertimbangkan penggunaan model-model open source sebagai alternatif yang lebih ekonomis tanpa mengorbankan kualitas.

Dengan LangChain, kita memiliki fleksibilitas untuk memilih model yang paling sesuai dengan kebutuhan proyek kita, serta kemampuan untuk memantau dan mengoptimalkan performa chatbot secara real-time. Ini membuka peluang baru bagi pengembangan aplikasi chatbot yang lebih canggih dan responsif di berbagai bidang. Terima kasih sudah membaca artikel ini, tetap semangat dan selamat belajar!

Source code : Github

Transformers di Bidang NLP

Apa itu Large Language Models?

Belakangan ini, kata GPT-4 dan ChatGPT semakin popoler di kalangan masyarakat umum. Kedua istilah ini mengacu pada Large Language Models/LLMs, yaitu jenis AI yang mampu memahami dan menghasilkan teks menyerupai manusia. LLM dapat digunakan untuk menjawab pertanyaan, menghasilkan konten, merangkum teks, menjelaskan suatu hal, dan membuat dialog. Penggunaan LLM dalam keseharian bisa ditemui pada sistem seperti chatbot, asisten virtual, dan aplikasi penerjemah. Namun, perkembangan dalam riset Natural Language Processing (NLP) sendiri telah booming jauh sebelum populernya GPT dan ChatGPT. Tepatnya sejak 2017, ketika tim peneliti dari Google mengusulkan arsitektur model AI yang disebut Transformer dalam makalah "Attention is All You Need".

Cara kerja LLM adalah kita berinteraksi dengannya menggunakan teks biasa, yang sering disebut sebagai prompt, kemudian model tersebut akan merespon dengan teks yang disebut completion atau output. Misalnya, jika kita ingin tahu apakah suatu buku itu menarik, kita bisa meminta LLM untuk merangkum beberapa bab awal dari buku tersebut.

Bagaimana sebuah LLM dilatih? Pre-training

Pada awalnya, LLM memiliki bobot acak dan belum mempunyai pengetahuan tentang bahasa. Ketika prompt diberikan di tahap ini, model hanya akan berhalusinasi. Namun, dengan melatih model menggunakan sejumlah data berukuran besar, model akan menyesuaikan bobotnya sebagai bagian dari proses pelatihan. Tahap pre-training ini sangat membutuhkan sumber daya yang sangat besar. Sebagai contoh, LLaMA, yang dirilis oleh Meta pada tahun 2023, menggunakan campuran data dari Common Crawl, C4, GitHub, Wikipedia, buku, artikel ilmiah, dan tanya jawab dari Stack Exchange. Setiap set data ini diambil dengan proporsi tertentu selama pelatihan, di mana model melihat sampel data beberapa kali (epoch).

Sumber gambar : https://arxiv.org/pdf/2302.13971

Selain dari segi data, pelatihan LLM juga membutuhkan sumber daya komputasi yang amat sangat besar, pada umumnya dilakukan di ruang server dengan ratusan hingga ribuan unit GPU di dalamnya. Proses ini bisa memakan waktu hingga beberapa minggu atau bulan serta biaya hingga jutaan dolar AS. Hasil akhirnya adalah model seperti GPT-3 dari OpenAI, yang mana ia mampu menghasilkan teks bahasa Inggris yang cukup manusiawi. Namun, model ini belum tentu bisa mengikuti instruksi dengan baik. Oleh karena itu, untuk membuat LLM berfungsi sebagai asisten virtual yang efektif, diperlukan tambahan langkah agar model dapat mengikuti instruksi dengan lebih baik.

Membuat LLM mengikuti instruksi

Sebagaimana telah disebut sebelumnya, suatu LLM pada awalnya tidak dapat mengikuti instruksi dengan baik. Pada tahun 2022, OpenAI merilis penelitian berjudul "Training Language Models to Follow Instructions with Human Feedback". Proses pelatihan di sini melibatkan dua komponen utama: supervised fine-tuning dan reinforcement learning with human feedback (RLHF). Dalam fine-tuning terawasi, peneliti membuat prompt dan labeler yang ahli dalam data teks menulis output yang diharapkan. Model dilatih menggunakan prompt dan output ini agar semakin mahir menghasilkan teks yang sesuai dengan harapan labeler.

Sumber gambar : https://medium.com/@yash9439/introduction-to-llms-and-the-generative-ai-part-3-fine-tuning-llm-with-instruction-and-326bc95e07ae

Reinforcement learning dari umpan balik manusia (RLHF) melibatkan labeler yang menilai beberapa output dari model berdasarkan prompt tertentu. Misalnya, untuk tugas merangkum artikel berita, model akan menghasilkan beberapa ringkasan yang kemudian dinilai oleh labeler. Model bahasa kemudian dioptimalkan menggunakan reinforcement learning, di mana model dihargai jika menghasilkan teks yang mengikuti instruksi dengan baik serta tidak bersifat toksik atau tidak benar. Metode ini telah menghasilkan model bahasa yang jauh lebih baik dalam mengikuti instruksi,

Komponen di Dalam LLM

Arsitektur Transformer

Model bahasa besar terdiri dari beberapa komponen, salah satunya adalah arsitektur transformer yang terdiri dari encoder dan decoder. Encoder menerima input teks, seperti "I like this movie," dan mengubahnya menjadi representasi yang dapat dipahami oleh model. Decoder kemudian menggunakan representasi ini untuk menghasilkan output, seperti menerjemahkan teks ke dalam bahasa Indonesia, "Saya suka film ini." Transformer tidak hanya memiliki satu encoder dan satu decoder, tetapi enam encoder dan enam decoder yang bekerja bersama melalui mekanisme attention. Mekanisme ini memungkinkan model untuk fokus pada bagian-bagian penting dari teks input, sehingga dapat menangkap pemahaman yang lebih mendalam dan kompleks tentang semantik bahasa. Encoder-dekoder digunakan untuk tugas generatif seperti terjemahan dan ringkasan, sementara encoder saja digunakan untuk tugas pemahaman bahasa seperti klasifikasi kalimat.

Sumber Gambar : Attention Is All You Need

Model seperti BERT (Bidirectional Encoder Representations from Transformers) menggunakan hanya encoder saja, model ini efektif untuk tugas-tugas yang memerlukan pemahaman bahasa yang baik, seperti klasifikasi teks. Sementara itu, model seperti ChatGPT, GPT-3, dan GPT-4 menggunakan decoder saja dan efektif untuk tugas generatif seperti pembuatan teks.

Apa itu Parameter?

Ketika membahas LLM, kita sering merujuk pada ukuran model atau jumlah parameternya. Sebagai contoh, GPT-3 memiliki 175 miliar parameter, sementara model terbesar Llama 2 dari Meta memiliki 70 miliar parameter. Parameter dalam jaringan neural adalah variabel yang dipelajari model selama proses pelatihan. Mereka disesuaikan untuk meminimalkan perbedaan antara output yang diprediksi dan output aktual. Dalam jaringan neural, node (disebut juga neuron) menerima input, memprosesnya, dan meneruskan output ke node lain. Setiap koneksi antara node memiliki bobot, yang disesuaikan selama pelatihan. Selain bobot, ada juga istilah bias yang membantu menyesuaikan output.

sumber : https://www.linkedin.com/learning/introduction-to-large-language-models/

Contoh di atas adalah suatu neural network yang di dalamnya terdapat lapisan input, lapisan tersembunyi, dan lapisan output, di mana setiap node di satu lapisan terhubung dengan setiap node di lapisan berikutnya. Untuk menghitung jumlah parameter, kita mengalikan jumlah node di dua lapisan yang terhubung dan menambahkan jumlah bias. Misalnya, jaringan dengan tiga node input, dua lapisan tersembunyi dengan empat node masing-masing, dan satu node output akan memiliki total 41 parameter. Sebagian besar LLM saat ini memiliki miliaran parameter, angka ini menunjukkan kompleksitas dan kemampuan mereka untuk mempelajari dan memproses bahasa. Parameter ini adalah kunci dalam menentukan seberapa baik model dapat melakukan tugas-tugas tertentu.

Apa itu Token?

Yang dihasilkan oleh suatu LLM bukanlah berupa teks kata demi kata, melainkan menghasilkan token. Token merupakan pecahan kata yang lebih kecil, di mana satu token kira-kira terdiri dari empat karakter teks. Tokenisasi adalah proses membagi kata menjadi bagian-bagian yang lebih kecil atau token. Pada umumnya, sebagian besar kata akan menjadi token tersendiri, termasuk spasi di depannya. Namun, ada beberapa pengecualian. Misalnya, kata "tokenization" terdiri dari dua token, yaitu "token" dan "ization". Dalam sebuah kalimat yang terdiri dari 3 kata, dapat terpecah menjadi 5 token, di mana tanda tanya di akhir kalimat juga dihitung sebagai satu token.

Kita dapat menggunakan tool Tokenizer di situs OpenAI untuk bisa mencoba ibarat seperti gambar di atas. Ketika memasukkan teks ke dalam Tokenizer, kita akan melihat bahwa setiap warna berbeda menunjukkan token yang berbeda. Ini membantu kita memahami bagaimana kata-kata dipecah menjadi token-token kecil. Dengan memahami konsep token, kita dapat mengerti bagaimana LLM memproses dan menghasilkan teks dengan lebih efisien, menggunakan unit-unit yang lebih kecil alih-alih menggunakan satu kata utuh.

Apa itu Context Length?

Panjang konteks (Context length) adalah jumlah total token yang dapat diingat oleh LLM dalam suatu percakapan. Panjang konteks mengacu pada jumlah total token dari prompt dan completion yang diingat oleh model untuk menghasilkan respons yang lebih relevan dan bermakna. Misalnya, gpt-3.5-turbo memiliki panjang konteks sekitar 16,385 token dan gpt-4-turbo memiliki 128,000 token, konteks yang lebih panjang memungkinkan pemrosesan teks yang lebih banyak dan detail.

Kemampuan model dengan panjang konteks yang lebih besar memungkinkan mereka untuk menjawab pertanyaan tentang teks yang panjang dengan cepat dan akurat. Misalnya, model gpt-4o bisa menerima seluruh isi buku Naar de 'Republiek Indonesia' karya Tan Malaka yang memiliki total 13604 kata dengan keseluruhan token 30415 token dalam satu jendela konteks.

Hukum Skalabilitas

Pada tahun 2020, bidang teknologi mengalami lonjakan eksperimen setelah kemunculan arsitektur transformer yang diperkenalkan pada 2017. Berbagai perusahaan fokus pada bagian encoder atau decoder, dan ada jugayang mencoba meningkatkan performa model secara keseluruhan. Di saat inilah tim riset OpenAI menemukan kesimpulan bahwa performa model besar bergantung pada jumlah parameter model, ukuran dataset yang digunakan untuk pelatihan, dan total daya komputasi yang tersedia. Mereka melakukan berbagai eksperimen yang menunjukkan bahwa semakin besar model dan dataset, serta semakin banyak komputasi yang digunakan, semakin rendah test loss, yang berarti performa model semakin baik.

Sumber : https://arxiv.org/pdf/2001.08361

Grafik hasil eksperimen menunjukkan bahwa menambah jumlah layer, ukuran dataset, dan daya komputasi dapat meningkatkan performa model. Namun, peningkatan terbesar didapatkan dari memperbesar ukuran model. Ketika OpenAI menerbitkan hasil penelitian ini pada tahun 2020, banyak perusahaan teknologi besar mulai meningkatkan ukuran model bahasa mereka, salah satunya adalah OpenAI dengan GPT-3 yang memiliki 175 miliar parameter. Ini secara signifikan meningkatkan performa model dibandingkan model bahasa lainnya pada saat itu. Hukum skalabilitas ini menekankan bahwa untuk mendapatkan performa terbaik, ukuran model, jumlah data pelatihan, dan daya komputasi harus ditingkatkan secara bersamaan.

Sumber : https://arxiv.org/pdf/2001.08361

Beberapa Contoh Large Language Models

BERT

BERT (Bidirectional Encoder Representations from Transformers) adalah LLM yang dikembangkan oleh Google berdasarkan pada arsitektur transformer. BERT hanya menggunakan lapisan encoder transformer untuk memahami bahasa dengan lebih baik, sehingga memungkinkan search engine Google memberikan jawaban yang lebih relevan dan langsung menjawab pertanyaan pengguna. BERT memiliki sekitar 110 juta parameter dan dilatih menggunakan Wikipedia bahasa Inggris dan BookCorpus, yang terdiri dari 11.000 buku.

Sumber : https://towardsdatascience.com/bert-explained-state-of-the-art-language-model-for-nlp-f8b21a9b6270

Berbeda dengan model text generation seperti ChatGPT dan GPT-4, BERT dilatih untuk melakukan dua tugas khusus: masked language modeling (MLM) dan next sentence prediction (NSP). Pada tugas MLM, BERT harus menebak kata yang disembunyikan dalam sebuah kalimat, sementara tugas NSP memintanya menentukan apakah dua kalimat berurutan secara logis. Tugas-tugas ini membuat BERT memiliki pemahaman yang mendalam tentang bahasa, sehingga sangat berguna dalam meningkatkan akurasi hasil pencarian Google. Meskipun BERT tidak digunakan untuk menghasilkan teks, kemampuannya dalam memahami bahasa menjadikannya sangat efektif dalam berbagai penerapan.

Contoh hasil search engine pasca BERT. Di mana hasil pencarian juga memberikan highlight pada kata-kata terkait.

GPT-3

GPT-3 merupakan salah satu LLM yang paling terkenal, dikembangkan oleh OpenAI. Nama GPT-3 mewakili tiga konsep utama: generatif (generative), yang berarti memprediksi token berikutnya berdasarkan token sebelumnya; pre-trained, yang berarti model ini dilatih dengan data dalam jumlah besar seperti Wikipedia bahasa Inggris; dan transformer, yang menggunakan bagian decoder dari arsitektur transformer. GPT-3 memiliki 175 miliar parameter dan dilatih untuk tugas prediksi token berikutnya. Selain itu, GPT-3 mendukung few-shot learning, yang memungkinkan model ini menyelesaikan berbagai tugas baru dengan memberikan beberapa contoh saja.

Sumber : https://arxiv.org/pdf/2005.14165

Sebelumnya, LLM perlu dilatih ulang untuk setiap tugas spesifik seperti analisis sentimen atau menjawab pertanyaan, dengan memberikan ratusan contoh berlabel. Namun, dengan GPT-3, para peneliti menemukan bahwa model yang sangat besar ini dapat melakukan berbagai tugas baru hanya dengan beberapa contoh dan instruksi yang jelas. I Hasil penelitian menunjukkan bahwa model GPT-3 yang lebih besar, dengan 175 miliar parameter, mampu mencapai akurasi yang lebih tinggi dibandingkan model yang lebih kecil, membuatnya lebih fleksibel dan serbaguna dalam menangani berbagai tugas tanpa pelatihan khusus untuk masing-masing tugas.

Chinchilla

Selama bertahun-tahun, tren dalam pengembangan LLM adalah memperbesar ukuran model. Namun, hipotesis muncul tim dari DeepMind yang berpendapat bahwa LLM selama ini dilatih dengan data yang kurang memadai. Mereka berpendapat bahwa performa model yang ada bisa jauh lebih baik dengan melatih model yang lebih kecil namun dengan jumlah data yang lebih banyak dan dalam waktu yang lebih lama. Untuk menguji hipotesis ini, tim DeepMind melatih beberapa ratus model bahasa dengan ukuran bervariasi dari 70 juta hingga 16 miliar parameter, dan melatihnya dengan berbagai jumlah data dari lima hingga 500 miliar token. Berdasarkan hasil eksperimen ini, mereka menciptakan Chinchilla, model dengan 70 miliar parameter yang dilatih dengan 1,4 triliun token.

Sumber : https://arxiv.org/pdf/2203.15556

Hasilnya, Chinchilla, meskipun lebih kecil dari model lain seperti Gopher (280 miliar parameter), GPT-3 (175 miliar parameter), dan Megatron-Turing (530 miliar parameter), memberikan performa yang lebih baik pada berbagai tugas bahasa. Hal ini mengindikasikan bahwa dengan ukuran komputasi yang sama, model yang lebih kecil namun dilatih dengan lebih banyak data dapat menghasilkan kinerja yang lebih baik. Eksperimen menunjukkan bahwa menyeimbangkan ukuran model dan jumlah data pelatihan adalah kunci untuk mencapai performa optimal. Chinchilla dilatih dengan lebih dari empat kali jumlah data dibandingkan LLM lainnya, menjadikannya model yang lebih efisien dan unggul dalam banyak tugas pemahaman bahasa.

Sumber : https://arxiv.org/pdf/2203.15556

PaLM dan PaLM 2

Google merilis PaLM (Pathways Language Model) pada April 2022, yang merupakan salah satu model bahasa terbesar dengan 540 miliar parameter. PaLM dilatih menggunakan sistem Pathway, yang memungkinkan penggunaan lebih banyak akselerator perangkat keras untuk efisiensi pelatihan. Model ini dilatih pada 780 miliar token dari korpus multibahasa yang mencakup lebih dari 100 bahasa, dengan sekitar 75% dari data pelatihan dalam bahasa Inggris. Studi menunjukkan bahwa model dengan 8 miliar parameter mampu melakukan tugas tertentu seperti menjawab pertanyaan dan pemahaman bahasa, sementara model dengan 62 miliar parameter dapat menangani terjemahan, ringkasan, dan penalaran umum. Namun, diperlukan lonjakan signifikan hingga 540 miliar parameter untuk menangani tugas-tugas seperti pengetahuan umum dan pemahaman terhadap bacaan. PaLM melampaui model seperti Gopher dan Chinchilla dalam berbagai tolok ukur pemahaman dan generasi bahasa alami.

Pada Mei 2023, Google merilis PaLM 2 yang mengungguli kemampuan PaLM. Meskipun Google tidak merilis informasi mengenai ukuran model atau jumlah data pelatihan , PaLM 2 dilatih pada lebih dari 100 bahasa dan mampu memahami serta menghasilkan teks yang lebih bernuansa. Model ini telah lulus ujian kemahiran bahasa tingkat lanjutan dan dilatih menggunakan makalah ilmiah serta artikel penelitian yang memilik banyak notasi matematika, sehingga menjadikannya lebih baik dalam menangani tugas yang berkaitan dengan logika dan penalaran. PaLM 2 juga unggul dalam menghasilkan dan mengoreksi kode dalam berbagai bahasa pemrograman. PaLM 2 berukuran terkecil bahkan dapat berjalan di perangkat seluler dan digunakan untuk memperkuat fitur di produk Google seperti Gmail dan Google Docs, serta berkontribusi dalam mengembangkan Bard, LLM lainnya dari Google. Selain itu, PaLM 2 juga digunakan untuk melatih Med-PaLM 2 yang berfokus pada data-data medis.

ChatGPT dan GPT-4

ChatGPT diluncurkan pada 30 November 2022 dan segera mencapai 100 juta pengguna aktif bulanan dalam dua bulan. ChatGPT adalah versi yang disempurnakan dari GPT-3.5, yang menggunakan teknik supervised fine-tuning dan reinforcement learning with Human Feedback (RLHF) sehingga menjadikannya lebih lihai dalam mengikuti instruksi. Hal ini membuatnya sangat efektif untuk dialog interaktif, sehingga dapat digunakan sebagai chatbot untuk membantu berbagai tugas, termasuk membantu menulis kode program. GPT-4, yang dirilis pada Maret 2023, membawa peningkatan lebih lanjut dalam hal kemampuan penalaran dan kompleksitas tugas yang dapat ditangani, contohnya pada hal-hal terkait penalaran logis. GPT-4 bahkan menunjukkan kinerja setara manusia ketika mengerjakan soal ujian sekolah menengah at. Salah satu perkembangan signifikan adalah kemampuan fine-tuning GPT-4. OpenAI juga memungkinkan fine-tuning GPT-4 sehingga memungkinkan pengguna untuk menyesuaikan model sesuai dengan kebutuhan spesifik mereka.

Sumber : https://openai.com/index/gpt-4-research/

Open LLMs

Selain model dari perusahaan teknologi besar seperti Google dan OpenAI, terdapat juga model open source dari komunitas yang menarik untuk diikuti. OpenAI memberikan akses ke GPT-3 melalui API, tetapi tidak memberikan akses ke bobot model yang memungkinkan peneliti untuk memodifikasi dan bereksperimen dengan model tersebut. Sementara itu, Meta merilis OPT (Open Pre-trained Transformers) yang terdiri dari berbagai model dekoder yang dilatih dengan parameter antara 125 juta hingga 66 miliar. Para peneliti dapat mengajukan permohonan akses ke model yang lebih besar, hingga 175 miliar parameter. Selain itu, Hugging Face bersama lebih dari 1.000 peneliti dari berbagai negara dan lembaga menciptakan model BLOOM dengan 176 miliar parameter yang semuanya terbuka untuk diakses.

Pada Februari 2023, Meta merilis model LLaMA dengan parameter 7, 13, 30, dan 65 miliar, yang hanya dapat digunakan untuk penelitian dan tujuan non-komersial. Sehingga memungkinkan peneliti untuk mengembangkan kapabilitas LLaMA lebih lanjut melalui penyetelan instruksi dan pelatihan pada data yang tidak berbahasa inggris. Model LLaMA 2 dirilis pada Juli 2023 dengan panjang konteks 4.000 token dan dilatih dengan dua triliun token. Komunitas terbuka kemudian segera menghasilkan model yang lebih baik dari LLaMA 2 dalam waktu singkat, seperti Stable Beluga 2 dari Stability AI. Meskipun LLaMA 2 tidak sepenuhnya open source dan masih memerlukan izin dari Meta selaku pembuatnya, model ini menunjukkan bahwa model terbuka bisa semakin mendekati performa model tertutup seperti ChatGPT.

Membandingkan LLM

Untuk membandingkan LLM, Stanford University mengusulkan HELM (Holistic Evaluation of Language Models) yang memberikan pandangan holistik tentang performa model dengan mengevaluasi berbagai dataset. HELM mencakup berbagai tolok ukur seperti pemahaman bahasa multitugas (MMLU) dan peringkasan teks (CNN dan Daily). HELM juga mengukur ketahanan model terhadap teks dengan kesalahan ketik atau ejaan yang salah, di mana model dengan akurasi tinggi cenderung lebih tangguh.

Selain HELM, HuggingFace menawarkan leaderboard model open source yang memungkinkan perbandingan model berdasarkan berbagai tolak ukur. Beberapa tolok ukur tersebut termasuk tantangan penalaran (ARC), inferensi akal sehat (HellaSwag), akurasi multitugas teks (MMLU), dan kemampuan menghindari kesalahan informasi umum (TruthfulQA).

Penutup

Transformasi dalam bidang natural language processing (NLP) melalui pengembangan LLM telah membuka banyak peluang baru dalam berbagai aplikasi teknologi. Dari peningkatan kualitas hasil pencarian di Google dengan BERT hingga kemampuan penalaran kompleks dari GPT-4, kemajuan ini menunjukkan potensi besar dari LLM dalam membantu dan meningkatkan berbagai aspek kehidupan manusia. Meski demikian, tantangan tetap ada, termasuk kebutuhan akan sumber daya komputasi yang besar dan masalah terkait akurasi serta ketahanan model terhadap kesalahan. Melalui kolaborasi antara komunitas riset dan perusahaan teknologi besar, serta perkembangan model open-source, kita dapat mengharapkan peningkatan lebih lanjut dalam performa dan aksesibilitas LLM di masa depan. Dengan pemahaman yang lebih mendalam tentang teknologi ini, kita dapat memanfaatkannya secara optimal untuk berbagai keperluan, dari pendidikan hingga industri. Terima kasih sudah membaca artikel ini, tetap produktif dan selamat belajar.

Sumber Konten : https://www.linkedin.com/learning/introduction-to-large-language-models/

Dalam artikel ini, kita akan membuat aplikasi translator voice to voice sederhana menggunakan Python. Di sini kita akan menggunakan Gradio untuk interface, AssemblyAI untuk pengenalan suara, pustaka translate untuk penerjemahan teks, dan ElevenLabs untuk konversi teks-ke-suara.

Mempersiapkan Environment

Sebelum memulai, pastikan kita sudah memiliki API key dan pustaka yang diperlukan Buat file .env di folder yang sama dengan projek kemudian simpan API key di file tersebut. Jangan lupa sertakan .env ke .gitignore jika ingin push kode kita ke github. Untuk mendapatkannya, kita terlebih dahulu ElevenLabs dan Assembly AI.

ELEVENLABS_API_KEY=your_elevenlabs_api_key
ASSEMBLYAI_API_KEY=your_assemblyai_api_key

Selanjutnya kita juga perlu menginstall library yang diperlukan:

pip install gradio assemblyai translate elevenlabs python-dotenv

Mengimpor Pustaka dan Memuat Konfigurasi

Pertama, kita mengimpor pustaka yang diperlukan dan memuat kunci API dari file .env.

import uuid
import gradio as gr
import assemblyai as aai
from pathlib import Path
from dotenv import dotenv_values
from translate import Translator
from elevenlabs import VoiceSettings
from elevenlabs.client import ElevenLabs

Interface web menggunakan gradio. Transkripsi audio ke teks menggunakan assemblyai. Translasi teks antar bahasa translate. Konversi teks ke suara menggunakan elevenlabs. Untuk membuat nama file yang unik menggunakan uuid. Penanganan jalur file menggunakan Path. Terakhir dotenv_values digunakan untuk memuat file .env.

Setelah mengimpor semua library yang diperlukan, selanjutnya kita memuat API key dari file .env yang sudah dibuat sebelumnya

config = dotenv_values(".env")

ELEVENLABS_API_KEY = config["ELEVENLABS_API_KEY"]
ASSEMBLYAI_API_KEY = config["ASSEMBLYAI_API_KEY"]

Transkripsi Audio

Kita menggunakan AssemblyAI untuk mentranskripsikan file audio.

def audio_transcription(audio_file):
    aai.settings.api_key = ASSEMBLYAI_API_KEY

    transcriber = aai.Transcriber()
    transcription = transcriber.transcribe(audio_file)

    return transcription

Pertama-tama kita masukkan API key untuk AssemblyAI di aai.settings.api_key. Lalu inisialisasi transcriber dengan aai.Transcriber kemudian mentranskripsikan file audio yang diberikan dengan transcribe.

Translasi Teks

Di fungsi ini kita menerjemahkan teks yang dimasukkan ke bahasa Spanyol, Arab, dan Jepang.

def text_translation(text):
    translator_es = Translator(from_lang="en", to_lang="es")
    es_text = translator_es.translate(text)

    translator_ar = Translator(from_lang="en", to_lang="ar")
    ar_text = translator_ar.translate(text)

    translator_ja = Translator(from_lang="en", to_lang="ja")
    ja_text = translator_ja.translate(text)

    return es_text, ar_text, ja_text

Pertama kita inisiasi penerjemah untuk setiap bahasa target menggunakan Translator. Selanjutnya adalah menggunakan methodtranslate untuk menerjemahkanteks dari bahasa Inggris ke bahasa target.

Teks ke suara

Terakhir kita menggunakan ElevenLabs, untuk mengonversi teks yang diterjemahkan menjadi suara.

def text_to_speech(text: str) -> str:
    client = ElevenLabs(api_key=ELEVENLABS_API_KEY)
    response = client.text_to_speech.convert(
        voice_id="pNInz6obpgDQGcFmaJgB",
        optimize_streaming_latency="0",
        output_format="mp3_22050_32",
        text=text,
        model_id="eleven_multilingual_v2",
        voice_settings=VoiceSettings(
            stability=0.5,
            similarity_boost=0.8,
            style=0.5,
            use_speaker_boost=True,
        ),
    )

    save_file_path = f"{uuid.uuid4()}.mp3"

    with open(save_file_path, "wb") as f:
        for chunk in response:
            if chunk:
                f.write(chunk)

    print(f"{save_file_path}: A new audio file was saved successfully!")

    return save_file_path

Pertama-tama kita inisialisasi variabel client dengan memanggil kelas ElevenLabs. Selanjutnya menggunakan method text_to_speech.convert kita konversikan teks menjadi ucapan dengan parameter yang telah ditentukan.

Fungsi voice_to_voice

Fungsi ini merupakan inti dari project kita. Fungsi ini akan mentranskripsikan audio input, menerjemahkannya ke sejumlah bahasa, dan mengubah terjemahan kembali menjadi audio.

def voice_to_voice(audio_file):
    transcription_response = audio_transcription(audio_file)

    if transcription_response.status == aai.TranscriptStatus.error:
        raise gr.Error(transcription_response.error)
    else:
        text = transcription_response.text

    es_translation, ar_translation, ja_translation = text_translation(text)

    es_audio_path = text_to_speech(es_translation)
    ar_audio_path = text_to_speech(ar_translation)
    ja_audio_path = text_to_speech(ja_translation)

    es_path = Path(es_audio_path)
    ar_path = Path(ar_audio_path)
    ja_path = Path(ja_audio_path)

    return es_path, ar_path, ja_path

Fungsi voice_to_voice menerima file audio sebagai parameter dan di dalamnya terjadi seluruh proses transkripsi, penerjemahan, dan konversi teks-ke-suara. Variabel transcription_response digunakan untuk menampung respons dari fungsi transkripsi. Transkripsi audio yang didapatkan kemudian diterjemahkan juga dalam bentuk teks ke bahasa Spanyol, Arab, dan Jepang. Setelah teks dalam bahasa tujuan didapatkan baru kemudian hasil terjemahan dikonversi kembali ke dalam bentuk suara.

Membuat Interface Pengguna

Untuk projek ini, kita menggunakan gradio untuk membuat interface sederhana yang mudah digunakan. Di sini pengguna dapat memasukkan audio melalui mikrofon mereka, dan mendapatkan output berupa audio yang diterjemahkan.

audio_input = gr.Audio(
    sources=["microphone"],
    type="filepath"
)

demo = gr.Interface(
    fn=voice_to_voice,
    inputs=audio_input,
    outputs=[gr.Audio(label="Spanish"), gr.Audio(label="Arabic"), gr.Audio(label="Japanese")],
    title="Voice-to-Voice Translator",
    description="Voice-to-Voice",
)

if __name__ == "__main__":
    demo.launch()

Pertama kita definisikan sumber input audio dengan gr.Audio. Kemudian dengan gr.Interface, kita buat antarmuka Gradio dengan input dan output yang ditentukan.

Kesimpulan

Pada artikel ini, kita sudah belajar cara membuat aplikasi sederhana penerjemah voice to voice menggunakan Python dan API dari ElevenLabs dan AssemblyAI. Dengan menggabungkan teknologi transkripsi, penerjemahan, dan teks-ke-ucapan, kita dapat menciptakan aplikasi yang menjembatani hambatan bahasa dan meningkatkan komunikasi secara global.

Masih banyak yang bisa kita kembangkan dari projek ini. Seperti penambahan bahasa dan antarmuka pengguna yang lebih intuitif. Terima kasih sudah membaca artikel ini. Semoga sukses dan selamat belajar.

Referensi : Assembly AI Youtube

Source code: Github

Pengenalan Random Forest

Lantas bagaimana cara kerja dari random forest? Misalnya kita memiliki data kesehatan seperti usia, tekanan darah, kadar kolesterol, dan lain-lain. Kemudian kita ingin memprediksi apakah orang tersebut akan mengalami penyakit jantung berdasarkan data yang diberikan. Salah satu cara yang bisa diterapkan adalah menggunakan decision tree. Namun, kendalanya pada pohon keputusan adalah ia rentan terhadap overfitting, yang mana berpotensi tidak bekerja dengan baik pada data baru.

Lalu kita melakukan langkah alternatif tentang dengan membuat keputusan berdasarkan pendapat sekelompok orang, bukan hanya satu orang. Misalnya, jika pada kasus penyakit jantung tadi kita bertanya kepada 10 dokter tentang prediksinya, kita mungkin mendapatkan jawaban yang lebih akurat dan meyakinkan dengan mengambil mayoritas jawaban mereka, daripada hanya bertanya kepada satu dokter. Kira-kira seperti ini lah perumpamaan dari metode random forest

Cara Kerja Random Forest

Dari subset acak pada data latih, Random Forest bekerja dengan membangun banyak decision tree. Setiap pohon dilatih pada subset data yang berbeda, yang diambil menggunakan teknik yang disebut bootstrap sampling, di mana sampel dipilih secara acak (satu sampel dapat dipilih lebih dari sekali). Selain itu, pada setiap node dalam pohon, hanya subset acak dari semua fitur yang dipertimbangkan untuk dipecah, bukan semua fitur. Hal ini membantu mengurangi korelasi antar pohon. Setelah semua pohon dibuat, Random Forest menggabungkan prediksi dari semua pohon untuk membuat keputusan akhir. Untuk klasifikasi, ini biasanya dilakukan dengan voting mayoritas (prediksi kelas yang paling sering muncul). Untuk regresi, rata-rata dari semua prediksi pohon digunakan.

Random Forest memiliki beberapa keunggulan. Pertama, algoritma ini cenderung memberikan hasil yang lebih akurat dibandingkan dengan satu decision tree saja karena sifatnya yang menggabungkan prediksi dari banyak pohon. Kedua, Random Forest mengurangi risiko overfitting dengan menggabungkan banyak pohon yang dilatih pada subset data yang berbeda. Ketiga, algoritma ini dapat menangani missing value dengan lebih baik. Keempat, Random Forest memungkinkan kita untuk melihat fitur mana yang paling berpengaruh dalam prediksi.

Kelemahan Random Forest

Meskipun memiliki banyak keunggulan, Random Forest juga memiliki beberapa kelemahan. Membangun banyak pohon dan menggabungkan prediksi mereka bisa membutuhkan banyak waktu dan sumber daya komputasi. Selain itu, meskipun kita dapat melihat fitur-fitur yang penting dalam prediksi, secara keseluruhan model Random Forest kurang interpretatif jika dibandingkan dengan decision tree.

Implementasi : Prediksi Heart Failure

Setelah kita mempelajari sekilas tentang konsep random forest. Sekarang kita akan mencoba menerapkannya untuk melakukan klasifikasi kematian pasien menggunakan dataset "Heart Failure Clinical Records". Pertama-tama, kita mengimpor pustaka-pustaka penting seperti pandas, numpy, matplotlib, seaborn, serta modul-modul dari scikit-learn yang digunakan untuk preprocessing dan evaluasi model.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

Kemudian kita memuat dataset menggunakan pandas lalu menampilkan 5 baris teratas dari data.

# Load the dataset
url = "/kaggle/input/heart-failure-clinical-data/heart_failure_clinical_records_dataset.csv"
data = pd.read_csv(url)

# Display the first few rows of the dataset
data.head()

Selanjutnya adalah mengecek informasi dasar tentang dataset menggunakan data.info(). Di sini kita bisa mengetahui jumlah entri, kolom, tipe data, dan jumlah nilai non-null.

# Check the basic info of the dataset
data.info()

Setelah itu kita juga menampilkan ringkasan statistik dasar dari dataset menggunakan data.describe().

# Statistical summary of the dataset
data.describe()

Untuk keperluan visualisasi, di sini kita akan melihat distribusi variabel target / 'DEATH_EVENT'.

# Plotting the distribution of target variable
sns.countplot(x='DEATH_EVENT', data=data)
plt.title('Distribution of Target Variable')
plt.show()

Dari hasil di atas terlihat bahwa data dengan label 0 lebih banyak daripada label 1. Selanjutnya kita akan membuat heatmap untuk melihat korelasi antar matrix.

# Correlation matrix
plt.figure(figsize=(12, 8))
sns.heatmap(data.corr(), annot=True, cmap='coolwarm')
plt.title('Correlation Matrix')
plt.show()

Selesai dengan visualisasi. Selanjutnya kita mempersiapkan data untuk training. Di sini kita memisahkan data menjadi fitur (X) dan target (y), dimana kolom 'DEATH_EVENT' dipisahkan dari dataset dan sisanya dijadikan fitur.

# Splitting the data into features and target
X = data.drop('DEATH_EVENT', axis=1)
y = data['DEATH_EVENT']

Dataset kemudian dibagi menjadi set pelatihan dan pengujian dengan perbandingan 80:20 menggunakan train_test_split, memastikan hasil yang dapat direproduksi dengan random_state=42.

# Splitting the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Fitur-fitur kemudian dinormalisasi menggunakan StandardScaler untuk mengurangi bias yang mungkin terjadi jika tidak dinormalisasi.

# Standardizing the features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Setelah data seiap, kita inisialisasi model Random Forest dan melatihnya pada set pelatihan.

# Initialize the Random Forest Classifier
rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)

# Train the model
rf_classifier.fit(X_train, y_train)

Setelah pelatihan, model digunakan untuk memprediksi hasil pada set pengujian.

# Make predictions
y_pred = rf_classifier.predict(X_test)

Evaluasi model dilakukan menggunakan metrik seperti accuracy score, classification report, dan confusion matrix.

# Evaluate the model
print("Accuracy Score:", accuracy_score(y_test, y_pred))
print("\nClassification Report:\n", classification_report(y_test, y_pred))

# Confusion Matrix
conf_matrix = confusion_matrix(y_test, y_pred)
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.show()

Hasil evaluasi menunjukkan akurasi model serta metrik precision, recall, dan f1-score untuk masing-masing kelas target. Matriks kebingungan digambarkan menggunakan heatmap untuk visualisasi yang lebih baik. Terakhir, kita bisa melihat nilai fitur-fitur penting yang digunakan dalam prediksi menggunakan atribut feature_importances_ yang ada di model Random Forest.

# Feature importance
importances = rf_classifier.feature_importances_
indices = np.argsort(importances)[::-1]
features = X.columns

# Plotting feature importances
plt.figure(figsize=(12, 8))
plt.title('Feature Importances')
plt.bar(range(X.shape[1]), importances[indices], align='center')
plt.xticks(range(X.shape[1]), features[indices], rotation=90)
plt.tight_layout()
plt.show()

Kesimpulan

Dalam artikel ini, kita telah mempelajari tentang algoritma Random Forest, sebuah metode pembelajaran mesin yang menggabungkan prediksi dari banyak decision tree yang dilatih pada subset acak dari data pelatihan, yang mana hal tersebut akan membantu meningkatkan akurasi dan mengurangi risiko overfitting.

Kita juga mencoba menerapkannya pada dataset "Heart Failure Clinical Records" untuk melakukan klasifikasi kematian pasien. Hasil evaluasi menunjukkan bahwa Random Forest dapat memberikan hasil akurasi 75%. Dan di akhir, kita juga mengidentifikasi fitur-fitur yang paling berpengaruh dalam prediksi. Terima kasih sudah membaca artikel ini, tetap semangat, terus berlatih dan selamat belajar!.

Kode Sumber : Kaggle

Decision Tree Proses

Sama seperti untuk regresi, sebuah Decision Tree terdiri dari tiga jenis node:

1. Root Node: Node pertama yang memulai pembagian.

2. Internal Node: Node di dalam pohon yang memisahkan data berdasarkan fitur tertentu.

3. Leaf Node: Node terakhir yang memberikan prediksi kelas.

Pada proses membuat Decision Tree untuk klasifikasi, terdapat sejumlah langkah penting:

1. Pemilihan Fitur: Memilih fitur yang paling signifikan untuk memisahkan data pada setiap langkah.

2. Kriteria Pembagian: Menentukan bagaimana memisahkan data di setiap simpul.

3. Pembentukan Simpul: Mengulangi proses pemisahan hingga kriteria penghentian terpenuhi (misalnya, kedalaman maksimum pohon atau jumlah minimum sampel dalam simpul).

Salah satu aspek paling penting dari Decision Tree Classifier adalah memilih cara terbaik untuk memisahkan data di setiap simpul. Untuk klasifikasi, biasanya digunakan kriteria seperti Gini Impurity atau Entropy (Information Gain).

Rumus Gini Impurity:

\(\text{Gini} = 1 - \sum_{i=1}^{C} p_i^2\)

Rumus Entropy:

\(\text{Entropy} = - \sum_{i=1}^{C} p_i \log(p_i)\)

dimana:

• \(C\) adalah jumlah kelas.

• \(p_i\)adalah proporsi sampel yang termasuk dalam kelas \(i\).

Algoritma akan mencari pembagian yang meminimalkan Gini Impurity atau Entropy pada setiap simpul.

Selanjutnya proses pemilihan fitur melibatkan perhitungan Gini Impurity atau Entropy untuk setiap fitur dan titik pembagian yang mungkin. Misalnya, jika kita memiliki fitur X dengan nilai-nilai \([1, 2, 3, 4, 5]\) dan kelas Y dengan nilai-nilai \([0, 1, 0, 1, 0]\), kita dapat mencoba berbagai titik pembagian seperti \(X < 2.5\), \(X < 3.5\), dll., dan menghitung Gini Impurity atau Entropy untuk setiap pembagian. Pembagian dengan nilai terendah akan dipilih.

Kelebihan dari decision tree adalah mudah diinterpretasikan dan divisualisasikan. Decision tree juga dapat menangani hubungan non-linear antara fitur dan kelas. Selain itu, Algoritma juga akan secara otomatis memilih fitur yang paling signifikan.

Kekurangan:

• Overfitting: Pohon keputusan cenderung overfitting pada data training, terutama jika tidak diatur kedalamannya.

• Stabilitas: Pohon keputusan sensitif terhadap perubahan kecil dalam data; perubahan kecil dapat menghasilkan struktur pohon yang sangat berbeda.

Studi Kasus: Prediksi Penyakit Jantung

Untuk contoh penggunaan decision tree classifier, kita akan menggunakan dataset Heart Disease dari Kaggle.

Import Libraries

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix, classification_report, accuracy_score

• pandas dan numpy digunakan untuk manipulasi data.

• matplotlib dan seaborn digunakan untuk visualisasi.

• train_test_split digunakan untuk membagi data menjadi set pelatihan dan pengujian.

• DecisionTreeClassifier digunakan untuk membuat model klasifikasi pohon keputusan.

• confusion_matrix, classification_report, dan accuracy_score digunakan untuk evaluasi performa model.

Load Dataset

df = pd.read_csv('/kaggle/input/heart-failure-clinical-data/heart_failure_clinical_records_dataset.csv')

Membaca data dari file CSV yang berisi informasi tentang pasien dengan penyakit jantung dan fitur-fitur yang terkait.

df.head()

Di sini kita melihat lima data teratas dari dataset. Dengan melakukan visualisasi seperti ini kita bisa mendapatkan gambaran tentang bagaimana kondisi data-data dan kolom-kolom fitur yang tersedia.

Descriptive Statistics

df.describe()

Setelah melihat ini contoh data-data teratas kita kemudian bisa menampilkan statistik deskriptif seperti mean, std, min, max untuk setiap kolom dalam dataset.

Informasi Data

df.info()

Memberikan informasi tentang tipe data dan jumlah nilai null untuk setiap kolom. Mengetahui tipe data dan jumlah null perlu diperlakukan agar bisa menjadi pertimbangan ketika melakukan preprocessing nanti.

Visualisasi Distribusi Target

plt.figure(figsize=(10, 6))
sns.countplot(x='DEATH_EVENT', data=df)
plt.title('Target Variable Distribution')
plt.show()

Dari visualisasi yang kita lakukan didapatkan bahwa target dengan label 0 memiliki jumlah data yang lebih banyak dari label 1. Sehingga bisa dikatakan bahwa data kita saat ini imbalanced.

Visualisasi Korelasi Fitur

plt.figure(figsize=(12, 8))
sns.heatmap(df.corr(), annot=True, fmt='.2f', cmap='coolwarm')
plt.title('Correlation Heatmap')
plt.show()

Heatmap di atas menunjukkan data-data yang memiliki korelasi dengan kolom DEATH_EVENT sebagai target. Nilai positif menunjukkan korelasi positif antar data, sebagai contoh semakin tinggi nilai pada kolom time maka cenderung juga kemungkinan DEATH_EVENT semakin tinggi. Sebaliknya pada data-data yang memiliki korelasi negatif.

Preprocessing Data

Normalisasi Fitur Numerik

from sklearn.preprocessing import StandardScaler

# Normalize numerical features
scaler = StandardScaler()
numerical_features = ['age', 'creatinine_phosphokinase', 'ejection_fraction', 'platelets', 'serum_creatinine', 'serum_sodium', 'time']
df[numerical_features] = scaler.fit_transform(df[numerical_features])

Di sini kita akan menggunakan Standard Scaler sebagai teknik prapemrosesan data. Teknik ini digunakan untuk menstandarisasi fitur-fitur numerik dalam dataset sehingga memiliki rata-rata (mean) nol dan standar deviasi satu. Proses ini membantu algoritma agar bisa bekerja dengan lebih efisien dengan mempercepat konvergensi dan mengurangi bias dalam fitur yang memiliki skala berbeda.

Pemilihan Fitur dan Target

X = df.drop(columns=['DEATH_EVENT'])
y = df['DEATH_EVENT']

Setelah dilakukan standarisasi, kita bisa kemudian menentukan kolom-kolom yang menjadi variabel fitur dan target. Di sini kita menggunakan DEATH_EVENT sebagai target dan kolom selainnya sebagai fitur.

Pemisahan Data

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Kemudian kita membagi data menjadi data train dan data text. Kita menggunakan ukuran split di sini 80% untuk training dan 20% untuk testing.

Hyperparameter Tuning

Menggunakan GridSearchCV untuk menemukan kombinasi hyperparameter terbaik.

from sklearn.model_selection import GridSearchCV

# Initialize Decision Tree model
model = DecisionTreeClassifier(random_state=42)

# Define parameter grid
param_grid = {
    'criterion': ['gini', 'entropy'],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 10, 20],
    'min_samples_leaf': [1, 5, 10]
}

# Initialize GridSearchCV
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, n_jobs=-1, scoring='accuracy')
grid_search.fit(X_train, y_train)

# Best parameters and model
best_params = grid_search.best_params_
best_model = grid_search.best_estimator_

print(f'Best Parameters: {best_params}')

Selain pada model, pengembangan machine learning juga sangat bergantung pada parameter-parameter yang digunakan untuk melatih model. Di sini kita melakukan grid search untuk melihat kombinasi dari setiap parameter yang ada.

Train and Evaluate the Best Model

# Train the best model
best_model.fit(X_train, y_train)

# Predictions
y_pred_train = best_model.predict(X_train)
y_pred_test = best_model.predict(X_test)

# Evaluation metrics
conf_matrix = confusion_matrix(y_test, y_pred_test)
class_report = classification_report(y_test, y_pred_test)
accuracy = accuracy_score(y_test, y_pred_test)

print(f'Confusion Matrix:\n{conf_matrix}')
print(f'Classification Report:\n{class_report}')
print(f'Accuracy: {accuracy}')

Setelah kita mendapatkan model dengan parameter terbaik. Kita melakukan training pada data latih kemudian mengujinya pada data tes. Terakhir kita melakukan evaluasi dengan melihat classification report dari model.

Visualisasi Decision Tree

from sklearn.tree import plot_tree

plt.figure(figsize=(20, 10))
plot_tree(best_model, filled=True, feature_names=X.columns, class_names=['No Disease', 'Disease'], max_depth=2, fontsize=10)
plt.show()

Sebagaimana telah disinggung. Kelebihan dari decision tree adalah sifatnya yang mudah diinterpretasi. Di sini kita melakukan visualisasi dengan kedalaman 2.

Visualisasi Confusion Matrix

plt.figure(figsize=(8, 6))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['No Disease', 'Disease'], yticklabels=['No Disease', 'Disease'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

Dari visualisasi di atas, kita dapat melihat hasil prediksi model yang didapatkan. Dari sini juga kita bisa menganalisa bagian-bagian mana yang diprediksi dengan baik oleh model dan bagian yang mana yang tidak. Sehingga berguna untuk analisa lebih lanjut di masa depan.

Kesimpulan

Dalam artikel ini, kita telah membahas bagaimana Decision Tree Classifier bekerja, mulai dari pemilihan fitur, kriteria pembagian, hingga pembentukan simpul. Kita juga telah melakukan studi kasus prediksi penyakit jantung. Model Decision Tree Classifier menawarkan interpretabilitas yang tinggi, memudahkan kita untuk memahami dan menjelaskan prediksi yang dihasilkan. Namun, penting untuk diingat bahwa model ini bisa sangat sensitif terhadap perubahan kecil dalam data dan cenderung overfitting jika tidak diatur dengan benar.

Dengan pemahaman yang mendalam tentang bagaimana Decision Tree Classifier bekerja dan bagaimana mengimplementasikannya, kita sekarang siap untuk menerapkan algoritma ini pada berbagai masalah klasifikasi lainnya. Terima kasih sudah membaca artikel ini, Selamat Belajar!

Source Code : Kaggle

"Mengubah LLM dari Robot Kaku menjadi Bestie Kamu"

Pendahuluan

Ketika kita mulai menerapkan Kecerdasan Artifisial dalam bentuk Large Language Model (LLM) pada suatu aplikasi, setidaknya kita akan menemui dua tantangan. Pertama adalah bagaimana menghubungkan LLM dengan 'data asli'. Perlu diketahui, bahwa kita perlu "membumikan" LLM atau menghubungkannya dengan data asli yang relevan dari agar dapat berfungsi dengan baik. Kedua adalah bagaimana menyediakan data yang tepat. LLM harus bisa memberikan informasi yang benar dan relevan sesuai kebutuhan bisnis.

RAG (Retrieval-Augmented Generation) merupakan teknik yang menggabungkan kemampuan mengambil data (retrieval) dengan kemampuan menghasilkan teks (generation) untuk memberikan jawaban yang lebih akurat dan relevan. Adapun Fine-Tuning adalah proses penyesuaian model LLM yang sudah ada dengan data spesifik yang lebih relevan untuk meningkatkan performa dan ketepatan dalam memberikan jawaban. RAG dan fine-tuning merupakan cara terbaik yang saat ini tersedia untuk menerapkan AI dalam dunia nyata. Keduanya membantu LLM memberikan hasil yang lebih akurat dan relevan dengan berbagai kondisi yang ada. Dalam artikel ini, kita akan membahas konsep-konsep ini secara keseluruhan untuk membantu memahami cara kerja dan manfaat RAG dan fine-tuning dalam penerapan AI di dunia nyata.

Bagaimana LLM Bekerja?

Agar bisa paham konsep RAG dan fine-tuning, kita perlu memahami dulu bagaimana cara kerja dari LLM. Ketika kita berinteraksi dengan LLM melalui aplikasi seperti ChatGPT misalnya, mungkin terkadang akan terasa seperti berbicara dengan manusia. Kita beri dia pertanyaan, lalu LLM memberikan jawabannya, kemudian percakapan bisa terus berlanjut. Interaksi seperti ini mungkin akan memberi kesan bahwa LLM ini pintar dan ia mampu berpikir seperti manusia pada umumnya. Namun, terkadang jawaban dari LLM bisa saja tidak akurat atau salah, meskipun terlihat LLM sangat yakin dengan jawabannya. Dalam konteks LLM, ini biasa disebut dengan "Halusinasi".

Suatu LLM yang diterapkan dalam bentuk aplikasi chat sebenarnya merupakan sistem auto-complete canggih. Ketika kita membuat chat baru, di balik layar LLM sudah memiliki pesan awal yang disebut "system message". Poin inilah yang menjadi titik awal dari suatu percakapan yang akan kita lakukan dengan LLM. Sehingga ketika misalnya kita memasukkan pertanyaan seperti, "Bagaimana cara membuat nasi goreng?", LLM terlebih dahulu membaca "system message" yang sudah didefinisikan sebelumnya, lalu membaca pertanyaan kita, dan kemudian melengkapi percakapan dengan memberikan jawaban yang sesuai.

Sebenarnya, LLM tidak mencari informasi tentang nasi goreng dari database sebelum menjawab. Sebaliknya, LLM menggunakan multi-dimensional map yang sangat kompleks dari bahasa manusia untuk melengkapi dokumen tersebut. Karena ratusan bahkan mungkin ribuan resep nasi goreng ada di dalam data latih, dan sebagian resep nasi goreng juga hanya merupakan variasi dari bahan-bahan dasar yang sama, maka kemungkinan besar juga LLM akan menghasilkan daftar bahan yang akurat untuk resep nasi goreng secara umum.

Sehingga perlu disadari bahwa suatu LLM tidak bisa disebut "pintar" dalam arti sebenarnya. Kemampuan menjawab pertanyaan ini di balik layar sebenarnya merupakan perhitungan matematika yang kompleks. Jadi, meski LLM kelihatannya punya kemampuan berpikir seperti manusia, kenyataannya itu hanyalah hasil dari proses auto-complete yang sangat canggih.

Pentingnya Konteks ketika Berinteraksi dengan LLM

Di antara hal penting yang perlu kita tahu saat mulai menggunakan LLM adalah kenyataan bahwa memberikan konteks kepada LLM bisa memberi pengaruh yang signifikan.

Disadari atau tidak, memberi konteks pembicaraan adalah hal yang sangat penting ketika kita berinteraksi dengan LLM. Dalam percakapan sehari-hari, kita selalu memberikan konteks tanpa berpikir panjang. Misalnya, saat ingin membuat nasi goreng, pertanyaan yang diajukan tidak hanya, "Apa bahan-bahan yang diperlukan untuk membuat nasi goreng?" Kita biasanya akan lebih spesifik, seperti "Apa bahan-bahan yang diperlukan untuk membuat nasi goreng khas Indonesia?"

Jadi, misalnya ketika kita bertanya ke ChatGPT, "Apa bahan-bahan yang diperlukan untuk membuat nasi goreng khas Indonesia?" kata "khas Indonesia" di sini lah yang menjadi konteks pentingnya. LLM kemudian akan membaca semua informasi sebelumnya, mulai dari pesan awal hingga permintaan dan konteks baru yang kita tambahkan, sehingga kemudian ia bisa memberikan jawaban yang lebih spesifik dan relevan.

Proses memberikan konteks yang tepat dengan harapan bisa mendapat jawaban relevan dari LLM inilah yang kemudian dikenal dengan "Prompt engineering". Makin banyak konteks yang kita berikan, makin besar pula kemungkinan LLM mampu memberikan jawaban sesuai dengan yang diinginkan. Oleh karena itu, hal ini juga yang menjadi alasan kenapa ketika kita meminta LLM untuk meringkas dari dokumen ataupun transkrip video ke dalam LLM, hasilnya akan bagus. Dengan cara memberikan konteks, LLM mampu menghasilkan respon yang bisa membuat kita merasa seakan-akan ia benar-benar telah membaca dan meringkas konten sesuai permintaan kita.

Mengenal RAG: Retrieval Augmented Generation

Sebagaimana sudah disinggung sebelumnya, ketika kita menggunakan produk LLM seperti ChatGPT. Kita seringkali menganggapnya sebagai perpaduan antara search engine dan asisten virtual yang amat sangat cerdas. Padahal, LLM sebenarnya bukanlah sistem pencarian informasi. LLM merupakan representasi dari suatu sistem kompleks bernama "language transformer". LLM tidak benar-benar "tahu" sesuatu. yang cukup rumit sehingga bisa melengkapi sebagian besar kalimat dengan benar, selama pola informasi tersebut tersedia dalam data pelatihannya.

Masalahnya adalah, ketika informasi yang diberikan LLM sebenarnya salah namun dari jawaban yang diberikan ia terlihat memiliki tingkat keyakinan yang sangat tinggi. Ketika terjadi kondisi seperti ini, LLM malah terlihat seperti sedang berhalusinasi atau bahkan sedang berbohong.

Agar jawaban yang diberikan LLM lebih akurat, kita bisa menggunakan pendekatan RAG. Pendekatan ini meningkatkan akurasi dari jawaban LLM dengan cara menggabungkan pencarian informasi (retrieval) dengan kemampuan LLM untuk melengkapi dan menghasilkan teks (generation). Sehingga, alih-alih langsung menjawab, yang terlebih dahulu dilakukan LLM adalah mencari informasi dari basis data, kemudian menambahkannya sesuai konteks, dan baru kemudian memberikan jawaban. Contoh awal dari konsep ini ada pada sistem Bing AI. Di mana ketika kita berikan pertanyaan, sistem terlebih dahulu akan mencari informasi yang relevan di web, kemudian informasi tersebut digunakan sebagai referensi untuk memberikan jawaban. Tentu saja pemanfaatan dari pendekatan ini tidak hanya terbatas pada search engine namun juga berlaku untuk sistem LLM yang lainnya.

Alur Kerja RAG (Retrieval Augmented Generation)

Lalu bagaimana model bahasa besar (LLM) bisa mengambil data dari sumber informasi yang ada? Mari kita lihat bagaimana alur kerja RAG secara sederhana (semoga 😅).

1. Permintaan Masuk:

   Ketika ada permintaan ataupun pertanyaan yang masuk, pertama-tama LLM akan memahami makna dari permintaan tersebut terlebih dahulu. Misalnya, ketika kita bertanya, "Apa saja bahan-bahan untuk membuat kue lapis?", LLM akan mengubah pertanyaan ini menjadi query (permintaan data) yang bisa dipahami oleh sistem data terkait.

2. Mengakses Sumber Data:

   Query ini kemudian dikirim ke sumber data yang relevan, sumber data di sini bisa berupa database standar yang diakses melalui API, array embeddings, database vektor, atau bahkan buku resep dalam bentuk pdf. Sumber data ini kita sebut sebagai "grounded truth" (kebenaran yang terhubung).

3. Mengambil Data:

   Sumber data yang terkait kemudian memproses permintaan ini dan mengembalikan data yang relevan kepada LLM.

4. Menghasilkan Jawaban:

   LLM kemudian menggabungkan permintaan asli dengan data yang baru saja diambil dan menghasilkan jawaban. Misalnya, ketika data yang diambil oleh LLM ternyata berupa resep dari buku resep masakan Indonesia, maka LLM akan menggunakan informasi ini untuk memberikan daftar bahan-bahan yang akurat.

5. Verifikasi Tambahan:

   Karena sifat dari LLM adalah bersifat probabilistik (menghasilkan jawaban berdasarkan kemungkinan) dan non-deterministik (hasilnya bisa berbeda pada setiap langkah), akurasi dari jawabannya mungkin tidak selalu tepat. Untuk mengurangi risiko ini, sering kali ditambahkan langkah verifikasi.

   Jawaban yang sudah dihasilkan, bersama dengan data yang diambil, akan dikembalikan ke LLM untuk memastikan bahwa jawaban tersebut hanya mengandung informasi dari data yang diambil. Langkah ini bisa diulang sampai beberapa kali untuk meningkatkan akurasi jawaban.

Embeddings: Membantu AI Memahami Data

Kembali lagi kepada perkara nasi goreng, misalnya kita membuat suatu ChatBot dan menggunakan buku resep masakan Indonesia sebagai sumber data. Kemudian kita berikan pertanyaan, "Apa resep untuk membuat nasi goreng?" Nasi adalah makanan pokok di Indonesia dan tentunya merupakan bahan umum yang ada di resep-resep masakan. Lantas bagaimana caranya sistem bisa tahu kalau yang kita mau adalah resep nasi goreng? bukan nasi ayam, nasi sop, nasi bakar, atau nasi kebuli?

Untuk menemukan informasi terkait yang relevan. AI menggunakan teknik bernama Embeddings. Berikut cara kerja embedding:

1. Representasi Numerik:

   Embeddings mengubah teks menjadi representasi numerik dalam bentuk titik-titik dan vektor di ruang multidimensi.

2. Proses Embeddings:

   Setiap resep dalam buku resep dimasukkan ke dalam model embeddings, yang kemudian mengubah kata-kata dalam resep tersebut menjadi peta titik-titik di ruang multidimensi. Di sini setiap kata-kata yang mirip, seperti "nasi" dan "ketan", akan ditempatkan lebih dekat satu sama lain. Sementara kata-kata yang tidak mirip, seperti "bayam" dan "wortel", akan ditempatkan lebih jauh.

3. Membuat Vektor:

   Vektor digambar pada setiap titik-titik yang dihasilkan untuk mewakili hubungan antara kata-kata dalam teks. Representasi matematis dari titik-titik dan vektor ini menjadi embeddings untuk setiap resep.

4. Mencocokkan Permintaan dengan Embeddings:

   Ketika kamu memberikan pertanyaan seperti, "Bagaimana cara membuat nasi goreng ayam?", sistem AI akan membuat embeddings dari pertanyaan ini menggunakan model embeddings yang sama. Sistem AI kemudian membandingkan embeddings pertanyaan dengan embeddings setiap resep untuk menemukan yang paling cocok.

5. Menghasilkan Jawaban:

   Dengan membandingkan embeddings, sistem AI dapat menemukan resep yang paling sesuai permintaan kita. Misalnya, jika pertanyaanmu kita dengan embeddings untuk resep nasi goreng khas Indonesia, sistem AI akan memberikan teks resep nasi goreng khas Indonesia dari database.

Knowledge Graphs

Bayangkan kita sedang memasak kemudian ingin tahu bahan apa yang diperlukan. Misalnya, kita bertanya, "Saus apa yang saya perlukan untuk membuat nasi goreng?" Jika sistem AI hanya mengandalkan 'embeddings', bisa saja AI tersebut mengembalikan dua jawaban: 'Saus Kecap' dan 'Saus Barbeque'. Jelas yang benar adalah 'saus kecap', bukan 'saus barbeque'. Apa alasan AI bisa salah?

1. Kata-Kata yang Sama, Maknanya Berbeda: Dalam bahasa kita, banyak kata yang memiliki lebih dari satu makna tergantung konteksnya. Misalnya 'pasta' di masakan 'saus tomat (tomato paste)' dengan 'pasta' dalam 'pasta gigi (tooth paste)' tentu berbeda.

2. Keterbatasan Embeddings: Embeddings memang mengubah kata-kata menjadi angka (vektor) yang membuat komputer bisa memahami dan membandingkan kata-kata tersebut. Akan tetapi, embeddings tidak selalu bisa memahami konteks dengan baik.

Untuk mengatasi masalah ini, kita bisa menggunakan 'knowledge graphs'. Dengan ini, selain makna, hubungan antar kata juga dipertimbangkan. Misalnya, dalam knowledge graph, 'tomato paste' akan dihubungkan dengan 'makanan' dan 'tooth paste' dengan 'kebersihan'. Sehingga ketika kita bertanya , "Pasta apa yang enak untuk membuat spaghetti?" Knowledge graph akan memahami bahwa kita sedang berbicara tentang makanan dan hanya akan memberikan 'tomato paste' sebagai jawaban yang relevan.

Meskipun demikian, tidak semua kondisi memerlukan knowledge graphs. Sistem AI biasanya menggabungkan berbagai sumber data seperti database tradisional, API, embeddings, dan knowledge graphs, tergantung pada keperluan dan jenis data yang ada. Pada umumnya, disarankan untuk memulai dengan metode yang paling sederhana, seperti menggunakan database dengan API, dan kemudian mencoba opsi yang lebih advance ketika masalah semakin kompleks.

Fine-Tuning

RAG memang merupakan salah satu metode yang efektif untuk meningkatkan kualitas jawaban dari LLM. Namun, ia juga bukan satu-satunya, contoh metode lain yang bisa dilakukan adalah fine tuning. Metode ini merupakan salah satu cara untuk meningkatkan kinerja model AI agar bisa memberikan jawaban yang lebih spesifik dan sesuai dengan keperluan kita. Cara kerjanya adalah pertama-tama, kita memberikan model AI banyak contoh dialog yang sudah lengkap. Setiap contoh berisi pesan sistem, permintaan pengguna, dan jawaban yang diharapkan. Kemudian Model AI dilatih dengan contoh-contoh ini sehingga dia belajar bagaimana harus merespons permintaan yang serupa di masa depan.

Fine-Tuning memiliki sejumlah manfaat. Setidaknya ada tiga benefit utama dari fine-tuning. Pertama adalah jawaban yang lebih konsisten, karena ia sudah tahu bagaimana harus merespon. Kedua, model akan bisa disesuaikan untuk menjawab dengan gaya bahasa tertentu. Ketiga, model bisa dilatih agar melakukan tindakan tertentu seperti memberikan referensi ke dokumen atau mengarahkan ke database.

Meskipun menjanjikan, fine-tuning juga memiliki sejumlah tantangan antara lain:

• Diperlukan banyak contoh data latih agar bisa berhasil.

• Proses melatih model perlu dilakukan berkali-kali agar model benar-benar mengikuti pola yang diinginkan.

• Meskipun sudah dilatih, model mungkin saja tidak memberi hasil yang sesuai harapan, sehingga akan perlu banyak uji coba dan penyesuaian.

Fine-tuning sangat berguna dalam situasi di mana kita memerlukan konsistensi jawaban. Dengan fine-tuning, kita bisa memiliki kendali langsung atas perilaku model AI, sesuatu yang akan sulit dicapai jika hanya menggunakan model dasar.

RAG dengan Fine-Tuning = RAFT

RAFT adalah singkatan dari Retrieval Augmented Fine-Tuning. Ini adalah metode yang menggabungkan dua teknik untuk membuat sistem AI yang lebih efisien dan akurat dalam menangani data spesifik, seperti dokumen internal perusahaan. Bisa demikian karena dengan RAG (Retrieval-Augmented Generation) AI bisa menemukan informasi relevan dari sumber data yang luas. Kemudian dengan Fine-Tuning AI juga dilatih agar memberikan jawaban yang sesuai dengan contoh spesifik. Berikut contoh alur dari RAFT:

1. Langkah Pertama: Menggunakan RAG

   Kita menggunakan RAG untuk melatih model AI dengan data spesifik. Misalnya, dokumen internal perusahaan sehingga AI mengenali pola dalam data tersebut.

2. Langkah Kedua: Membuat Pertanyaan Spesifik

   Buat daftar pertanyaan yang mencerminkan jenis pertanyaan yang mungkin diajukan oleh pengguna sistem.

3. Langkah Ketiga: Ambil Dokumen Terkait

   Gunakan RAG untuk mengambil dua jenis dokumen:

   • A : Dokumen yang berisi jawaban yang benar.

     B : Dokumen yang berisi informasi yang tidak relevan.

4. Langkah Keempat: Gabungkan Pertanyaan dan Dokumen

   Gabungkan pertanyaan dengan dokumen A untuk membuat jawaban yang rinci, termasuk di dalmnya penjelasan langkah demi langkah.

5. Langkah Kelima: Proses Fine-Tuning

   Lakukan fine-tuning dengan menggunakan tiga jenis contoh data:

   1. Pertanyaan + Dokumen A + Jawaban rinci.

   2. Pertanyaan + Dokumen B + Jawaban rinci.

   3. Pertanyaan + Campuran data + Jawaban rinci.

Setelah dilatih hasilnya adalah model akan belajar menggunakan data yang relevan dan mengabaikan data yang tidak relevan dan bisa menentukan data mana yang bisa relevan untuk setiap pertanyaan yang ada.

Kesimpulan

Dalam penerapan Kecerdasan Artifisial, terutama dengan Large Language Models (LLMs), terdapat berbagai tantangan yang perlu diatasi agar dapat memberikan jawaban yang akurat dan relevan. Teknik-teknik seperti RAG (Retrieval-Augmented Generation) dan Fine-Tuning memainkan peran penting dalam mengatasi tantangan tersebut. Dengan menggunakan teknik-teknik ini, kita dapat menciptakan sistem AI yang tidak hanya canggih, tetapi juga lebih dapat diandalkan dalam memberikan jawaban yang relevan dan akurat sesuai dengan keperluan. Penerapan RAG, fine-tuning, dan RAFT dalam sistem AI akan membantu mengatasi keterbatasan model dasar dan memastikan bahwa AI dapat memberikan kontribusi yang signifikan dalam berbagai aplikasi dunia nyata. Terimakasih telah membaca artikel ini, selamat belajar!

Decision Tree adalah salah satu algoritma yang sangat populer dalam machine learning, digunakan baik untuk masalah klasifikasi maupun regresi. Pada artikel ini, kita akan fokus pada Decision Tree Regression terlebih dahulu. Decision Tree Regression adalah algoritma yang memetakan fitur dari dataset untuk memprediksi nilai kontinu (seperti harga rumah, suhu, dll.). Decision Tree di sini memecah data ke dalam subset yang lebih kecil dan semakin kecil dan di saat yang sama dibuat suatu pohon keputusan secara bertahap. Hasil akhirnya adalah sebuah pohon dengan simpul daun dan cabang.

Bagaimana Suatu Decision Tree Bekerja?

Sebuah decision tree terdiri dari tiga jenis node:

1. Root Node: Node pertama yang memulai pembagian.

2. Internal Node: Node di dalam pohon yang memisahkan data berdasarkan fitur tertentu.

3. Leaf Node: Node terakhir yang memberikan prediksi nilai target.

Dalam membangun suatu decision tree, terdapat beberapa tahapan yang terjadi:

1. Pemilihan Fitur: Memilih fitur yang paling signifikan untuk memisahkan data pada setiap langkah.

2. Kriteria Pembagian: Menentukan bagaimana memisahkan data pada setiap simpul.

3. Pembentukan Simpul: Ulangi proses pemisahan sampai memenuhi kriteria tertentu (misalnya, jumlah maksimum kedalaman pohon atau jumlah minimum sampel dalam simpul).

Kriteria Pembagian

Salah satu aspek paling penting dari Decision Tree Regression adalah memilih cara terbaik untuk memisahkan data di setiap simpul. Untuk regresi, biasanya digunakan Mean Squared Error (MSE) sebagai kriteria pembagian.

Rumus Mean Squared Error (MSE):

\( \text{MSE} = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2\)

dimana:

• \(N\) adalah jumlah sampel

• \(y_i\) adalah nilai target aktual

• \(\hat y_i\) adalah nilai prediksi

Algoritma akan mencari pembagian yang meminimalkan MSE pada setiap simpul.

Pemilihan Fitur dan Pembagian

Proses pemilihan fitur melibatkan perhitungan MSE untuk setiap fitur dan titik pembagian yang mungkin. Misalnya, jika kita memiliki fitur X dengan nilai-nilai \([1, 2, 3, 4, 5]\) dan nilai target Y dengan nilai-nilai \([5, 4, 3, 2, 1]\), kita dapat mencoba berbagai titik pembagian seperti \(X < 2.5\), \(X < 3.5\), dll., dan menghitung MSE untuk setiap pembagian. Pembagian dengan MSE terendah akan dipilih.

Setelah fitur dan titik pembagian dipilih, data dipecah menjadi dua subset berdasarkan pembagian tersebut. Proses ini diulang terus menerus pada setiap subset sampai memenuhi kriteria penghentian tertentu, seperti kedalaman maksimum pohon atau jumlah minimum sampel dalam simpul.

Misalkan kita memiliki dataset sederhana dengan fitur X dan nilai target Y:

Kita ingin memprediksi nilai Y menggunakan Decision Tree Regression. Berikut langkah-langkahnya:

1. Memilih Fitur dan Pembagian:

   • Cobalah pembagian di ( X < 2.5 ):

     • Kiri: X = [1, 2] , Y = [5, 4]

     • Kanan: X = [3, 4, 5] , Y = [3, 2, 1]

   • Hitung MSE untuk pembagian ini:

     \(\text{MSE}_{left} = \frac{1}{2} ((5 - 4.5)^2 + (4 - 4.5)^2) = 0.25\)

     \(\text{MSE}_{ right} = \frac{1}{3} ((3 - 2)^2 + (2 - 2)^2 + (1 - 2)^2) = 0.67\)

     \( \text{MSE}_{total} = \frac{2}{5} \times 0.25 + \frac{3}{5} \times 0.67 = 0.47\)

2. Membuat Simpul:

   • Pembagian ( X < 2.5 ) memberikan MSE total terendah, jadi kita memecah data pada titik tersebut.

Proses ini diulang untuk subset yang dihasilkan sampai kriteria penghentian terpenuhi.

Kelebihan dan Kekurangan

Sebagaimana model machine learning pada umumnya. Decision Tree juga memiliki kelebihan dan kekurangannya. Decision Tree mudah diinterpretasikan dan divisualisasikan. Decision tree juga dapat menangani hubungan non-linear antara fitur dan target. Algoritma decision tree juga akan secara otomatis memilih fitur yang paling signifikan untuk melakukan prediksi.

Adapun kekurangannya antara lain hasil decision tree cenderung overfitting pada data training, terutama jika kita tidak mengatur kedalamannya. Selain itu, decision tree juga sangat sensitif terhadap perubahan kecil dalam data., perubahan kecil dapat menghasilkan struktur pohon yang sangat berbeda.

Studi Kasus : Prediksi Harga Rumah

Kode di bawah ini adalah contoh implementasi model Decision Tree Regressor menggunakan dataset House Prices dari Kaggle. Langkah-langkahnya mencakup loading data, eksplorasi data, penanganan missing values, pemisahan data, pelatihan model, evaluasi model, dan visualisasi hasil.

Import Libraries

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error, r2_score

• pandas dan numpy digunakan untuk manipulasi data.

• matplotlib dan seaborn digunakan untuk visualisasi.

• train_test_split dari sklearn digunakan untuk membagi data menjadi set pelatihan dan pengujian.

• DecisionTreeRegressor dari sklearn digunakan untuk membuat model regresi pohon keputusan.

• mean_squared_error dan r2_score digunakan untuk evaluasi performa model.

Load Dataset

df = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv')

Membaca data dari file CSV yang berisi informasi harga rumah dan fitur-fitur yang terkait. Kemudian kita menampilkan 5 baris pertama untuk mendapatkan dambaran umum tentang data.

df.head()

Descriptive Statistics

df.describe()

Menampilkan statistik deskriptif seperti mean, std, min, max untuk setiap kolom dalam dataset.

Karena data yang kita gunakan memiliki kolom yang sangat banyak, kita juga perlu mengetahui tentang tipe data yang ada di setiap kolom.

df.info()

Deteksi Missing Values

for col in df.columns:
    miss = df[col].isna().sum() 
    if miss > 0:
        print(f"{col} has total {miss} missing values")

Menghitung dan menampilkan jumlah nilai yang hilang untuk setiap kolom.

Visualisasi Missing Values

plt.figure(figsize=(12, 6))
sns.heatmap(df.isnull(), cbar=False, cmap='viridis')
plt.title('Missing Values Heatmap')
plt.show()

Menggunakan heatmap untuk memvisualisasikan lokasi missing values dalam dataset.

Penanganan Missing Values

manyMiss = [col for col in df.columns if df[col].isna().sum() > 500]
lessMiss = [col for col in df.columns if df[col].isna().sum() <= 500]
df = df.drop(columns=manyMiss)
for col in df.columns:
    if df[col].dtype == 'O':
        df[col] = df[col].fillna(df[col].mode()[0])
    else:
        df[col] = df[col].fillna(df[col].mean())

• manyMiss: Kolom dengan lebih dari 500 missing values dihapus.

• lessMiss: Kolom dengan kurang dari 500 missing values diisi dengan mode untuk tipe objek dan mean untuk tipe numerik.

Eksplorasi Data

Distribusi SalePrice

plt.figure(figsize=(10, 6))
sns.histplot(df['SalePrice'], kde=True)
plt.title('SalePrice Distribution')
plt.show()

Di sini kita ingin memprediksi harga rumah, maka tidak ada salahnya melakukan plotting untuk melihat distribusi yang ada.

Pemilihan Fitur Numerik

numeric_features = df.select_dtypes(include=[np.number])
numeric_features = numeric_features.drop(columns=['SalePrice'])
y = df['SalePrice']
X = numeric_features

Untuk project ini kita hanya memilih kolom-kolom yang memiliki tipe data numerik. Kemudian kita menentukan kolom SalePrice sebagai variabel target / y. Setelah menentukan variabel X dan y kemudian kita membaginya menjadi data train dan data test

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Train Model

model = DecisionTreeRegressor(random_state=42)
model.fit(X_train, y_train)

Di sini kita membuat dan melatih model Decision Tree Regressor pada data latih.

Prediksi dan Evaluasi

Setelah melatih pada data yang dipilih, kemudian kita melakukan prediksi pada data baru. Dalam hal ini kita menggunakan data tes yang sudah dituliskan sebelumnya (20% dari dataset)

# Predictions
y_pred_train = model.predict(X_train)
y_pred_test = model.predict(X_test)

# Evaluation metrics
mse_train = mean_squared_error(y_train, y_pred_train)
mse_test = mean_squared_error(y_test, y_pred_test)
r2_train = r2_score(y_train, y_pred_train)
r2_test = r2_score(y_test, y_pred_test)

print(f'Training MSE: {mse_train}')
print(f'Testing MSE: {mse_test}')
print(f'Training R²: {r2_train}')
print(f'Testing R²: {r2_test}')

• y_pred_train dan y_pred_test: Hasil prediksi untuk set pelatihan dan pengujian.

• mse_train dan mse_test: Mean Squared Error untuk set pelatihan dan pengujian.

• r2_train dan r2_test: R² score untuk set pelatihan dan pengujian.

• Menampilkan hasil evaluasi performa model.

Visualisasi Decision Tree

from sklearn.tree import plot_tree
plt.figure(figsize=(20, 10))
plot_tree(model, filled=True, feature_names=X.columns, max_depth=2, fontsize=10)
plt.show()

Menggunakan plot_tree untuk memvisualisasikan struktur pohon keputusan sampai kedalaman 2.

Di atas kita membuat visualisasi hasil decision tree dengan kedalaman 2. Pada kenyataannya, pohon keputusan memiliki cabang yang sangat banyak dan dalam. Setelah mendapatkan hasil prediksi, kita buat visualisasi untuk melihat perbandingan data real dengan hasil prediksi.

plt.figure(figsize=(10, 6))
plt.scatter(y_test, y_pred_test, alpha=0.7, color='b')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], '--r', linewidth=2)
plt.xlabel('Actual SalePrice')
plt.ylabel('Predicted SalePrice')
plt.title('Actual vs Predicted SalePrice')
plt.show()

Penutup

Dalam artikel ini, kita telah membahas bagaimana Decision Tree bekerja, mulai dari pemilihan fitur, kriteria pembagian, hingga pembentukan simpul. Kita juga melakukan studi kasus prediksi harga rumah. Model Decision Tree Regression menawarkan interpretabilitas yang tinggi, memudahkan kita untuk memahami dan menjelaskan prediksi yang dihasilkan. Namun, penting untuk diingat bahwa model ini bisa sangat sensitif terhadap perubahan kecil dalam data dan cenderung overfitting jika tidak diatur dengan benar.

Dengan pemahaman yang mendalam tentang bagaimana Decision Tree Regression bekerja dan bagaimana mengimplementasikannya, kita sekarang siap untuk menerapkan algoritma ini pada berbagai masalah prediksi nilai kontinu lainnya. Terima kasih sudah membaca artikel ini, Selamat Belajar!

Source Code : Kaggle

Support Vector Machine

Support Vector Machine merupakan algoritma machine learning yang bekerja dengan cara mencari hyperplane optimal untuk memisahkan data ke dalam kelas-kelas berbeda. Dalam kasus data dua dimensi, hyperplane ini adalah garis lurus yang memisahkan data. Di ruang tiga dimensi, hyperplane menjadi bidang, dan di dimensi lebih tinggi, hyperplane tetap disebut hyperplane. Tujuan SVM adalah menemukan hyperplane yang memaksimalkan margin antara dua kelas, yang dikenal sebagai margin maximization.

Support Vectors

Support vectors adalah titik data yang paling dekat dengan hyperplane. Titik-titik ini sangat penting karena mereka menentukan posisi dan orientasi hyperplane. Jika support vectors diubah, hyperplane yang memisahkan kelas juga akan berubah. Oleh karena itu, SVM hanya bergantung pada beberapa titik data penting ini, menjadikannya efisien dalam hal penggunaan memori.

Margin Maximization

Margin adalah jarak antara hyperplane dan titik data terdekat dari setiap kelas. SVM berusaha untuk menemukan hyperplane yang memaksimalkan margin ini. Hyperplane dengan margin terbesar dipilih karena diharapkan dapat memberikan generalisasi yang lebih baik pada data baru. Margin yang lebih besar mengurangi risiko overfitting, yang terjadi ketika model terlalu menyesuaikan data pelatihan dan tidak bekerja dengan baik pada data yang tidak terlihat.

Kernel Trick

Dalam banyak kasus, data tidak dapat dipisahkan secara linear di ruang fitur asli. Untuk mengatasi ini, SVM menggunakan kernel trick, yang memetakan data ke ruang dimensi lebih tinggi di mana data dapat dipisahkan secara linear. Kernel yang umum digunakan termasuk kernel linear, polynomial, dan radial basis function (RBF). Dengan kernel trick, SVM dapat menangani data yang sangat kompleks dan tidak dapat dipisahkan secara linear.

Fungsi Kernel

1. Linear Kernel: Digunakan untuk data yang dapat dipisahkan secara linear.

2. Polynomial Kernel: Memetakan data ke ruang polinomial.

3. Radial Basis Function (RBF) Kernel: Memetakan data ke ruang dimensi tak hingga.

SVM dengan kernel trick memungkinkan model untuk menemukan hyperplane optimal di ruang fitur yang lebih tinggi tanpa perlu menghitung koordinat data dalam ruang tersebut secara eksplisit.

Studi Kasus: Klasifikasi kualitas Wine

Pada bagian ini, kita akan mengimplementasikan algoritma Support Vector Machine (SVM) menggunakan dataset Wine Quality.

Mengimpor Library dan Dataset

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import warnings
warnings.filterwarnings('ignore')

wine_data = pd.read_csv('/kaggle/input/red-wine-quality-cortez-et-al-2009/winequality-red.csv')
wine_data.head()

Pada langkah ini, kita mengimpor library-library yanng diperlukan dan membaca dataset Wine Quality dari file CSV yang tersedia di Kaggle.

Eksplorasi dan Pembersihan Data

Pertama-tama kita memeriksa informasi tentang dataset, termasuk jumlah baris dan kolom, serta tipe data setiap kolom.

wine_data.info()

Dari informasi di atas dapat diketahui bahwa keseluruhan data memiliki tipe data numerik. Selanjutnya adalah memeriksa statistik deskriptif dari dataset seperti mean, standard deviation, minimum, dan maximum value untuk setiap fitur.

wine_data.describe()

Kemudian kita juga perlu memeriksa apakah ada missing values dalam dataset.

wine_data.isnull().sum()

Hasil menunjukkan bahwa tidak ada missing values. Selanjutnya kita akan menampilkan sejumlah visualisasi dari data yang kita gunakan

plt.figure(figsize=(8, 6))
sns.countplot(data=wine_data, x='quality', palette='viridis')
plt.title('Wine Quality Distribution')
plt.xlabel('Quality')
plt.ylabel('Count')
plt.show()

Plot ini menunjukkan sebaran jumlah sampel anggur untuk setiap nilai kualitas. Ini membantu kita memahami berapa banyak anggur yang masuk dalam setiap kategori kualitas.

plt.figure(figsize=(12, 8))
sns.heatmap(wine_data.corr(), annot=True, cmap='coolwarm')
plt.title('Feature Correlation Heatmap')
plt.show()

Plot ini menunjukkan korelasi antar fitur dalam dataset. Nilai korelasi berkisar dari -1 hingga 1. Nilai positif menunjukkan korelasi positif, sementara nilai negatif menunjukkan korelasi negatif. Ini membantu kita memahami hubungan antar fitur.

features = ['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar', 'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density', 'pH', 'sulphates', 'alcohol']
plt.figure(figsize=(20, 15))
for i, feature in enumerate(features):
    plt.subplot(4, 3, i+1)
    sns.histplot(wine_data[feature], kde=True, bins=30, color='blue')
    plt.title(f'Distribusi {feature}')
plt.tight_layout()
plt.show()

Plot ini menunjukkan distribusi nilai dari setiap fitur utama dalam dataset. Ini membantu kita memahami sebaran data dan mendeteksi adanya outlier.

plt.figure(figsize=(20, 15))
for i, feature in enumerate(features):
    plt.subplot(4, 3, i+1)
    sns.boxplot(y=wine_data[feature], color='blue')
    plt.title(f'Boxplot {feature}')
plt.tight_layout()
plt.show()

Plot ini menunjukkan boxplot dari setiap fitur utama dalam dataset. Boxplot memberikan informasi tentang distribusi data, median, kuartil, dan potensi outlier. Ini membantu kita memahami karakteristik distribusi setiap fitur lebih detail.

Preprocessing Data

Selanjutnya adalah melakukan prapemrosesan pada data. Tahap ini bertujuan agar data siap dimasukkan ke dalam model machine learning.

X = wine_data.drop('quality', axis=1)
y = wine_data['quality']

y = (y > 5).astype(int)

Pertama, kita memisahkan fitur (X) dan target (y). Kita mengubah kolom quality menjadi variabel binary di mana nilai 0 menunjukkan kualitas <= 5 dan nilai 1 menunjukkan kualitas > 5.

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Selanjutnya, kita melakukan scaling pada fitur menggunakan StandardScaler untuk memastikan semua fitur memiliki skala yang sama.

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

Kita membagi data menjadi training set dan test set dengan proporsi 80% training dan 20% testing.

Membuat Model SVM

svm_model = SVC(kernel='linear')
svm_model.fit(X_train, y_train)

y_pred = svm_model.predict(X_test)

Pada bagian ini, kita membangun model SVM menggunakan kernel linear dan melatihnya dengan data training. Kemudian, kita melakukan prediksi pada data test.

Model Evaluation

print(classification_report(y_test, y_pred))

Kita mengevaluasi performa model menggunakan classification_report yang memberikan metrik seperti precision, recall, dan f1-score untuk setiap kelas.

plt.figure(figsize=(8, 6))
sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.show()

Kita juga menampilkan confusion matrix untuk melihat jumlah prediksi benar dan salah untuk setiap kelas.

Tambahan : Menggunakan Kernel RBF

Jika pada percobaan sebelumnya kita menggunakan kernel linear, sekarang mari kita coba membuat model svm menggunakan kernel rbf. gamma='auto' berarti bahwa parameter gamma akan diatur ke nilai default.

svm_model_rbf = SVC(kernel='rbf', gamma='auto')
svm_model_rbf.fit(X_train, y_train)

y_pred_rbf = svm_model_rbf.predict(X_test)

# Evaluasi performa model RBF
print(classification_report(y_test, y_pred_rbf))

plt.figure(figsize=(8, 6))
sns.heatmap(confusion_matrix(y_test, y_pred_rbf), annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.show()

Dari hasli yang didapatkan dapat dilihat bahwa hasil klasifikasi yang menggunakan kernel RBF mendapatkan hasil yang lebih baik dibandingkan dengan menggunakan kernel Linear.

Kesimpulan

Dalam artikel ini, kita membahas konsep dasar Support Vector Machine (SVM) dan mengimplementasikannya pada dataset Wine Quality untuk klasifikasi kualitas anggur. Hasil evaluasi menunjukkan bahwa SVM dengan kernel RBF memberikan performa lebih baik dengan akurasi 77% dibandingkan kernel linear dengan akurasi 73%. Visualisasi seperti distribusi kualitas anggur, heatmap korelasi fitur, dan boxplot distribusi fitur utama membantu memahami karakteristik data. Secara keseluruhan, SVM adalah algoritma yang kuat untuk tugas klasifikasi, terutama saat data tidak dapat dipisahkan secara linear. Selain itu, perbedaan hasil antara model yang menggunakan kernel RBF dengan linear menggambarkan pentingnya untuk melakukan tuning terhadap parameter-parameter yang ada di dalam model. Terima kasih sudah membaca artikel ini. Semoga bermanfaat dan selamat belajar!

Source Code : Kaggle

Mengenal K-Nearest Neighbor (KNN)

K-Nearest Neighbor adalah algoritma yang mengklasifikasikan sebuah data baru berdasarkan kemiripannya dengan data yang sudah ada. Misalnya kita memiliki sekelompok data yang sudah dikategorikan, dan kemudian kita ingin mengkategorikan data baru. KNN akan mencari data yang paling mirip dengan data baru ini dan menggunakan informasi tersebut untuk menentukan kategori data baru. Berikut adalah tahapan yang terjadi dalam KNN:

1. Pilih jumlah tetangga (k): Jumlah tetangga yang akan digunakan untuk menentukan kategori data baru. Biasanya, k adalah angka ganjil untuk menghindari hasil yang setara dalam klasifikasi.

2. Hitung jarak: Hitung jarak antara data baru dan semua data dalam dataset yang sudah ada. Jarak ini biasanya dihitung menggunakan rumus Euclidean.

3. Pilih tetangga terdekat: Pilih k data terdekat yang memiliki jarak terkecil dengan data baru.

4. Tentukan kategori: Lihat kategori dari k tetangga terdekat. Kategori yang paling sering muncul di antara tetangga terdekat akan menjadi kategori untuk data baru.

Rumus Euclidean merupakan metode yang paling umum digunakan untuk menghitung jarak antara dua titik dalam ruang berdimensi n. Misalnya, jika kita memiliki dua titik \(A\) dan \(B\) dengan koordinat masing-masing \((x_1, y_1)\) dan \((x_2, y_2)\), maka jarak Euclidean antara keduanya adalah:

\(\text{Euclidean Distance} = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}\)

Rumus ini bisa diperluas untuk data dengan lebih banyak dimensi.

Kelebihan dari KNN antara lain adalah prosesnya yang dipahami dan diimplementasikan. KNNjuga tidak memerlukan pelatihan model, karena ia hanya menyimpan data. Selain itu, ia juga dapat menangani data dengan kategori yang banyak.

KNN juga memiliki sejumlah kekurangan seperti diperlukannya banyak memori karena harus menyimpan semua data. Waktu prediksi KNN bisa berlangsung lama ketika dataset sangat besar. KNN juga sensitif terhadap fitur yang tidak relevan atau skala yang berbeda.

Studi Kasus Klasifikasi Bunga Iris

Setelah memahami dasar-dasar K-Nearest Neighbor (KNN) pada bagian sebelumnya, mari kita lanjutkan dengan studi kasus penerapan KNN. Kita akan menggunakan dataset Iris yang berisi informasi tentang tiga jenis bunga Iris: Iris-setosa, Iris-versicolor, dan Iris-virginica. Setiap jenis bunga memiliki empat fitur:

• Panjang sepal (sepal_length)

• Lebar sepal (sepal_width)

• Panjang petal (petal_length)

• Lebar petal (petal_width)

Dataset Iris yang digunakan pada artikel ini berasal dari kaggle dan bisa dilihat pada link berikut.

import warnings
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelEncoder
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
warnings.filterwarnings('ignore')

Pertama kita mengimpor library yang diperlukan terlebih dahulu. Library-library ini mencakup tools untuk manipulasi data (pandas), visualisasi data (seaborn dan matplotlib), preprocessing (LabelEncoder), algoritma KNN, dan evaluasi model (accuracy_score, confusion_matrix, classification_report).

data = pd.read_csv('/kaggle/input/iris-flower-dataset/IRIS.csv')
data.head()

Selanjutnya kita memuat Dataset Iris dengan pd.read_csv lalu menampilkan lima baris pertama untuk memastikan data telah dimuat dengan benar.

data['species'].value_counts()

Selanjutnay kita lihat berapa banyak contoh setiap jenis bunga dalam dataset.

label_encoder = LabelEncoder()
data['species'] = label_encoder.fit_transform(data['species'])
data['species'].value_counts()

LabelEncoder digunakan untuk mengubah label kategori (Iris-setosa, Iris-versicolor, Iris-virginica) menjadi angka (0, 1, 2). Selanjutnya kita jalankan kembali data['species'].value_counts() untuk melihat apakah kolom species sudah berubah menjadi angka.

Visualisasi Data

Selanjutnya adalah melakukan visualisasi pada data yang ada di dalam dataset. Di sini kita akan menampilkan pairplot dan heatmap.

sns.pairplot(data, hue='species', markers=["o", "s", "D"])
plt.show()

plt.figure(figsize=(8, 6))
sns.heatmap(data.corr(), annot=True, cmap='coolwarm', linewidths=0.5)
plt.title('Correlation Matrix')
plt.show()

Pair plot menunjukkan hubungan antara setiap fitur dan bagaimana mereka dipisahkan berdasarkan kelas. Heatmap menunjukkan korelasi antara fitur-fitur dalam dataset.

Menentukan Fitur dan Target

X = data.drop('species', axis=1)
y = data['species']

Fitur (X) mencakup semua kolom kecuali 'species', dan target (y) adalah kolom 'species'.

Membagi Data

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

Selanjutnya adalah membagi data menjadi data latih dan data uji. Di sini kita membagi data latih dan data uji dengan rasio 80:20.

Inisialisasi dan Pelatihan Model KNN

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

Model KNN diinisialisasi dengan k=3 dan dilatih menggunakan data latih.

Evaluasi Model

y_pred = knn.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)

print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Classification Report:\n", class_report)

Model dievaluasi menggunakan metrik akurasi, confusion matrix, dan classification report untuk melihat performa model.

plt.figure(figsize=(8, 6))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False)
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

Selamat kita telah berhasil menerapkan KNN untuk melakukan prediksi data iris. Kita bisa melihat bahwa model yang kita buat bisa melakukan prediksi dengan akurasi 100%.

Kesimpulan

K-Nearest Neighbor (KNN) adalah algoritma yang sangat berguna dan mudah diimplementasikan untuk berbagai tugas klasifikasi. Melalui studi kasus menggunakan dataset Iris, kita telah melihat bagaimana KNN dapat digunakan untuk mengkategorikan jenis bunga berdasarkan fitur-fiturnya. Dengan visualisasi data yang tepat dan evaluasi model yang baik, kita dapat memastikan bahwa model KNN bekerja dengan optimal.

Meskipun memiliki beberapa kekurangan, seperti kebutuhan memori yang besar dan sensitivitas terhadap fitur yang tidak relevan, KNN tetap menjadi pilihan yang populer dalam dunia machine learning karena kesederhanaannya dan kemampuannya untuk menangani berbagai jenis data. Namun perlu diketahui juga, dataset iris yang kita gunakan terbilang sebagai data yang 'sangat bersih', sehingga tidak mengherankan hasilnya akan sangat bagus ketika menggunakan sejumlah metode. Sehingga kita tidak perlu terkejut ketika menerapkan KNN pada dataset lain, hasilnya tidak sebagus menggunakan dataset iris. Oleh karena itu, diharapkan kita bisa terus belajar dan melakukan eksplorasi terhadap metode-metode baru yang senantiasa berkembang. Terima kasih sudah membaca artikel ini, semoga bermanfaat dan selamat belajar!.

Source Code : Kaggle