Pengantar Pemrograman Lanjut

Cheatsheet Content

### Konsep Dasar Perulangan Perulangan (looping) adalah instruksi kode program yang dieksekusi berulang kali untuk memerintah komputer melakukan tugas yang sama secara berulang. #### Fungsi Perulangan - Mengotomatisasi tugas yang berulang. - Mengurangi duplikasi kode. - Mempermudah pemrosesan data (array/list, file, algoritma pencarian, perhitungan komputasional). #### Jenis Perulangan Utama ##### 1. `while` loop (Pengulangan Berdasarkan Kondisi) - Program akan terus mengulang selama kondisi bernilai `True`. - **Sintaks:** ```python while kondisi: pernyataan ``` - **Kelebihan:** Cocok untuk proses yang jumlah iterasinya belum diketahui, fleksibel untuk berbagai jenis kondisi. - **Kekurangan:** Berpotensi `infinite loop` jika kondisi tidak berubah. **Contoh Implementasi `while` loop:** - **Menghitung mundur:** ```python count = 5 while count > 0: print("Hitung mundur:", count) count -= 1 ``` - **Validasi input:** ```python password = "" while password != "12345": password = input("Masukkan password: ") print("Login berhasil!") ``` ##### 2. `for` loop (Pengulangan Berdasarkan Koleksi / Terbatas) - Digunakan untuk mengulang sejumlah elemen dalam struktur data (list, tuple, dictionary, string) atau range tertentu. - **Sintaks:** ```python for variabel in koleksi: pernyataan ``` - **Contoh Implementasi `for` loop:** - **Iterasi list:** ```python buah = ["apel", "jeruk", "mangga"] for item in buah: print(item) ``` - **Perulangan angka dengan `range()`:** ```python for i in range(1, 6): # Dari 1 sampai 5 print("Iterasi ke:", i) ``` - **Iterasi dictionary:** ```python nilai = {"Ali": 80, "Budi": 90, "Cici": 75} for nama, skor in nilai.items(): print(nama, "memperoleh nilai", skor) ``` #### Pengulangan Bersarang (Nested Loop) - Loop di dalam loop. - Digunakan untuk kasus bertingkat (tabel, matriks, kombinasi data). - **Contoh:** - **Menampilkan pola bintang:** ```python for i in range(1, 6): for j in range(i): print("*", end="") print() ``` - **Iterasi Matriks 2D:** ```python matriks = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] for baris in matriks: for kolom in baris: print(kolom, end=" ") print() ``` #### Loop Control Statements Digunakan untuk mengontrol jalannya loop. ##### 1. `break` - Menghentikan loop sebelum waktunya. - **Contoh:** ```python for i in range(10): if i == 5: break print(i) ``` ##### 2. `continue` - Melewati iterasi saat ini dan melanjutkan ke iterasi berikutnya. - **Contoh:** ```python for i in range(10): if i % 2 == 0: # Hanya angka ganjil continue print(i) ``` ##### 3. `pass` - Placeholder; tidak melakukan apa pun. Berguna saat sintaks memerlukan blok kode tetapi tidak ada aksi yang diperlukan. - **Contoh:** ```python for huruf in "Python": if huruf == "h": pass print(huruf) ``` ### Array Array adalah struktur data yang memungkinkan untuk menyimpan sekumpulan elemen data dengan tipe yang sama dalam satu variabel. #### Karakteristik Utama - **Homogen:** Semua elemen dalam array harus memiliki tipe data yang sama (misalnya, semua integer atau semua float). - **Berurutan:** Elemen-elemen disimpan dalam lokasi memori yang berdekatan (kontigu). - **Berindeks:** Setiap elemen diakses menggunakan indeks numerik yang dimulai dari 0. - **Efisiensi:** Lebih efisien dalam hal penggunaan memori dan kecepatan dibandingkan list untuk data homogen. #### Perbedaan Array vs List (Python) | Fitur | Array | List | |----------------|----------------------------------------|--------------------------------------| | Tipe Data | Elemen harus bertipe sama | Elemen bisa bertipe berbeda | | Deklarasi | Perlu impor modul `array` atau `NumPy` | Tidak perlu impor modul eksplisit | | Operasi Arit. | Dapat langsung menangani | Tidak dapat langsung menangani | | Akses/Cetak | Perlu loop eksplisit | Dapat dicetak langsung | | Memori | Lebih hemat memori | Lebih boros memori | | Fleksibilitas | Kurang fleksibel (penambahan/penghapusan berdasarkan elemen) | Lebih fleksibel (modifikasi data mudah) | #### Kegunaan Array dalam Python - **Pengolahan data numerik:** Efisien untuk sejumlah besar data numerik bertipe sama. - **Operasi matematika:** Penjumlahan, pengurangan, perkalian, pembagian pada setiap elemen. - **Pengurutan data:** Mengurutkan elemen (naik/turun). - **Manipulasi data:** Menambah, menghapus, mencari elemen. - **Penghematan memori:** Lebih efisien untuk data homogen. #### Konsep Dasar Array 1. **Elemen dan Indeks:** - Setiap data dalam array disebut *elemen*, dan setiap elemen memiliki *indeks*. - Contoh: `angka = [4, 7, 2, 9]` | Indeks | 0 | 1 | 2 | 3 | |--------|---|---|---|---| | Elemen | 4 | 7 | 2 | 9 | 2. **Deklarasi dan Inisialisasi:** - **Deklarasi:** Menentukan variabel array. - **Inisialisasi:** Memberikan nilai awal. - Contoh: `angka = [10, 20, 30]` #### Membuat Array di Python - **Menggunakan modul `array`:** ```python import array my_array = array.array('i', [1, 2, 3]) # 'i' untuk signed int print(my_array) # Output: array('i', [1, 2, 3]) ``` - **Menggunakan pustaka `NumPy` (lebih umum untuk komputasi ilmiah):** ```python import numpy as np my_np_array = np.array([1, 2, 3, 4, 5]) print(my_np_array) # Output: [1 2 3 4 5] ``` #### Operasi Dasar pada Array - **Akses Elemen Array:** Menggunakan indeks. ```python angka = [10, 20, 30] print(angka[1]) # Output: 20 ``` - **Mengubah Nilai Elemen:** ```python angka = [10, 20, 30] angka[2] = 99 print(angka) # Output: [10, 20, 99] ``` - **Menampilkan Semua Elemen (Traversal):** Menggunakan perulangan. ```python angka = [10, 20, 30] for i in range(len(angka)): print(angka[i]) ``` - **Menghitung Jumlah Elemen:** ```python angka = [10, 20, 30] print(len(angka)) # Output: 3 ``` #### Operasi Lanjut pada Array 1. **Pencarian (Searching):** - **Linear Search:** Mencari elemen satu per satu. ```python target = 20 found = False angka = [10, 20, 30, 40] for i in range(len(angka)): if angka[i] == target: found = True break print(found) # Output: True ``` 2. **Pengurutan (Sorting):** Mengurutkan elemen dari kecil ke besar atau sebaliknya. ```python angka = [30, 10, 20] angka.sort() print(angka) # Output: [10, 20, 30] ``` 3. **Array Multidimensi:** Array yang elemen-elemennya merupakan array lain (misalnya matriks). - **Contoh Matriks 2D:** ```python matriks = [ [1, 2, 3], [4, 5, 6] ] ``` - **Akses Elemen:** ```python print(matriks[1][2]) # Output: 6 (elemen baris 1, kolom 2) ``` #### Jenis-Jenis Array - **Array Statis:** Ukuran ditentukan di awal dan tidak bisa berubah. - **Array Dinamis:** Ukuran bisa bertambah atau berkurang. #### Kesalahan Umum pada Array - **Index Out of Range:** Mengakses indeks di luar batas array. - **Tipe Data Campur:** Pada bahasa tertentu, array harus menyimpan tipe data yang sama. - **Lupa Inisialisasi:** Menggunakan array sebelum diberi nilai awal. - **Kesalahan dalam loop:** Jumlah iterasi melebihi ukuran array. ### Struktur Data Matriks Matriks adalah struktur data dua dimensi yang tersusun atas baris (rows) dan kolom (columns). Dalam pemrograman, matriks umumnya diimplementasikan sebagai array 2 dimensi atau list di dalam list. #### Kegunaan Matriks - Representasi data tabular. - Komputasi numerik dan aljabar linear. - Visualisasi dan citra digital (gambar = matriks pixel). - Perhitungan algoritmik (graph adjacency matrix, dynamic programming). #### Deklarasi dan Representasi Matriks - **Konseptual (Matriks 3x3):** ``` A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] ``` - **Dalam Python (list of lists):** ```python A = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] ``` #### Operasi Dasar Matriks ##### 1. Mengakses Elemen - `A[i][j]` = elemen pada baris `i`, kolom `j`. - Indeks biasanya dimulai dari 0. - **Contoh:** ```python A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] print(A[1][2]) # Output: 6 (baris 1, kolom 2) ``` ##### 2. Traversal Matriks - Proses mengunjungi seluruh elemen matriks. - **Contoh:** ```python A = [[1, 2], [3, 4]] for i in range(len(A)): for j in range(len(A[0])): print(A[i][j], end=" ") print() ``` ##### 3. Penjumlahan Dua Matriks - **Syarat:** Ukuran kedua matriks harus sama. - **Rumus:** $$C_{ij} = A_{ij} + B_{ij}$$ - **Contoh kode:** ```python A = [[1, 2], [3, 4]] B = [[5, 6], [7, 8]] C = [[0, 0], [0, 0]] for i in range(len(A)): for j in range(len(A[0])): C[i][j] = A[i][j] + B[i][j] print(C) # Output: [[6, 8], [10, 12]] ``` ##### 4. Pengurangan Dua Matriks - **Syarat:** Ukuran kedua matriks harus sama. - **Rumus:** $$C_{ij} = A_{ij} - B_{ij}$$ ##### 5. Transpose Matriks - Menukar baris menjadi kolom. - **Rumus:** $$(A^T)_{ji} = A_{ij}$$ - **Contoh kode:** ```python A = [[1, 2], [3, 4]] T = [[0, 0], [0, 0]] # Matriks transpose for i in range(len(A)): for j in range(len(A[0])): T[j][i] = A[i][j] print(T) # Output: [[1, 3], [2, 4]] ``` ##### 6. Matriks Identitas - Matriks bujur sangkar dengan 1 di diagonal utama dan 0 di tempat lain. - **Rumus:** $$I_{ij} = 1 \text{ if } i=j \text{ else } 0$$ ##### 7. Perkalian Matriks - **Syarat:** Jumlah kolom matriks pertama harus sama dengan jumlah baris matriks kedua. - **Rumus:** $$C_{ij} = \sum_{k=0}^{n-1} A_{ik} B_{kj}$$ - **Contoh kode:** ```python A = [[1, 2], [3, 4]] # 2x2 B = [[5, 6], [7, 8]] # 2x2 C = [[0, 0], [0, 0]] # Hasil 2x2 for i in range(len(A)): for j in range(len(B[0])): for k in range(len(B)): # Iterasi melalui kolom A / baris B C[i][j] += A[i][k] * B[k][j] print(C) # Output: [[19, 22], [43, 50]] ``` #### Aplikasi Matriks dalam Pemrograman ##### 1. Machine Learning (Komputasi Linear) - Perhitungan output layer sederhana (feedforward) menggunakan operasi matriks. - **Contoh Kasus:** Input fitur `x`, bobot `W`, dan bias `b` untuk menghitung output neuron. - **Kode Python (menggunakan NumPy):** ```python import numpy as np x = np.array([[0.5, 1.2, -0.3]]) # Input fitur (shape (1,3)) W = np.array([[0.2, -0.5], [1.0, 0.3], [-0.7, 0.8]]) # Bobot (shape (3,2)) b = np.array([[0.1, -0.2]]) # Bias (shape (1,2)) output = x @ W + b # Operasi matriks (x @ W adalah perkalian matriks) print("Output neuron:", output) ``` ##### 2. Pemrosesan Citra (Gambar sebagai Matriks Pixel) - Gambar grayscale dapat direpresentasikan sebagai matriks 2D dengan nilai pixel (0-255). - Operasi aritmatika pada matriks pixel menghasilkan transformasi citra. - **Contoh:** Membaca gambar, menghitung rata-rata pixel, dan mencerahkan gambar. - **Kode Python (menggunakan PIL dan NumPy):** ```python from PIL import Image import numpy as np # Buka gambar dan ubah ke grayscale img = Image.open("gambar.jpg").convert("L") # Ubah ke matriks numpy pixel = np.array(img) print("Ukuran matriks pixel:", pixel.shape) print("Rata-rata intensitas:", pixel.mean()) # Mencerahkan gambar 30 poin bright = np.clip(pixel + 30, 0, 255) # Convert kembali ke gambar dan simpan bright_img = Image.fromarray(bright.astype('uint8')) bright_img.save("gambar_terang.jpg") ``` ##### 3. Graph Theory (Adjacency Matrix) - Matriks adjacency digunakan untuk merepresentasikan graf. - `A[i][j] = 1` jika ada edge antara node `i` dan `j`, `0` jika tidak ada. - **Contoh:** Mencari tetangga node tertentu pada graf 4 node. - **Kode Python (menggunakan NumPy):** ```python import numpy as np # Adjacency matrix untuk graf tidak berarah A = np.array([ [0, 1, 1, 0], # node 0 terhubung ke 1,2 [1, 0, 1, 0], # node 1 terhubung ke 0,2 [1, 1, 0, 1], # node 2 terhubung ke 0,1,3 [0, 0, 1, 0] # node 3 terhubung ke 2 ]) # Cari tetangga node 2 neighbors = np.where(A[2] == 1)[0] print("Adjacency Matrix:\n", A) print("Tetangga node 2:", neighbors) # Output: [0 1 3] ``` ##### 4. Simulasi dan Fisika Komputasi - Simulasi difusi panas pada grid 2D menggunakan matriks. - Setiap elemen matriks diperbarui berdasarkan nilai tetangganya. - Konsep ini digunakan pada CFD (Computational Fluid Dynamics), simulasi gelombang, difusi, dan fisika termal. - **Persamaan (Finite Difference):** $$T_{baru}[i, j] = \frac{T[i-1, j] + T[i+1, j] + T[i, j-1] + T[i, j+1]}{4}$$ - **Kode Python (contoh sederhana):** ```python import numpy as np # Grid 10x10 temperatur awal T = np.zeros((10, 10)) # Sumber panas di tengah T[5,5] = 100 # Iterasi simulasi for step in range(50): T_new = T.copy() for i in range(1, 9): for j in range(1, 9): T_new[i,j] = (T[i-1,j] + T[i+1,j] + T[i,j-1] + T[i,j+1]) / 4 T = T_new print("Distribusi panas akhir:\n", T) ``` ##### 5. Dynamic Programming (Memoization dalam Tabel Matriks) - **Contoh:** Longest Common Subsequence (LCS) menggunakan tabel DP (matriks). - `dp[i][j]` adalah sub-solusi LCS pada prefix `X` dan `Y`. - Tabel DP berbentuk matriks $(m+1) \times (n+1)$. - Matriks digunakan untuk menyimpan hasil perhitungan sebelumnya (memoization). - **Kode Python:** ```python def LCS(X, Y): m, n = len(X), len(Y) # Matriks DP diinisialisasi dengan 0 dp = [[0] * (n + 1) for _ in range(m + 1)] for i in range(1, m + 1): for j in range(1, n + 1): if X[i-1] == Y[j-1]: dp[i][j] = dp[i-1][j-1] + 1 else: dp[i][j] = max(dp[i-1][j], dp[i][j-1]) return dp[m][n], dp X = "ABCBDAB" Y = "BDCAB" length, table = LCS(X, Y) print("Panjang LCS:", length) print("Tabel DP:") for row in table: print(row) ``` ### Pemrograman Modular Pemrograman modular adalah pendekatan perancangan perangkat lunak yang membagi sistem besar menjadi unit-unit kecil (modul) yang mandiri secara fungsional, memiliki tanggung jawab yang jelas, dan saling berinteraksi melalui antarmuka (interface) tertentu. #### Inti Filosofi "Complexity is managed by decomposition." (Mengelola kompleksitas dengan memecah masalah). #### Modul sebagai Unit Abstraksi - Detail internal modul disembunyikan (Information Hiding). - Pengguna modul hanya perlu memahami apa yang dilakukan, bukan bagaimana caranya (Encapsulation). #### Sejarah dan Latar Belakang Modularisasi - Bermula dari Pemrograman Terstruktur (1970-an) dan karya Edsger W. Dijkstra. - Solusi terhadap kritik "spaghetti code" yang sulit dibaca, diuji, dan dikembangkan dalam tim. #### Tujuan Utama Program Modular 1. **Mengelola Kompleksitas:** Masalah besar dipecah menjadi masalah kecil yang lebih mudah dianalisis dan diselesaikan. 2. **Meningkatkan Kualitas Perangkat Lunak:** - Meningkatkan Keandalan (reliability). - Meningkatkan Kemudahan Pemeliharaan (maintainability). - Meningkatkan Skalabilitas sistem. 3. **Mendukung Pengembangan Berbasis Tim:** Setiap modul dapat dikembangkan oleh individu berbeda dan diuji secara terpisah. #### Karakteristik Modul yang Baik - **Single Responsibility:** Satu modul memiliki satu tujuan utama. Jika melakukan terlalu banyak hal, itu tanda desain buruk. - **Mandiri (Independence):** Modul dapat bekerja sendiri sejauh mungkin dan ketergantungan pada modul lain harus minimal. - **Antarmuka Jelas:** Modul memiliki input dan output yang jelas (interface contract). - **Mudah Digunakan Kembali (Reusable):** Tidak terlalu spesifik dan tidak bergantung pada konteks sempit. #### Prinsip-Prinsip Fundamental Modularisasi 1. **Decomposition:** Memecah sistem berdasarkan fungsi, proses, atau tanggung jawab. 2. **Abstraction:** Menyembunyikan detail internal dan hanya menampilkan fungsi utama saja. 3. **Encapsulation:** Mengikat data dan operasi dalam satu modul, mencegah akses langsung yang tidak perlu. 4. **Separation of Concerns:** Setiap modul menangani satu jenis kepentingan (concern) tertentu (mis. modul input, modul proses, modul output). #### Coupling (Keterikatan Antar Modul) - Tingkat ketergantungan antar modul. - Tujuan modularisasi: Coupling serendah mungkin (Loose Coupling lebih baik dari Tight Coupling). #### Cohesion (Keterpaduan dalam Modul) - Tingkat keterkaitan elemen dalam satu modul. - Modul ideal: High Cohesion (Baik) + Low Coupling (Baik). #### Modularisasi vs Monolitik | Fitur | Program Monolitik | Program Modular | |-----------------------|-------------------------------|-----------------------------| | Logika | Semua logika bercampur | Struktur jelas | | Pemeliharaan | Sulit dipelihara | Mudah diuji | | Pengembangan | Perubahan kecil berdampak besar | Mudah dikembangkan jangka panjang | | Filosofi | Tidak ada | Struktur tanggung jawab (bukan hanya ukuran file) | #### Modularisasi dalam Siklus Pengembangan Software Diterapkan sejak: - Analisis kebutuhan - Perancangan sistem - Implementasi - Pengujian - Pemeliharaan Modularisasi bukan hanya teknik coding, tetapi strategi desain. #### Modularisasi pada Berbagai Paradigma Pemrograman - **Pemrograman Prosedural:** Modul $\to$ fungsi / prosedur. - **Pemrograman Berorientasi Objek:** Modul $\to$ class / package. - **Pemrograman Fungsional:** Modul $\to$ fungsi murni (pure function). Konsep modular bersifat universal, lintas paradigma dan bahasa. #### Kesalahan Umum dalam Modularisasi - Modul terlalu besar (God Module). - Modul terlalu kecil tanpa tujuan jelas. - Modul saling bergantung kuat. - Tidak ada dokumentasi antarmuka modul. ### Pengantar Artificial Intelligence (AI) AI adalah teknologi yang dirancang untuk membuat sistem komputer mampu meniru kemampuan intelektual manusia, seperti belajar dari pengalaman, mengidentifikasi pola, membuat keputusan, dan menyelesaikan tugas kompleks. #### Sejarah Singkat AI - **1940-1980:** Konsep neuron buatan (McCulloch & Pitts, 1943), Uji Turing (1950), Perceptron (Frank Rosenblatt), Chatbot ELIZA (Joseph Weizenbaum). Mengalami "Musim Dingin AI" pertama karena keterbatasan. - **1980-2006:** Minat baru pada AI, kebangkitan jaringan neural (deep learning oleh David Rumelhart & John Hopfield). "Musim Dingin AI" kedua (1987-1997). Deep Blue mengalahkan Garry Kasparov (1997). Judea Pearl dan Geoffrey Hinton menghidupkan kembali deep learning. - **2007-2018:** Kemajuan komputasi cloud, peningkatan adopsi machine learning. AlexNet (CNN) memenangkan ImageNet. AlphaZero menguasai catur, shogi, Go. - **2010 - Sekarang:** Machine learning dan deep learning inti kemajuan AI modern. AI mampu melakukan tugas kompleks (pemrosesan bahasa alami, pengenalan gambar) dan mudah ditemukan di perangkat sehari-hari. #### Definisi Artificial Intelligence Cabang ilmu komputer yang mempelajari bagaimana membuat mesin atau program komputer mampu meniru kecerdasan manusia dalam: - Berpikir logis. - Belajar dari pengalaman. - Mengambil keputusan. - Memahami bahasa. - Mengenali pola. **Tujuan utama AI:** Menciptakan sistem yang dapat bertindak cerdas secara otonom. #### Mengapa AI Penting dalam Pemrograman Lanjut? AI adalah kelanjutan alami dari pemrograman lanjut, meliputi: - Struktur data. - Algoritma. - Pemrograman modular. - Analisis data. AI melatih cara berpikir algoritmik tingkat tinggi, pengambilan keputusan otomatis, pemrosesan data kompleks, dan sistem adaptif/cerdas. #### Perkembangan AI Sangat erat dengan: - Ketersediaan data. - Peningkatan daya komputasi. - Kemajuan algoritma. #### Karakteristik Sistem AI Sistem AI umumnya memiliki kemampuan: 1. **Perception:** Mengenali lingkungan (data, input). 2. **Reasoning:** Berpikir dan menarik kesimpulan. 3. **Learning:** Belajar dari data. 4. **Decision Making:** Memilih tindakan terbaik. 5. **Adaptation:** Menyesuaikan diri dengan kondisi baru. ##### 1. Perception (Persepsi) - Kemampuan AI untuk menerima dan memahami informasi dari lingkungan dalam bentuk data mentah (raw data). - Pada manusia: panca indera. Pada AI: data numerik, teks, gambar, suara, sensor. - **Konteks Pemrograman:** Membaca input, mengambil data dari file/database, menerima data dari sensor/API, mengubah data mentah ke format yang dapat diproses. - Tanpa perception, AI tidak memiliki "kesadaran lingkungan". - **Contoh:** Sistem AI menerima nilai IPK mahasiswa, program membaca data cuaca, aplikasi membaca teks ulasan pelanggan. (AI belum berpikir, hanya mengamati). ##### 2. Reasoning (Penalaran) - Kemampuan AI untuk menganalisis informasi, menarik kesimpulan, dan menyusun logika keputusan. - Menjawab pertanyaan: "Apa arti data ini dan apa yang seharusnya dilakukan?" - **Jenis Reasoning dalam AI:** - **Deductive Reasoning:** Dari aturan umum ke kesimpulan khusus (IF IPK $\ge$ 3.75 THEN layak beasiswa). - **Inductive Reasoning:** Dari data ke pola (menyimpulkan pola kelulusan dari data mahasiswa). - **Probabilistic Reasoning:** Menggunakan peluang (prediksi kemungkinan gagal bayar kredit). - **Dalam Pemrograman Lanjut:** Diwujudkan dalam percabangan (if-else), algoritma pencarian, perhitungan probabilitas, evaluasi kondisi. Reasoning adalah inti dari kecerdasan logis AI. ##### 3. Learning (Pembelajaran) - Kemampuan AI untuk meningkatkan kinerjanya berdasarkan pengalaman (data sebelumnya) tanpa harus diprogram ulang secara eksplisit. - Pembeda utama antara program biasa dengan sistem AI. - **Bentuk Learning dalam AI:** Belajar dari data historis, memperbaiki kesalahan sebelumnya, menyesuaikan parameter internal. - **Learning vs Program Konvensional:** | Fitur | Program Biasa | AI | |-----------------|---------------------|----------------------| | Aturan | Tetap | Dapat berubah | | Pembelajaran | Tidak belajar | Belajar dari data | | Perilaku | Statis | Adaptif | - Dalam pemrograman lanjut, konsep learning mempersiapkan menuju Machine Learning dan Neural Network. ##### 4. Decision Making (Pengambilan Keputusan) - Kemampuan AI untuk memilih tindakan terbaik dari beberapa kemungkinan berdasarkan data, tujuan, dan aturan/model. - **Proses Decision Making dalam AI:** Identifikasi pilihan, evaluasi setiap pilihan, pilih opsi terbaik, eksekusi keputusan. - Keputusan AI tidak selalu "benar mutlak", tetapi paling optimal menurut data yang ada. - **Dalam Pemrograman:** Diimplementasikan melalui if-else bertingkat, fungsi evaluasi, algoritma optimasi. ##### 5. Adaptation (Adaptasi) - Kemampuan AI untuk menyesuaikan perilakunya ketika lingkungan berubah. - Terjadi karena learning dan evaluasi hasil keputusan sebelumnya. - **Mengapa Adaptasi Penting?** Lingkungan dunia nyata dinamis, tidak selalu pasti, dan penuh perubahan. AI yang tidak adaptif akan cepat usang dan tidak relevan. - **Dalam Pemrograman Lanjut:** Melatih untuk membuat program fleksibel, menggunakan parameter, menghindari hard-coded logic. #### Autonomy (Kemandirian Sistem) - AI memiliki tingkat kemandirian tertentu dalam mengambil keputusan, menjalankan proses, dan mengoreksi diri. - Semakin tinggi autonomy, semakin sedikit intervensi manusia dan semakin kompleks sistemnya. - **Contoh Tingkat Autonomy:** | Tingkat | Contoh | |---------|------------------------| | Rendah | Sistem berbasis aturan | | Sedang | Sistem rekomendasi | | Tinggi | Mobil otonom | #### Tujuan (Goal-Oriented Behavior) - AI selalu dirancang dengan tujuan tertentu: meminimalkan kesalahan, memaksimalkan akurasi, mengoptimalkan hasil. - AI tidak berpikir tanpa tujuan. #### Hubungan Antar Karakteristik Karakteristik AI tidak berdiri sendiri, melainkan membentuk siklus: Perception $\to$ Reasoning $\to$ Decision $\to$ Learning $\to$ Adaptation. Siklus ini menjadikan AI: cerdas, adaptif, berorientasi tujuan. #### Perbedaan AI, Machine Learning, dan Deep Learning | Istilah | Penjelasan | |-----------------------|------------------------------------------| | Artificial Intelligence | Konsep umum kecerdasan mesin | | Machine Learning | AI yang belajar dari data | | Deep Learning | ML berbasis neural network berlapis | #### Cabang Utama AI - Machine Learning - Natural Language Processing - Computer Vision - Expert System - Robotics - Knowledge Representation & Reasoning #### Konsep Pemrograman yang Digunakan dalam AI - Struktur data kompleks (list, tree, graph, matrix). - Algoritma pencarian (BFS, DFS, heuristic). - Rekursi dan iterasi. - Pemrograman modular. - Pemrosesan data. ### Intelligent Agent & Problem Solving dalam AI #### Intelligent Agent Entitas (program/sistem) yang: - Mengamati lingkungan (perception). - Mengambil tindakan (action). - Bertujuan memaksimalkan pencapaian tujuan (goal). Agent adalah inti dari hampir seluruh sistem AI modern. ##### Komponen Intelligent Agent 1. **Environment (Lingkungan):** Dunia tempat agent beroperasi. 2. **Percepts (Input/Observasi):** Apa yang agent amati dari lingkungan. 3. **Actions (Tindakan):** Apa yang agent lakukan di lingkungan. 4. **Agent Program (Logika Pengambilan Keputusan):** Aturan atau algoritma yang menentukan tindakan berdasarkan persepsi. 5. **Goal (Tujuan):** Kondisi yang ingin dicapai agent. **Skema dasar:** Lingkungan $\to$ Perception $\to$ Agent $\to$ Action $\to$ Lingkungan. ##### Jenis-Jenis Intelligent Agent 1. **Simple Reflex Agent:** - Berdasarkan kondisi saat ini. - Menggunakan aturan IF-THEN. - Tidak memiliki memori. - **Contoh:** Jika suhu > 30°C $\to$ Nyalakan AC. 2. **Model-Based Agent:** - Memiliki memori keadaan sebelumnya. - Mempertimbangkan kondisi masa lalu. - Lebih "cerdas" dibanding reflex agent. 3. **Goal-Based Agent:** - Bertindak berdasarkan tujuan. - Membandingkan beberapa kemungkinan aksi untuk mencapai tujuan. - **Contoh:** Memilih rute tercepat ke tujuan. 4. **Utility-Based Agent:** - Memilih aksi dengan nilai terbaik (utility). - Menggunakan fungsi evaluasi. - Dasar optimasi AI. #### AI dan Masalah (Problem) Dalam AI, masalah direpresentasikan sebagai: - **Initial State:** Kondisi awal masalah. - **Goal State:** Kondisi akhir yang diinginkan. - **Actions:** Tindakan yang dapat dilakukan untuk mengubah state. - **Constraints:** Batasan-batasan yang harus dipenuhi. ##### State Space - Himpunan semua kondisi yang mungkin dari suatu masalah. - AI menjelajah state space untuk mencapai goal. - **Contoh Masalah Seleksi:** - State awal: Data mahasiswa. - Goal: Keputusan terbaik. - Action: Evaluasi aturan. #### Hubungan dengan Pemrograman Lanjut - **AI sebagai agent menggunakan:** Struktur data (list, dictionary), fungsi & modularisasi, algoritma pencarian sederhana, logika pengambilan keputusan. - **Mahasiswa belajar:** Berpikir sistem, berpikir berbasis tujuan, desain algoritma AI. ### Knowledge Representation & Rule-Based Reasoning #### Pengantar Knowledge Representation Dalam AI, *knowledge* adalah: fakta, aturan, dan hubungan antar konsep. AI tidak "tahu" secara alami, sehingga pengetahuan harus direpresentasikan. Tanpa representasi pengetahuan, AI tidak bisa reasoning, tidak bisa menjelaskan keputusan, dan menjadi sekadar program biasa. ##### Bentuk Knowledge Representation 1. **Fakta (Facts):** - **Contoh:** IPK = 3.8, Penghasilan = 2.5 juta. - **Dalam pemrograman:** Variabel, Dictionary, Database. 2. **Aturan (Rules):** - Bentuk umum: `IF kondisi THEN Kesimpulan`. - Aturan adalah dasar Rule-Based AI. 3. **Relasi:** - Hubungan antar data. - **Contoh:** Mahasiswa $\to$ Program Studi, Nilai $\to$ Kelulusan. #### Rule-Based System Sistem AI yang: - Menggunakan kumpulan aturan. - Melakukan reasoning secara logis. - Menghasilkan keputusan. ##### Komponen Rule-Based AI - **Knowledge Base:** Kumpulan aturan & fakta. - **Inference Engine:** Mesin penalaran yang menerapkan aturan pada fakta untuk menarik kesimpulan. - **Working Memory:** Area penyimpanan sementara untuk fakta-fakta yang sedang aktif. - **Decision Output:** Keputusan atau kesimpulan yang dihasilkan. ##### Forward Chaining (Konseptual) - Penalaran dari fakta $\to$ kesimpulan. - *Data-driven*. - Cocok untuk sistem seleksi & diagnosis sederhana. #### Kelebihan & Keterbatasan Rule-Based AI ##### Kelebihan - Mudah dipahami. - Transparan (mudah dilacak alur logikanya). - Cocok untuk domain terbatas. ##### Keterbatasan - Sulit diskalakan (jumlah aturan bisa sangat banyak). - Tidak adaptif tanpa modifikasi (perlu aturan baru untuk situasi baru). - Bergantung pada kualitas aturan (aturan yang buruk menghasilkan keputusan buruk). #### Hubungan dengan Pemrograman Lanjut Mahasiswa belajar: - Mengubah logika manusia $\to$ aturan formal. - Mendesain sistem modular berbasis aturan. - Menulis kode yang explainable (mudah dijelaskan).