Merancang Sistem dengan Cepat Lewat Pola Umum Yang Ada

Banyak mahasiswa kesulitan ketika merancang sistem saat merampungkan skripsi atau tugas akhirnya. Sebagian besar melihat rancangan senior-senior yang sudah menyelesaikan rancangan. Tetapi banyak juga rancangan yang menjadi rujukan kurang baik sehingga kesalahan akan merambat ke adik-adik kelasnya.

Untuk sistem berorientasi objek, banyak referensi yang menyediakan pola (pattern) sebuah sistem informasi. Manfaatnya adalah kita bisa menggunakan kembali rancangan yang pernah dibuat. Biaya pembuatan sistem pun menjadi murah, bahkan sepertinya tidak masuk akal dengan harga yang murah itu. Tetapi dengan menggunakan pola yang pernah ada, sepertinya masuk akal karena perancang sistem tinggal menggunakan saja. Beberapa vendor pembuat sistem membedakan bayaran ke tim perancang jika sistem yang dibuat hanya menggunakan pola yang ada. Sementara itu jika tim membangun pola baru, perusahaan pembuat software itu akan membayar lebih karena pola yang dibuat menjadi aset perusahaan.

Transaksi

Untuk file master (data nasabah, data barang, data mahasiswa, dan sejenisnya) sepertinya tidak ada masalah bagi perancang. Hal ini karena hanya melibatkan operasi create, read, update, dan delete (CRUD). Teknik bagaimana proses penyimpanan sudah standar tingga memakai saja tergantung jenis bahasa pemrograman yang digunakan. Nah, untuk transaksi berbeda karena melibatkan alur proses bisnis. Untuk yang standar digunakan seperti penjualan, pembelian, pendaftaran, dan yang sering dijumpai sepertinya tidak ada masalah. Tetapi untuk domain tertentu seperti kedokteran, data warehouse, dan sistem lain yang jarang dijumpai atau masih baru sangat sulit didapat. Untuk merancang dari nol pun sepertinya membutuhkan waktu yang lama. Memanfaatkan jasa konsultan pun membutuhkan kocek yang tidak murah.

Sumber Informasi Pola Disain Sistem

Banyak buku yang menyediakan pola sistem informasi, salah satu penulis yang rajin membuat pola sistem adalah Martin Fowler. Khususnya yang tertarik dengan sistem berorientasi objek. Namun salah satu informasi yang murah-meriah dan cukup baik polanya adalah link berikut ini.

Silahkan cari pola yang cocok dengan rancangan yang sedang kita buat. Selain transaksi tertentu seperti peminjaman, pembelian, penyewaan, dan lain-lain, pola tersebut untuk domain spesifik (business rule) tertentu seperti lembaga asuransi, hotel, farmasi, kedokteran, dan lain-lain sehingga bisa lebih akurat dibanding jika hanya mengandalkan jenis transaksinya. Berikut ini contoh untuk penyewaan apartemen.

Perhatikan, ternyata tersedia juga model logika (logical data model) selain model fisik/file (physical data model). Jadi untuk para mahasiswa jangan sampai berpusing-pusing ria merancang sesuatu yang sudah ada, apalagi jika hasilnya “nyeleneh”. Untuk DBMS bisa mengunakan produk yang banyak tersedia di pasaran, misalnya untuk kasus pembelian barang dengan database sederhana (Microsoft Access) berikut ini.

Dipublikasi di Software Engineering | 1 Komentar

Jangan Lupakan Service/Layanan

Orang yang berkecimpung dalam dunia teknologi informasi pasti mengenal istilah service oriented architecture atau yang lebih dikenal dengan SOA. Arsitektur ini bermaksud menangani service atau layanan yang diberikan oleh perusahaan kepada konsumen dengan ciri-ciri antara lain bebas platform, berbasis internet dan real-time, dan integrasi terhadap seluruh layanan yang ada. Ketika iseng-iseng membaca perihal SOA di internet, saya teringat kasus yang menimpa dunia pendidikan, terutama kampus tempat para dosen bekerja yang terdampak pandemic COVID-19.

Pembelian Jasa

Ketika saya ingin berlangganan internet, ada tawaran servis/layanan apa saja yang bisa diambil, misalnya tv kabel, disamping tentu saja akses internet, dengan biaya tambahan tergantung channel yang tersedia. Ketika sudah sepakat, pembayaran dilakukan, namun ada servis yang karena satu dan lain hal tidak bisa berjalan. Apakah konsumen diam saja? Tentu saja tidak. Mereka akan menuntut layanan yang bermasalah tersebut. Ada batas waktu penyelesaian yang diistilahkan dengan service level agreement (SLA) yaitu waktu maksimal provider dalam mengatasi masalah layanan yang ada. Misalnya waktu saya kerja di bank, untuk ATM tidak boleh melebihi 7 jam offlinenya. Jika tidak maka provider terkena pinalti.

Kondisi Khusus

Terkadang memang ada kondisi khusus, yang diistilahkan dengan force majeure. COVID-19 merupakan salah satunya. Contoh real adalah kampus yang tidak bisa mengadakan perkuliahan tatap muka. Ketika semi lock-down diterapkan di tanah air (PSBB), banyak kampus yang berfikir keras mengatasi masalah ini. Para pimpinan, rektor hingga dekan akan berfikir keras karena salah satu layanan utama yang menjadi core business, yaitu perkuliahan tatap muka tidak boleh dilaksanakan. Kalau didiamkan saja, alias pimpinan tidak mengambil tindakan dan menyerahkan sepenuhnya kepada dosen pengajar dalam mengganti perkuliahan tatap muka dengan online maka tidak akan ada standar dalam kampus tersebut. Ibarat konsumen, mahasiswa akan meminta kompensasi layanan yang hilang, yaitu tatap muka.

Perkuliahan Daring

Beberapa kampus sudah menyiapkan sarana dan instrumen bagi dosen dan mahasiswa dalam menjalankan perkuliahan online. Instrumen tersebut berupa e-learning, online meeting, webinar, dan sejenisnya. Efektif atau tidaknya instrumen tersebut adalah bertujuan mengkonversi layanan tatap muka yang hilang akibat bencana COVID-19. Memang tidak ada jaminan instrumen yang disediakan kampus dapat mengganti layanan tatap muka, tetapi hal itu merupakan antisipasi terhadap layanannya yang hilang. Kampus bisa saja menyerahkan sepenuhnya kepada dosen pengampu mata kuliah, tetapi antara dosen satu dengan lainnya memiliki kemampuan berbeda dalam pemahaman dunia online, ditambah beberapa mata kuliah agak sulit dilakukan secara online, misalnya praktikum. Jika pun dosen enggan dan “membandel” tidak menjalankan perkuliahan online semestinya dan mahasiswa kecewa, mereka tidak bisa menuntut kampus karena kampus sudah menyediakan sarana dengan baik. Berbeda jika kampus tidak menyediakan sarana “standar” dan hanya menyerahkan semua kepada dosen pengampu mata kuliah, sasaran kekecewaan bukan hanya ke dosen, tetapi kepada institusi yang dirasa tidak ada usaha mengganti layanannya yang hilang.

Service Level Agreement (SLA)

Istilah ini adalah batas waktu yang wajib diselesaikan oleh pemberi layanan ketika ada layanannya yang bermasalah. Tentu tidak ada yang bisa 100% layanan itu oke, bisa saja terjadi gangguan di tengah jalan. Untuk kasus pandemic saat ini, hampir kebanyakan kampus harus berhenti perkuliahan tatap muka di tengah jalan tanpa persiapan. SLA ini memang sulit didefinisikan, bisa satu bulan, satu semester, atau sampai pandemic berakhir, tapi setidaknya sebagian besar kampus sudah bisa mengantisipasi (walau masih banyak juga yang kacau balau) dan sudah ada gambaran bagaimana antisipasi di semester yang akan datang, apalagi dengan kondisi penerimaan mahasiswa baru.

Dengan diterapkannya new normal dan kuliah masih harus online, tidak ada salahnya kampus harus menyediakan instrumen resmi di kampusnya untuk menghadapi semester depan yang masih dilakukan secara daring. Memang masalah ini terjadi di kedua pihak, baik pemberi jasa maupun penerima jasa, dan sebaiknya kedua pihak saling memahami posisi sulit yang memang menimpa hampir sebagian besar orang. Sekian, semoga bisa menginspirasi dan pandemic ini segera berlalu; tetap semangat.

Dipublikasi di Komputer dan Masyarakat, Puisi Kehidupan | Meninggalkan komentar

Riset Bidang Informatika

Mahasiswa informatika yang mengerjakan skripsi atau tugas akhir biasanya berupa pembangunan sistem informasi baik perancangan maupun pembuatan program. Memang untuk mahasiswa S1, kompetensi akhir adalah mengaplikasikan ilmu yang diperoleh ketika kuliah dalam sebuah tugas akhir. Nah, masalahnya muncul ketika mempublikasikannya dalam sebuah jurnal yang sempat ada wacana sebagai syarat kelulusan seorang mahasiswa dimana masalah originality, novelty, dan kontribusi menjadi momok bagi para editor dalam menerima paper jenis ini. Ada baiknya kita mengurai masalah ini berdasarkan bidang ilmu informatika yang terpecah menjadi dua kutub yaitu ilmu komputer dan sistem informasi.

Ilmu Komputer

Bidang ini memang berfokus kepada metode yang berisi di dalamnya algoritma-algoritma yang membantu komputasi. Hampir semua riset di bidang ini fokus ke peningkatan akurasi, efisiensi, dan aspek-aspek lain terhadap kualitas sebuah metode yang diusulkan. Jadi riset yang fokus ke bidang ilmu komputer harus berisi tinjauan metode-metode terkini dan dilanjutkan dengan “mengutak-atik” parameter atau dengan penambahan sedikit algoritma/metode sehingga meningkatkan akurasi atau aspek lain. Jadi perlu ada pembuktian terhadap performa metode usulan. Oiya, saat ini istilah metode biasanya menggantikan istilah algoritma karena sifatnya yang lebih kompak dimana metode bisa berisi lebih dari satu jenis algoritma, misalnya Genetic Algorithms dengan “s” di belakang yg berarti jamak. Jika mahasiswa bidang ini menggunakan sebuah metode terhadap domain tertentu, misalnya bisnis, dia tinggal memilih fokus utama apakah ke metode atau ke domain penerapannya. Jika fokus ke ilmu komputer maka mau tidak mau pengujian akurasi dengan usulan peningkatan metode yang ada wajib ada. Repotnya banyak yang tidak membuat upaya peningkatan metode, hanya manfaat dan kontribusi terhadap domain penelitiannya, dalam hal ini aspek bisnis. Maka seharusnya mahasiswa tersebut fokus ke domain sistem informasi berikut ini.

Sistem Informasi

Bidang ini mungkin memiliki nama lain, misalnya di tempat saya dulu bernama information management, yang uniknya di Indonesia malah di level D3. Atau ada yang lain lagi misalnya business intelligence. Bidang ini membantu domain-domain di luar ilmu komputer seperti kedokteran, geografi, akuntansi, bisnis, dan lain-lain lewat metode-metode yang dibahas dan dikembangkan oleh bidang ilmu komputer. Ada yang berpendapat untuk S3, bidang ini harus “luas” sementara untuk ilmu komputer “sempit”. Namun perkembangan di per-jurnal-an sedikit berbeda dimana istilah “luas” menjadi rancu. Ada yang mengatakan luas di sini berarti “grand design”, framework enterprise dan hal-hal lain yang kesannya menambah beban mahasiswa S3 agar “pusing” dikit dalam mengambil data yang banyak, ijin yang berbelit, dan sejenisnya. Biasanya yang berfikir tersebut adalah pihak kampus. Sementara dari pihak “reviewer”, sebenarnya sistem informasi bermaksud penerapan yang tepat terhadap domain tertentu, seperti misalnya untuk e-learning, maka fokus originality, novelty dan contribution adalah cukup fokus ke domainnya yaitu pendidikan dan psikologi. Terkadang dengan metode yang sudah establish, hanya menggunakan metode yang ada tetapi pembahasan yang tepat terhadap hubungannya dengan peningkatan performa dari domain dapat diterima untuk dipublikasi.

S1, S2, dan S3

Ada yang membedakan fokus S1 ke implementasi metode, S2 membandingkan dan memilih metode, dan S3 menemukan/memperbaiki metode. Dilihat dari sisi peta okupasi dan kompetensi sudah cukup memadai, tetapi dari sisi penelitian ada yang janggal karena seharusnya S1 ilmu komputer tidak hanya menerapkan di domain tertentu karena cenderung menjadi sistem informasi. Hal ini yang menurut saya menyebabkan konflik antara jurusan teknik informatika dan sistem informasi yang terdapat dalam satu universitas/sekolah tinggi. Banyak dijumpai mahasiswa sistem informasi yang pindah ke teknik informatika karean merasa pusingnya sama tetapi gengsinya beda (mereka menganggap teknik informatika lebih bergengsi). Problem berikutnya adalah S2 yang biasanya kelanjutan S1 dan persiapan S3. Dengan waktu hanya 2 tahun (1,5 tahun dipakai course work), sepertinya agak sulit jika dipaksa mencari novelty dari jurusannya. Di mata reviewer, antara S1, S2, dan S3 tidak ada bedanya. Dengan melihat pendahuluan, novelty dan kontribusi akan terlihat apakah penulis ingin fokus ke metode atau ke domain penerapan metode. Jika fokus ke metode tapi tidak ada upaya improvement, hanya pernyataan bahwa metode tersebut dapat meningkatkan kinerja domain sudah pasti reviewer akan me-reject. Sebaliknya jika fokus ke domain penerapan metode tetapi pembahasan membahas akurasi metode juga di-reject, kedua hal tersebut dianggap “salah kamar”.

Penutup

Jika syarat publikasi wajib maka format S1, S2, dan S3 sedikit banyak akan berubah, kecuali jika dipublikasikan ke jurnal tanpa peer review. Kampus, dosen, dan mahasiswa harus mulai menentukan fokus ke arah mana. Dan antara jurusan ilmu komputer dan sistem informasi jangan sampai terlalu tumpang tindih. Memang mencari originality, novelty dan kontribusi metode dalam ilmu komputer sangat sulit tapi harus dicoba, harus ada usaha. Masalah berhasil atau tidak itu urusan belakang, minimal mahasiswa tahu “jeroan” dari metode tersebut. Sebagai contoh misalnya bahasa Python telah menyediakan sebuah library tertentu, misalnya SVM pada Scikit Learning (Sklearn). Mahasiswa ilmu komputer harus tahu isi dari kode SVM agar bisa menambah atau menyetel parameter-parameter di dalamnya, sementara mahasiswa sistem informasi boleh saja hanya menggunakan library SVM tersebut pada domaint tertentu, seperti prediksi sebaran corona dengan SVM khusus regresi (SVR). Bagaimana dengan S3? Silahkan perkuat bahasa Inggris (TOEFL atau IELTS), cari kampus tujuan, cari beasiswa atau dana mandiri, dan coba kuliah dan merasakan atmosfir yang jauh berbeda dari level pendidikan sebelumnya. Sekian, semoga tulisan ini sedikit bermanfaat.

Dipublikasi di Komputer dan Masyarakat, Puisi Kehidupan | 1 Komentar

Mengimpor Kelas Pada Python

Pemrograman berorientasi objek (PBO) saat ini lebih diminati dari pemrograman terstruktur. Hal ini karena PBO ternyata lebih terstruktur dengan pola yang terdiri dari atribut dan metode (operasi). Untuk penggunaan fungsi eksternal pada jenis pemrograman terstruktur sudah dibahas pada post terdahulu. Agar lebih jelas ada baiknya kita menggunakan contoh kasus yang sama, yaitu pembelian barang.

Membuat Kelas

Kelas dapat dibuat dalam satu file yang sama atau terpisah. Di sini kita coba menggunakan file terpisah, misalnya bernama “hitung.py”. File ini berisi tiga buah method dengan fungsi seperti kasus yang lalu: total, diskon dan bayar. Berikut kelas “struk” yang dibuat dengan kata kunci “class”. Perhatikan indent (menjorok) baik setelah “class” maupun “def”.

class struk:
	def total(harga,jumlah):
		"""fungsi untuk menghitung Total bayar"""
		return harga*jumlah

	def diskon(harga):
		""" fungsi menghitung diskon """
		if (harga >= 500000):
			potongan=harga*0.1
		else:
			potongan=harga*0.05
		return potongan

	def bayar(harga,potongan):
		""" fungsi menghitung total bayar """
		return harga-potongan

Memanggil Kelas

Kelas dipanggil dengan kata kunci “import”. Perhatikan pada listing di bawah cara memanggil fungsi/metode yang dimiliki oleh kelas, dalam hal ini kelas “struk”. Formatnya adalah <nama_kelas>.<nama_metode>. Di sini kita coba menggunakan Google Colab. Kita bisa juga menggunakan Jupyter Notebook atau versi terdahulu dengan IDLE.

from hitung import struk
print(" ———Toko Amanah Jaya———")
#input data
harga= int(input("masukan harga barang: "))
jumlah= int(input("masukan jumlah baju yang dibeli: "))
Total=struk.total(harga,jumlah)
potongan=struk.diskon(Total)
tagihan=struk.bayar(Total,potongan)
print("Total Harga = ", "Rp.",Total)
print("Diskon", "Rp.", potongan)
Bayar=int(input("Jumlah Nominal Uang =" ))
Kembalian= (Bayar-tagihan)
print("Uang Kembalian = ", "Rp.",Kembalian)

Berikut hasil “running” ketika transaksi barang dengan harga Rp. 100.000,- sebanyak 4 buah. Karena di bawah Rp. 500.000,- maka diskonnya 5 %. Sekian semoga bermanfaat.

Dipublikasi di Object Oriented Programming, Python | Meninggalkan komentar

Maaf, kita terpaksa belajar secara online

Siang ini udara cukup panas ketika saya keluar sebentar untuk ambil raport SMP anak. Ketika balik lagi ke kampus karena memang jadwal saya piket, ternyata mahasiswa unjuk rasa mengenai perkuliahan. Tuntutannya sederhana, meminta dispensasi pembayaran, kalau tidak salah 50 persen. Alasannya sederhana, karena perkuliahan berjalan secara daring. Untuk menjawab bagaimana kampus bersikap, ada baiknya melihat kondisi sesaat sebelum pandemic COVID-19 terjadi berikut ini.

Disrupsi

Istilah ini bukan hal yang baru dan setiap orang sudah mengerti. Pesatnya penjualan, transportasi, dan bisnis online sudah terasa dampaknya di masyarakat. Konflik dengan konvensional seperti ojek pangkalan, taksi konvensional yang sebelumnya keras mulai melunak dan bahkan kini bisa berjalan saling mengisi. Bagaimana dengan dunia pendidikan? Beberapa pakar sudah memprediksi bahwa bakal banyak kampus yang akan tutup, jangankan negara berkembang, negara maju tempat pusat IPTEKS pun diramalkan akan terjadi (misal di US, lihat link ini).

Secara teori, disrupsi memotong rantai antara produsen dengan konsumen. Jadi jika kita sebagai produsen atau konsumen, tentu saja tetap tidak tergantikan. Masalahnya adalah untuk jasa, seperti pendidikan, siapa kah produsennya? Kampus atau dosen? Sementara konsumen, mahasiswa ataukah industri penyerap tenaga kerja? Repotnya berita Google yg tidak mensyaratkan ijazah ketika merekrut karyawannya membuat posisi produsen (kampus dan dosen) kelimpungan (lihat link ini misalnya).

Menurut buku Renald Kasali tentang disrupsi, nanti peran kampus adalah sebagai even organizer yang menangani servis pendidikan dan pengajaran. Kampus dan dosen seolah lenyap (wah repot juga). Jika perusahaan penyerap memiliki tools yang canggih untuk menguji kemampuan calon tenaga kerja, sudah dipastikan peran ijazah bakal sirna dan digantikan peran lembaga yang mampu meningkatkan skill dan ilmu siswa/mahasiswa/calon tenaga kerja. Kalau diibaratkan tokopedia, bukalapak, shopee yang hingga kini bertarung habis-habisan, kemungkinan lembaga yang memberikan servis pengajaran pun pasti bertarung habis-habisan. Namun kondisi COVID-19 pen-disrupsi pun kewalahan (lihat berita ini).

Business-to-Business (B2B)

Di industri kita kenal perusahaan yang menjual barang bukan ke konsumen, melainkan ke perusahaan lain. Jadi kita tidak bisa sekedar menyamakan kampus dengan gojek atau toko online yang business-to-customer. Ketika ojek dibutuhkan, pasti ada pensuplainya, kendaraan dan driver. Begitu juga pendidikan, ada pihak pensuplai kurikulum/konten dan dosen. Hal ini terjadi karena pengajar bukan sebagai buruh, melainkan mitra. Nah, kondisi pengajaran online pun berbeda dengan ojek yang memang dibutuhkan jumlah yang banyak, untuk pengajaran terkadang dibutuhkan pengajar yang “menarik” konsumen karena kepakaran, skill, atau aspek-aspek penerimaan lainnya yang tentu saja karena online tidak perlu berjumlah banyak. Wah, bagaimana ini?

Tuntutan Spesialisasi

Perkembangan teknologi dan tuntutan kehidupan modern memaksa tidak adanya monopoli oleh seseorang. Sehebat apapun seorang pakar, dia tidak bisa menguasai semua ilmu yang dibutuhkan orang/masyarakat. Peta okupasi (profesi) pun terus bertambah, misalnya untuk dunia IT sudah ratusan. Jadi seharusnya tidak perlu khawatir. Nah, di sinilah sebenarnya akar permasalahan ketika transisi dari tatap muka/offline/blended menjadi murni online. Baik pengajar maupun mahasiswa khawatir tidak memperoleh hasil yang diinginkan. Sebagai contoh, silahkan ikuti webinar-webinar yang saat ini banyak dijumpai, tidak ada skill spesifik yang didapat karena memang bentuknya yang agak monolog dan tidak bisa meng-cover kebutuhan semua peserta.

Influencer

Jika sudah menjadi spesialis dan terus mengasah skill dan kepakaran, maka dampak nyatanya berupa karya kian terlihat. Uniknya di jaman online, sangat mudah terlihat dan viral. Sekali terlihat, permintaan pasti datang dan jika peminatnya banyak, banyak pihak-pihak yang menempel ketat. Jika kampus atau dosen sudah berperan seperti influencer, sepertinya aman-aman saja karena mendapat dukungan dari mahasiswa dan industri. Jika mahasiswa sudah menjadi follower setia, online pun tidak masalah. Peran model dan sosok sebagai sumber inspirasi seorang tutor/dosen/guru tidak bisa tergantikan. Sekian, semoga pembaca sekalian sependapat untuk beberapa poin dalam tulisan ini.

 

Dipublikasi di Puisi Kehidupan | Meninggalkan komentar

Menyisipkan Machine Learning Pada Aplikasi Web

Aplikasi web biasanya merupakan aplikasi bertipe front-end dimana antara user dengan machine saling berinteraksi. Sementara itu machine learning, bagian khusus dari data mining, kebanyakan bekerja sebagai back-end. Nah, agar machine learning terhubung dengan user, dibutuhkan user interface, salah satunya adalah aplikasi berbasis web. Python, sebagai bahasa yang memang dikhususkan untuk back-end menyediakan pula aplikasi front-end dalam bentuk web lewat beberapa framework-nya, salah satunya adalah Flask.

Menyisipkan Machine Learning

Bagaimana cara kerja Flask, silahkan lihat pos saya terdahulu. Beberapa library perlu dipersiapkan dari yang diperuntukan menjalankan machine learning (Pandas, NumPy, Keras, SKlearn, dan lain sebagainya) hingga yang memang khusus untuk Flask. Untuk studi kasus dipilih Support Vector Machine (SVM) untuk mengklasifikasi data penentuan beasiswa. Diperlukan tiga file program dengan satu file data. Tiga file tersebut antara lain satu file utama python dan dua file html untuk interface (main program untuk inputan dan result.html untuk keluaran). Berikut tampilan program utamanya.

Perhatikan letak training SVM setelah proses impor pustaka-pustaka yang dibutuhkan. Dua fungsi (template_test dan predict) dibutuhkan berturut-turut ketika program dieksekusi dan ketika tombol ditekan (via browser).

Testing

Untuk mengujinya, perlu memahami bagaimana konsep environment di python. Cara termudah adalah lewat Anaconda Navigator. Pastikan di environmen terpasang pustaka-pustaka yang dibutuhkan (bisa lewat PIP terminal ataupun lewat Anaconda). Buka environment yang tepat dengan menekan mouse di nama environmen tersebut dilanjutkan dengan mengklik kanan dan pilih “terminal” untuk membuka terminal yang mengarah ke environment tersebut. Environment ditunjukan dengan dalam kurung di terminal, misalnya kasus saya nama environmennya “tensorflow” (hanya nama saja).

Setelah masuk terminal arahkan folder ke lokasi program utama python-nya (berekstensi *.py). Untuk jelaskan silahkan buka video berikut ini. Sekian, semoga bermanfaat.

Untuk rekan-rekan mahasiswa yang sudah setia mengikuti perkuliahan (Univ. Islam 45, Univ. Nusa Putra, dan Univ. Bhayangkara Jakarta Raya) walaupun secara online di masa pandemic COVID-19, kami mengucapkan terima kasih sebesar-besarnya karena secara tidak langsung turut membantu terciptanya buku revisi “Data Mining” yang kini disertai bahasa Python yang Insya Allah sudah melewati revisi terakhir dan siap cetak.

Dipublikasi di Decision Support System, Python | Meninggalkan komentar

Memulai Meeting Online dengan Google Meet

Dulu Google Meet bernama hangout, namun perkembangan kuliah daring di masa pandemi membuat aplikasi-aplikasi meeting berbenah. Salah satunya adalah google meet. Google merupakan perusahaan besar yang kerap melakukan riset dari hal-hal sederhana pekerjaan kantor sehari-hari hingga skala besar.

Bisa dengan Akun Gmail Biasa

Buke email anda dan perhatikan simbol di atas bagian atas kanan (1). Tekan dan di sana ada banyak pilihan, salah satunya adalah “meet” yang berarti Google Meet (2). Silahkan tekan.

Setelah itu kita tinggal membuat satu meet baru dengan menekan “Start a meeting”. Perhatikan kalimat di atasnya: “premium meeting is free for everyone”, yang artinya dulu hanya bisa gmail versi tertentu ac.id atau yang berbayar, sekarang oleh siapapun bisa, asal gmail.

Kolom enter meeting code jika kita ingin bergabung, bukan sebagai admin. Tekan “Join Now” untuk membuat satu “meeting” baru.

Begitu saja, sangat sederhana untuk memulainya. Kita tinggal meng-copas link dan men-share ke rekan lain yang ingin ikut bergabung. Tentu saja yang ingin bergabung harus punya gmail.

Ketika seseorang memiliki link yang di-copy-kan tersebut, maka dia bisa langsung “join”. Keluar masuk cukup mudah hanya dengan menekan simbol “telepon” di bagian tengah.

Lama Durasi Meeting Google Meet

Sebagai informasi tambahan yang penting, Google Meet gratis seharusnya maksimal satu jam, tetapi sampai 30 September 2020 bisa sampai 24 jam, silahkan kalau kuat.

Terbukti saya gunakan mengajar dari jam 08.00 WIB sampai Jam 17.00 WIB tidak ada masalah, juga untuk acara lain seperti seminar yang beranggotakan puluhan hingga ratusan. Kabarnya bisa sampai 250 peserta, silahkan coba. Sekian semoga berfaedah.

 

Dipublikasi di Komputer dan Masyarakat, Komputer II | Meninggalkan komentar

Flask dan Jinja2 Untuk Aplikasi Machine Learning Berbasis Web

Mungkin ada pembaca yang sudah mahir metode-metode yang digunakan untuk machine learning, tapi kesulitan ketika membuat aplikasi yang digunakan oleh pengguna. Banyak pilihan yang mungkin, apakah berbasis desktop ataukah web. Pilihan berupa mejalankan lewat konsol tentu saja menyulitkan pengguna yang biasanya eksekutif pengambil keputusan. Untuk yang berbasis desktop (lihat pos yang lalu tentang tkinter) menyulitkan jika ingin digunakan bersama. Nah, penggunaan aplikasi berbasis web untuk machine learning menjadi satu-satunya pilihan yang baik. Dengan aplikasi web, aplikasi dapat digunakan oleh divisi lain. Pos ini merupakan penjelasan lebih lanjut dari post yang lalu dengan penambahan pada operasi aritmatika sederhana (penjumlahan).

Bahasa Pemrograman Front-End dan Back-End

Dua pilihan framework web berbasis python yang terkenal adalah “django” dan “flask”. Jika django diperuntukan untuk aplikasi besar (enterprise), flask cocok jika digunakan internal di perusahaan karena karakteristiknya yang microframework. Toh biasanya memang aplikasi machine learning tidak “diumbar” ke luar, melainkan hanya kepentingan internal saja. Biasanya memang machine learning bekerja secara back-end, sementara bahasa pemrograman lain seperti java, php, dan bahasa front-end lainnya diperbantukan. Tetapi ternyata dengan framework-framework web, python secara mengejutkan dapat digunakan sebagai front-end juga.

Mempersiapkan Pustaka (Library) Flask

Langkah penting pertama adalah menyiapkan pustaka untuk menjalankan Flask. Kita dapat menggunakan dua metode yaitu lewat konsole (dengan PIP) dan lewat Anaconda Navigator. Silahkan atur environment yang tepat agar tidak salah menggunakan environment.

Di sini saya menginstal Flask di environment “tensorflow” (hanya nama saja). Untuk yang konsol, gunakan “path” yang sesuai, atau bisa menggunakan aplikasi “virtualenv”. Atau untuk pemula seperti saya, gunakan saja Anaconda yang terintegrasi.

Format Folder Flask

Flask membutuhkan satu file python untuk menghidupkan server dan beberapa templet HTML untuk input dan outputnya. Misalnya untuk contoh kita menggunakan satu file python “web.py” untuk menghidupkan server dan mengatur komunikasi templet lainnya: “mainpage.html” dan “result.html”.

Gunakan beragam text editor untuk mengetik dan membaca program-program tersebut, misalnya notepad, sublimetext, IDLE, dan text editor lainnya. Pastikan letak file mengikuti standar di atas dimana HTML terletak dalam satu folder “templates”. Berikut contoh kode untuk menghidupkan server Flask.

Memang perlu usaha keras untuk rekan-rekan yang kurang memahami format HTML dan CSS. Silahkan pelajari sumber-sumber belajar HTML dan CSS tersebut. Atau bisa gunakan Bootstrap yang tersedia dengan cuma-cuma di internet.

Menghidupkan Server

Dengan environment yang sesuai, masuk ke mode konsol dan ketik: python <namafile.py> di folder yang tepat. Pastikan server hidup dengan indikasi adanya instruksi untuk mengakses http://127.0.0.1:<port>.

Untuk keluar bisa menggunakan “Ctrl+C”. Ada kejadian unik ketika saya mengutak-atik kode tetapi tidak bisa dijalankan karena server masih menyimpan yang lama (cache). Setelah mengganti port baru bisa.

Testing

Buka browser dan jalankan aplikasi. Pastikan dapat berjalan dengan sempurna. Silahkan untuk jelasnya buka video tutorial saya di Youtube berikut ini.

Dipublikasi di Decision Support System, Python | 1 Komentar

Adaptive Neuro-Fuzzy Inference System (ANFIS) dengan Python

Adaptive Neuro-Fuzzy Inference System (ANFIS) merupakan metode yang menggabungkan Jaringan Syaraf Tiruan (JST) dengan Fuzzy. Konsepnya adalah menjadikan “rule” sebagai “neuron”. Jumlah layer tersembunyi (hidden) hanya satu layer. Salah satu situs yang OK untuk mempraktikan ANFIS dengan bahasa pemrograman Python adalah salah satu TIM dari MIT di link berikut ini. Source code bisa diunduh dan penjelasannya lewat situs Github.

Instal Library ANFIS

Anaconda tidak memiliki pustaka ANFIS, oleh karena itu perlu mengunduh menggunakan PIP. Selain itu pustaka yang dibuat sendiri juga disertakan, misalnya anfis.py dan folder membership yang berisi dua file penting lainnya. Untuk mengetahui bagaimana fungsi eksternal bekerja silahkan lihat postingan saya yang lalu.

Menggunakan Google Colab

Memang lebih mudah menggunakan Google Colab karena sebagian besar pustaka sudah tersedia. Hanya saja untuk ANFIS terpaksa harus menginstal terlebih dahulu. Caranya adalah seperti instalasi PIP lewat terminal, hanya saja disini menggunakan tanda seru di awalnya.

Ketik !pip install anfis. Tunggu beberapa saat hingga Google Colab berhasil mengunduh dan menginstal pustaka ANFIS tersebut. Jangan lupa, file-file pendukung unggah di bagian File di sisi kiri Google Colab. Pastikan ketika impor pustaka di sel berikutnya berhasil. Buat folder baru dengan nama membership lalu isi dengan file pendukungnya. Jangan diletakan di luar semua.

Berikutnya adalah mengambil data latih dari file “beasiswa.txt”. Pastikan X dan Y sesuai dengan yang diinginkan sebagai data latih dan targetnya. Silahkan cari sumber referensi mengenai membership function. Di sini mf berfungsi mem-fuzzy-kan inputan. Jalankan dan pastikan grafik performa pelatihan muncul.

Perhatikan hasil latih yang berwarna merah sudah mendekati target yang berwarna biru. Satu untuk memperoleh beasiswa dan nol untuk yang tidak memperoleh beasiswa. Gunakan satu data sampel untuk menguji apakah menerima beasiswa atau tidak.

Perhatikan untuk input1 3.2 dan input2 3.4 hasilnya adalah 1. Silahkan menggunakan fungsi “round” untuk membulatkan apakah nol atau satu. Untuk jelasnya lihat video berikut ini. Sekian semoga bermanfaat.

Dipublikasi di Artificial Neural Network, Decision Support System, Python | 4 Komentar

Coba Bikin Buku Lagi .. “Data Mining dengan Matlab & Python”

Buku berbeda dengan artikel jurnal dari sisi konten. Jika jurnal merupakan hasil penelitian terkini, buku sedikit tertinggal beberapa tahun. Namun biasanya buku lebih stabil keilmuwannya, alias sudah “established”. Biasanya buku digunakan sebagai sumber referensi untuk kasus tertentu karena formatnya yang rapi, tidak terlepas ke sana-sini seperti artikel ilmiah. Toh, jurnal pun sesungguhnya terbit setelah penelitian yang dilakukan beberapa tahun belakangan, jadi tidak baru-baru amat. Postingan ini sedikit memberi gambaran bagaimana membuat buku dengan mudah dan cepat.

Materi Kuliah

Waktu itu diminta ngajar mata kuliah “Data Mining” di kampus besar yang terletak di Pondok Kopi. Total ada 14 pertemuan. Kebetulan perkuliahan disertai dengan praktek di laboratorium. Dalam satu kali pertemuan saya buat satu bab, jadi total setelah perkuliahan selesai, jadilah buku sekitar 14 bab. Jadi ketika mengajari, langsung saja “capture” langkah-langkahnya. Tidak perlu ditulis dulu karena menulis membutuhkan waktu. Toh, dari hasil capture kita tahu apa yang harus ditulis nanti. Lihat postingan saya 7 tahun yang lalu tentang teknik ini.

Di akhir semester ada waktu kira-kira sebulan untuk membuat kata-kata yang mengalir. Ada sisi positifnya jika kita menulis materi kuliah. Ketika mempraktekan terkadang dapat diketahui apakah modul berjalan dengan baik. Terkadang ada saja hal-hal yang dijumpai siswa yang membuat praktik tidak berjalan. Hal ini penting untuk ditulis karena pembaca buku adalah pembelajar mandiri yang harus jelas dari “a” sampai “z” tanpa ada guru/tutor. Jika tidak berjalan, tentu saja mengecewakan pembaca. Namun toh, biasanya ada saja masalah dijumpai dan pembaca mengirim pertanyaan lewat email, terutama masalah kompatibilitas dengan laptopnya. Tapi biasanya berjalan dengan baik oleh pembaca. Kalaupun hanya memanfaatkan dari “help” tetap harus dicoba oleh penulis apakah bisa berjalan dengan baik atau perlu alat bantu lain. Beberapa penulis buku tidak menganjurkan memanfaatkan “help” karena untuk apa buat buku kalau di “help”-nya sudah ada.

Hasil Penelitian

Nah, yang ini agak sulit. Beberapa penerbit menolak membukukan hasil penelitian (skripsi, tesis, atau disertasi). Hal ini saya dengar langsung oleh perwakilan penerbit (waktu itu dari Andi offset) yang diundang oleh pihak kampus saya waktu itu (STMIK Nusa Mandiri). Saya lupa tahunnya, yang jelas waktu itu masih “ST”. Oiya, mungkin dosen-dosen muda sekarang heran melihat S1 yang menjadi dosen. Pasti lebih heran lagi kalau tahu jabatan fungsional Lektor saya diperoleh waktu masih bergelar S1 (lektor 200). Waktu itu memang jamannya orang enggan jadi dosen, sehingga kebutuhan dosen masih tinggi. Nah, si penerbit bersedia membukukan hasil penelitian jika mampu mengemas laporan penelitiannya dalam bentuk sudut pandang “orang awam”. Maksudnya pembaca harus dijejali hal-hal yang perlu agar mereka bisa mengikuti. Ini yang membuat penulis harus kerja ekstra mengetik ulang hasil penelitiannya. Nah nanti di akreditasi terbaru dengan format 9 standar, tiap dosen harus memasukan hasil penelitiannya ke materi ajar. Jadi buku yang dibuat kombinasi dari materi kuliah dengan hasil penelitian. Agak repot juga ketika mengajar mata kuliah yang berbeda dengan roadmap penelitiannya, jadi tidak bisa disisipi hasil penelitian. Jadi intinya, penerbit ingin pembaca tidak membutuhkan sumber-sumber lain untuk memahami, artinya dengan satu buku itu sudah paham. Kalau memerlukan buku lainnya, biasanya pembaca kerepotan karena harus merogoh kocek lagi untuk beli buku lainnya.

Menolong Orang Lain

Siapa yang ditolong? Banyak, misalnya kampus (lewat poin akreditasi karena ada buku), dosen (karena ada materi kuliah), industri/developer (untuk membuat software/aplikasi), dan mahasiswa (untuk kuliah dan tugas akhir/skripsi). Hal ini terjadi karena buku berbeda dengan artikel ilmiah yang terkadang merahasiakan kode sumber, sementara buku selain menyertakan kode sumber, terkadang diberikan CD/DVD atau file yang dishare di internet (dari website, Github, dan lain-lain). Kebanyakan mereka seumur hidup hanya sekali merasakan skripsi/tugas akhir, jadi tidak mungkin melupakan buku yang ia baca ketika berpusing-pusing ria dalam merampungkan kuliahnya. Saya pun sampai sekarang masih ingat buku-buku yang membantu saya lulus kuliah. Terakhir, tentu saja membantu penerbit. Mereka secara jujur kesulitan mencari penulis buku, padahal jumlah penulis potensial di tanah air harusnya di atas negara lain.

Revisi Atau Baru?

Sebenarnya saya ingin merevisi buku yang dulu, tetap mengingat isi yang jauh berbeda, terpaksa membuat versi yang benar-benar baru. Salah satu hal yang membedakan adalah “web-based machine learning“. Silahkan cari di internet buku tentang machine learning atau data mining berbasis web, masih jarang. Hal ini terjadi karena antara front-end (web developer) dengan back-end (data scientis) berasal dari orang dengan fokus yang berbeda. Perlu ada jembatan yang menghubungkan keduanya. Pengguna pun lebih nyaman menggunakan apikasi data mining dengan GUI berbasis web yang mudah diakses dari manapun. Jadi dengan tambahan web-based machine learning mudah-mudahan dapat menjembatani front-end dan back-end. Penggunaan bahasa Python pun karena trend bahasa pemrograman ini yang terus naik (lihat pos yang lalu) sampai-sampai Google mengadopsi bahasa ini dalam pemrograman onlinenya (lihat pos yg lalu tentang Google Colab).

Sebagai bonus, penulis terkadang harus cuek, apalagi menulis buku. Jika novel atau cerpen, kita bisa menggunakan nama samaran jika kita tidak ingin repot dengan para kritikus. Beberapa pakar di tanah air terkadang merendahkan tulisan dari penulis-penulis lokal dan cenderung menganjurkan buku-buku internasional yang “wah”. Tidak apa-apa kalau punya pandangan seperti itu, toh niat kami membantu anak-anak yang mungkin kurang skill bahasa Inggrisnya dengan bahasa yang mudah mereka mengerti. Jika dikatakan tulisan “instan” ya tidak apa-apa, kan repot juga mahasiswa dipaksa belajar bahasa Inggris dulu baru bisa lulus. Prinsip saya dan penulis-penulis lokal lainnya sebenarnya sederhana, membantu memberikan pemahaman kepada masyarakat umum, tidak merahasiakan ilmu atau menyarankan mereka mengikuti kursus yang harganya terkadang tidak terjangkau oleh mahasiswa-mahasiswa rata-rata di tanah air yang untuk bayar kuliah saja sulit. Tentu saja kalau mampu silahkan buat buku bertaraf internasional yang “wah” dan itu bagus banget menurut saya. Semoga berminat menulis buku.

 

Dipublikasi di Matlab, Puisi Kehidupan, Python | Meninggalkan komentar

Simulated Annealing in Jupyter Notebook

Similar with particle swarm optimization, simulated annealing (SA) is a fast optimization method. It mimics the process of the cooling system in die casting. The cooling system in die casting should be slow to avoid the internal energy trapped in the cast that reduce the quality. The SA code can be found in the internet, e.g. the panda site.

SA use some exponential calculation, so we need to import “math” library in the beginning. Open your Jupyter Notebook with the proper environment. Use Anaconda Navigator to get the environment and open the terminal. After finding your working direktory, type “Jupyter Notebook” to open the IDE in your browser automatically. Copy and paste the SA code at the end of this post to show how the SA work. You can change the objective function according your case study.

Matplotlib library was used to create the performance chart. Best performance was at 8.1 after 258 iteration. Try the code below in your Jupyter Notebook or previous method, e.g. by console, IDLE, etc.

import time
import random
import math
import numpy as np
import matplotlib.pyplot as plt
#------------------------------------------------------------------------------
# Customization section:
initial_temperature = 100
cooling = 0.8  # cooling coefficient
number_variables = 2 
upper_bounds = [3, 3]   
lower_bounds = [-3, -3]  
computing_time = 1 # second(s)

def objective_function(X):
    x=X[0]
    y=X[1]
    value = 3*(1-x)**2*math.exp(-x**2 - (y+1)**2) - 10*(x/5 - x**3 - y**5)*math.exp(-x**2 - y**2) -1/3*math.exp(-(x+1)**2 - y**2)
    return value

#------------------------------------------------------------------------------
# Simulated Annealing Algorithm:
initial_solution=np.zeros((number_variables))
for v in range(number_variables):
    initial_solution[v] = random.uniform(lower_bounds[v],upper_bounds[v])

current_solution = initial_solution
best_solution = initial_solution
n = 1  # no of solutions accepted
best_fitness = objective_function(best_solution)
current_temperature = initial_temperature # current temperature
start = time.time()
no_attempts = 100 # number of attempts in each level of temperature
record_best_fitness =[]

for i in range(9999999):
    for j in range(no_attempts):

        for k in range(number_variables):
            current_solution[k] = best_solution[k] + 0.1*(random.uniform(lower_bounds[k],upper_bounds[k]))
            current_solution[k] = max(min(current_solution[k],upper_bounds[k]),lower_bounds[k])  # repair the solution respecting the bounds

        current_fitness = objective_function(current_solution)
        E = abs(current_fitness - best_fitness)
        if i == 0 and j == 0:
            EA = E

        if current_fitness < best_fitness:
            p = math.exp(-E/(EA*current_temperature))
            # make a decision to accept the worse solution or not
            if random.random()<p:
                accept = True # this worse solution is accepted
            else:
                accept = False # this worse solution is not accepted
        else:
            accept = True # accept better solution
        if accept==True:
            best_solution = current_solution # update the best solution
            best_fitness = objective_function(best_solution)
            n = n + 1 # count the solutions accepted
            EA = (EA *(n-1) + E)/n # update EA

    print('interation: {}, best_solution: {}, best_fitness: {}'.format(i, best_solution, best_fitness))
    record_best_fitness.append(best_fitness)
    # Cooling the temperature
    current_temperature = current_temperature*cooling
    # Stop by computing time
    end = time.time()
    if end-start >= computing_time:
        break
plt.plot(record_best_fitness)
Dipublikasi di Decision Support System, Python | Meninggalkan komentar

Particle Swarm Optimization in Jupyter Notebook

Particle Swarm Optimization (PSO) has been widely used for solving optimization problems. This method has many advantages, in particular for the computational complexity. PSO mimics the flock of bird or the school of fish when searching for foods. It faster than genetic algorithms (GAs), so become the first choice when optimizing the complex problems, such as multi-objective optimization, optimization with many constraints, etc. Following is the particle velocity calculation and its new location.

pso

Many source codes can be found in the internet, for example this panda site. This beautiful code use object-oriented style with some classes. Some functions inside a class are easy to understand. This code can be copied and pasted in your jupyter notebook. As usual, use the Anaconda Navigator to choose the right environment. This code only uses a simple library: math, and matplotlib.

Choose your working directory to open the Jupyter Notebook by typing “juypyter notebook”. The Jupyter notebook then suddenly appear in your browser. Copy and paste the code to run the sample of PSO. This sample use two variables (X0 and X1). Use mm=-1 for minimizing problem and mm=1 for maximizing problem. A main class run two previous classes (Particle and PSO) to show the optimum result with a performance chart.

Here is the code:

import random
import math
import matplotlib.pyplot as plt
#------------------------------------------------------------------------------
# TO CUSTOMIZE THIS PSO CODE TO SOLVE UNCONSTRAINED OPTIMIZATION PROBLEMS, CHANGE THE PARAMETERS IN THIS SECTION ONLY:
# THE FOLLOWING PARAMETERS MUST BE CHANGED.
def objective_function(x):
    y = 3*(1-x[0])**2*math.exp(-x[0]**2 - (x[1]+1)**2) - 10*(x[0]/5 - x[0]**3 - x[1]**5)*math.exp(-x[0]**2 - x[1]**2) -1/3*math.exp(-(x[0]+1)**2 - x[1]**2);
    return y

bounds=[(-3,3),(-3,3)]   # upper and lower bounds of variables
nv = 2                   # number of variables
mm = -1                   # if minimization problem, mm = -1; if maximization problem, mm = 1

# THE FOLLOWING PARAMETERS ARE OPTIMAL.
particle_size=100         # number of particles
iterations=200           # max number of iterations
w=0.85                    # inertia constant
c1=1                    # cognative constant
c2=2                     # social constant
# END OF THE CUSTOMIZATION SECTION
#------------------------------------------------------------------------------    
class Particle:
    def __init__(self,bounds):
        self.particle_position=[]                     # particle position
        self.particle_velocity=[]                     # particle velocity
        self.local_best_particle_position=[]          # best position of the particle
        self.fitness_local_best_particle_position= initial_fitness  # initial objective function value of the best particle position
        self.fitness_particle_position=initial_fitness             # objective function value of the particle position

        for i in range(nv):
            self.particle_position.append(random.uniform(bounds[i][0],bounds[i][1])) # generate random initial position
            self.particle_velocity.append(random.uniform(-1,1)) # generate random initial velocity

    def evaluate(self,objective_function):
        self.fitness_particle_position=objective_function(self.particle_position)
        if mm == -1:
            if self.fitness_particle_position < self.fitness_local_best_particle_position:
                self.local_best_particle_position=self.particle_position                  # update the local best
                self.fitness_local_best_particle_position=self.fitness_particle_position  # update the fitness of the local best
        if mm == 1:
            if self.fitness_particle_position > self.fitness_local_best_particle_position:
                self.local_best_particle_position=self.particle_position                  # update the local best
                self.fitness_local_best_particle_position=self.fitness_particle_position  # update the fitness of the local best

    def update_velocity(self,global_best_particle_position):
        for i in range(nv):
            r1=random.random()
            r2=random.random()

            cognitive_velocity = c1*r1*(self.local_best_particle_position[i] - self.particle_position[i])
            social_velocity = c2*r2*(global_best_particle_position[i] - self.particle_position[i])
            self.particle_velocity[i] = w*self.particle_velocity[i]+ cognitive_velocity + social_velocity

    def update_position(self,bounds):
        for i in range(nv):
            self.particle_position[i]=self.particle_position[i]+self.particle_velocity[i]

            # check and repair to satisfy the upper bounds
            if self.particle_position[i]>bounds[i][1]:
                self.particle_position[i]=bounds[i][1]
            # check and repair to satisfy the lower bounds
            if self.particle_position[i] < bounds[i][0]:
                self.particle_position[i]=bounds[i][0]

class PSO():
    def __init__(self,objective_function,bounds,particle_size,iterations):

        fitness_global_best_particle_position=initial_fitness
        global_best_particle_position=[]

        swarm_particle=[]
        for i in range(particle_size):
            swarm_particle.append(Particle(bounds))
        A=[]

        for i in range(iterations):
            for j in range(particle_size):
                swarm_particle[j].evaluate(objective_function)

                if mm ==-1:
                    if swarm_particle[j].fitness_particle_position < fitness_global_best_particle_position:
                        global_best_particle_position = list(swarm_particle[j].particle_position)
                        fitness_global_best_particle_position = float(swarm_particle[j].fitness_particle_position)
                if mm ==1:
                    if swarm_particle[j].fitness_particle_position > fitness_global_best_particle_position:
                        global_best_particle_position = list(swarm_particle[j].particle_position)
                        fitness_global_best_particle_position = float(swarm_particle[j].fitness_particle_position)
            for j in range(particle_size):
                swarm_particle[j].update_velocity(global_best_particle_position)
                swarm_particle[j].update_position(bounds)

            A.append(fitness_global_best_particle_position) # record the best fitness

        print('Optimal solution:', global_best_particle_position)
        print('Objective function value:', fitness_global_best_particle_position)
        print('Evolutionary process of the objective function value:')
        plt.plot(A)
#------------------------------------------------------------------------------
if mm == -1:
    initial_fitness = float("inf") # for minimization problem
if mm == 1:
    initial_fitness = -float("inf") # for maximization problem
#------------------------------------------------------------------------------   
# Main PSO         
PSO(objective_function,bounds,particle_size,iterations)
Dipublikasi di Decision Support System, Object Oriented Programming, Python | 1 Komentar

Studi Lanjut di Era New Normal

Untuk rekan-rekan yang saat ini masih kuliah (S1, S2, atau S3), pasti terpengaruh dengan wabah COVID-19. Yang biasanya bertatap muka, saat ini berganti melalui multimedia, baik tulisan, suara, maupun video. Tentu saja kesulitan pasti muncul. Repotnya kesulitan tersebut baru kali ini terjadi. Saya sendiri sulit membayangkan seandainya saya belum lulus. Sebagai informasi banyak rekan-rekan saya yang belum juga lulus. Mungkin postingan ini sedikit bisa memberi gambaran untuk rekan-rekan yang akan memulai studi. Untuk yang sedang berjalan, mungkin bisa sharing jika ada pengalaman yang bermanfaat untuk dibagikan.

Kondisi Universitas Saat Ini

Tanpa adanya COVID-19, beberapa pakar mulai mempertanyakan apakah universitas juga mengalami disrupsi, seperti perusahaan-perusahaan lainnya dimana terjadi pergeseran dari proses bisnis konvensional menjadi online. Dengan adanya wabah, apalagi jika antivirus belum juga ditemukan, proses disrupsi jauh lebih cepat lagi sepertinya. Ada perubahan dalam perhitungan dimana kondisi saat ini mengharuskan tiap universitas harus efisien dalam menggunakan sarana dan prasarana yang ada. Memang, serangan COVID-19 mirip serangan mendadak yang membuat pontang-panting dunia pendidikan yang baru saja siap-siap online. Beban berat ada di tangan divisi yang bertugas mengontrol jalannya perkuliahan online dan memastikan kualitas proses belajar tetap seperti kondisi sebelumnya. Persaingan yang ketat membuat kampus tidak boleh main-main dengan biaya karena calon siswa dengan mudah beralih ke kampus lain, apalagi kondisi saat ini informasi sangat mudah di dapat, termasuk informasi mengenai kinerja kampus tujuan.

Safe Mode

Ibarat sistem operasi yang bermasalah, terkadang perlu menjalankan mode “safe mode” dimana beberapa driver saja yang diaktifkan guna menghindari “crash”, begitu juga sebaiknya calon siswa bersikap. Pikirkan kembali apakah mengambil kuliah di dalam atau di luar negeri. Biaya sendiri atau menunggu beasiswa. Sempat juga saya ngobrol dengan pengelola S3 sistem informasi yang baru saja dibentuk. Saat ini skema yang ada hanyalah LPDP yang mungkin hanya beberapa yang dapat per angkatan (dua atau tiga). Jika biaya bisa dicover dari gaji atau tunjangan serdos, tidak ada salahnya menggunakan biaya sendiri. Atau jika masih ragu, tunda saja beberapa saat hingga kondisi wabah mereda. Untuk yg tinggal syarat wajib publikasi, jika diperbolehkan open akses yang berbayar tidak ada salahnya memilih opsi itu daripada gaya-gayaan milih murni Q1 atau Q2 dengan impak yang tinggi tapi ga tembus-tembus.

Metode Belajar

Saat ini calon mahasiswa dituntut kualitasnya mirip calon pegawai. Silahkan searching di internet, tuntutan apa saja yang diminta oleh perusahaan, terutama secara psikologis seperti kemampuan untuk berkembang, beradaptasi, berkolaborasi, berkomunikasi, dan sejenisnya. Jika dulu kita bisa seharian berfikir menyelesaikan masalah/problem, saat ini jika dengan kolaborasi lebih cepat, tidak ada salahnya gabung di grup-grup keilmuwan. Saat ini banyak grup-grup medsos yang membicarakan hal itu, tentu saja harus memiliki “sense” agar tidak hanyut ke hal-hal remeh temeh yang tidak perlu seperti politik, gosip, dan sejenisnya.

Result-based dengan memperhatikan konsep pareto (20:80) perlu juga dipelajari. Silahkan searching konsep menarik ini. Kita harus memiliki kemampuan mendeteksi 20 persen titik kritis yang mempengaruhi 80% hasil. Jangan sampai menghabiskan 80% yang tidak penting dan melupakan 20% yang vital. Mengapa hal ini penting? Salah satu alasannya adalah dunia online yang memiliki aplikasi-aplikasi yang memicu endorphin, seperti game, medsos, dan sejenisnya. Gunakan metode detoks dengan cara mengerjakan hal-hal wajib yang membosankan tapi penting, jadikan pemicu endorphin tersebut sebagai “hadiah” saja.

Di era “big data” ini, informasi sangat mudah dijumpai. Ada manfaat, tetapi tentu saja banyak informasi sampah yang tidak harus kita telan juga. Otak kita tidak seperti machine learning yang mampu mengelola data yang besar 24 jam. Oleh karena itu kemampuan mendeteksi informasi-informasi berharga harus dimiliki. Terkadang informasi tersebut tidak bisa diperoleh hanya dengan mengetik kata kunci di Google. Bisa saja lewat bacaan baik buku maupun jurnal. Khusus mahasiswa doktoral wajib menguasai hal ini mengingat syarat lulus yang harus menemukan hal unik yang baru (novelty).

Low Profile

Sungguh konyol kalau kita masih berani sombong dalam kondisi seperti ini. Negara2 adidaya saja kewalahan menghadapi kondisi saat ini. Kabarnya beberapa kampus di barat mengalami kekhawatiran akan tutup. Apalagi kita yang calon siswa, tentu saja kerendahan hati, sifat alami bangsa Indonesia, tetap dijaga. Tidak ada salahnya mengakui kalau kita tidak bisa dari pada tugas tidak selesai. Tidak ada salahnya juga membantu rekan-rekan tanpa imbalan.

Tetap Hidup

Nah ini yang penting. Ketika saya kuliah, terkadang otak bekerja keras siang malam. Makan dan tidur kurang, serta jarang berolah raga. Untuk kondisi new normal yang akan kita hadapi sebaiknya jangan dilakukan. Tidur yang cukup, berolah raga, dan makan makanan bergizi (tidak perlu mahal) harus dilakukan. Saya teringat ketika pembekalan sebelum berangkat kuliah ke luar, pembicara mengatakan agar jangan terlalu “perfect”. Kerjakan secepatnya, tidak perlu menghasilkan hal-hal yang “wah”, apalagi sampai ingin dapat hadiah nobel. Makin kita lama kuliah, makin banyak yang dikorbankan, terutama waktu yang tidak bisa dibeli. Semoga pembaca sehat selalu … Amiin.

Dipublikasi di Puisi Kehidupan | Meninggalkan komentar

Menulis Pseudocode

[mk|pert|jur:logika-alg|X|akuntansi]

Banyak kita jumpai bahasa pemrograman dengan aturan tata-tulis (sintaks) yang beragam. Terkadang pengguna bahasa pemrograman tertentu kesulitan membaca kode yang dibuat oleh bahasa pemrograman lain, walaupun terkadang tidak terlalu berbeda jauh. Oleh karena itu dibutuhkan suatu aturan agar sebuah kode program dapat dimengerti oleh programer bahasa pemrograman lain. Walaupun disainer memiliki alat bantu berupa diagram, misalnya flowchart, activity diagram, dan model-model lainnya baik yang bersifat berorientasi objek maupun terstruktur, tetap bagi programer agak sulit, khususnya ketika berinteraksi lewat milis-milis, misalnya stackoverflow, github, dan grup-grup lainnya. Oleh karena itu beberapa peneliti menggunakan pseudocode untuk bertukar informasi sebuah kode program. Tentu saja bukan kode program seluruhnya, hanya beberapa bagian, biasanya sebuah fungsi atau kelas yang penting untuk dikomunikasikan, baik dalam artike ilmiah, maupun diskusi-diskusi di internet. Postingan kali ini mencoba memberikan gambaran bagaimana cara pembuatan pseudocode yang lazim digunakan.

1. Tipe input, output, proses

Tipe pertama merupakan pseudocode dengan fokus utama proses yang dilakukan terhadap sebuah masukan untuk menghasilkan keluaran tertentu. Di sini tidak dirinci apa format kode tersebut, apakah sebuah fungsi ataukah komputasi numerik tertentu yang merupakan bagian dari fungsi yang lebih besar. Gambarannya kira-kira seperti ini, misalnya diminta menghitung jarak antara satu data dengan data lainnya dengan Euclidean distance.

  • ——————————————————-
  • Algoritma 1: Menghitung Jarak Euclidean
  • ——————————————————-
  • input: x1,y1,x2,y2
  • output: d
  • d = sqrt((x1-x2)^2+(y1-y2)^2)
  • ——————————————————–

Jenis ini terkadang tidak tidak menyertakan output di atas, tetapi meletakan Return di bagian bawah yang menggambarkan jarak.

  • ——————————————————-
  • Algoritma 1: Menghitung Jarak Euclidean
  • ——————————————————-
  • input: x1,y1,x2,y2
  • d = sqrt((x1-x2)^2+(y1-y2)^2)
  • return d
  • ——————————————————–

Kebetulan di sini merupakan fungsi sederhana yang tidak melibatkan kalang (loop). Ada dua jenis kalang yang biasa digunakan dalam pseudocode yaitu for – next dan repeat – until. Selain itu ada juga while – end yang masuk kategori repeat-until. Diletakan di antara input dan output. Terkadang di sisi proses tidak dijelaskan secara detil, hanya garis besar saja jika dirasa pembaca sudah mengetahui alur komputasi atau fungsi yang biasa digunakan secara umum.

2. Tipe Fungsi

Fungsi merupakan komponen kecil dari total kode program, baik yang berada dalam satu file dengan fungsi induk maupun yang terpisah. Pseudocode tipe ini biasa digunakan oleh pengguna Matlab dan Python. Jika Matlab menggunakan kata kunci “Function”, Python dengan “def” (lihat pos yang lalu tentang fungsi eksternal). Fungsi melibatkan nama fungsi serta variabel masukan. Misal untuk contoh kasus perhitungan jarak Euclidean seperti kasus sebelumnya.

  • ——————————————————-
  • Function jarak(x1,x2,y1,y2)
  • ——————————————————-
  • input: x1,y1,x2,y2
  • d ← sqrt((x1-x2)^2+(y1-y2)^2)
  • return d
  • ——————————————————–

Biasanya notasi pseudocode tidak menggunakan sama dengan “=” melainkan panah kiri “← “. Mengenai apakah pseudocode itu jenis tulisan atau gambar, ada beragam versi. Ada yang membuat kotak pada pseudocode dan menjelaskannya sebagai gambar, ada juga yang menganggap sebagai tulisan biasa bagian dari artikel. Mungkin pembaca menemukan bentuk lainnya.

 

Dipublikasi di Unisma | Meninggalkan komentar

Memanggil Fungsi Eksternal Pada Python

[Hari|Matkul|Jur|Dosen: Rabu.13.05.2020|Logika-prt.9|AK|Rahmadya,PhD]

Sebelumnya telah dibahas bagaimana menggunakan fungsi pada bahasa pemrograman Python (lihat pos yang lalu). Terkadang fungsi-fungsi tertentu digunakan oleh program-program Python lain sehingga perlu dibuat satu file terpisah agar tidak perlu menulis kode fungsi di tiap-tiap program. Misalnya kode pembelian barang berikut berisi kode yang ada di dalamnya fungsi yang dibutuhkan, didefinisikan dengan keyword “def”.

print(" ———Toko Amanah Jaya———")
def total(harga,jumlah):
	"""fungsi untuk menghitung Total bayar"""
	return harga*jumlah
def diskon(harga):
	""" fungsi menghitung diskon """
	if (harga &gt;= 500000):
		potongan=harga*0.1
	else:
		potongan=harga*0.05
	return potongan
def bayar(harga,potongan):
	""" fungsi menghitung total bayar """
	return harga-potongan

#input data
harga= int(input("masukan harga barang: "))
jumlah= int(input("masukan jumlah baju yang dibeli: "))
Total=total(harga,jumlah)
potongan=diskon(Total)
tagihan=bayar(Total,potongan)
print("Total Harga = ", "Rp.",Total)
print("Diskon", "Rp.", potongan)
Bayar=int(input("Jumlah Nominal Uang =" ))
Kembalian= (Bayar-tagihan)
print("Uang Kembalian = ", "Rp.",Kembalian)

Bagaimana cara memindahkan fungsi tersebut ke file lain? Caranya mudah saja. Pertama cek dulu apakah program sudah berjalan sesuai dengan spesifikasinya. Jika sudah tidak ada masalah, tinggal “cut” saja dan buat file baru, di sini saya beri nama “diskon.py” dan letakan di folder yang sama. Jika dengan Google Colab, upload saja file tersebut di menu “upload file”. Untuk memanggil file tersebut gunakan instruksi “from” dan “import” di program utama berikut ini.

from diskon import total,diskon,bayar
print(" ———Toko Amanah Jaya———")
#input data
harga= int(input("masukan harga barang: "))
jumlah= int(input("masukan jumlah baju yang dibeli: "))
Total=total(harga,jumlah)
potongan=diskon(Total)
tagihan=bayar(Total,potongan)
print("Total Harga = ", "Rp.",Total)
print("Diskon", "Rp.", potongan)
Bayar=int(input("Jumlah Nominal Uang =" ))
Kembalian= (Bayar-tagihan)
print("Uang Kembalian = ", "Rp.",Kembalian)

Jalankan program dan pastikan berjalan seperti sebelumnya (tanpa file eksternal). Perhatikan juga penggunaan “if-else” pada python di file “diskon.py” tersebut.

Untuk jelasnya silahkan buka link youtube saya berikut ini.

Dipublikasi di Algoritma, Python | 4 Komentar