Alasan Kenapa Kita Seharusnya Tidak Membeli (aka boycott) Barang dari TEMU

Setidaknya ada tiga alasan kenapa seharusnya kita tidak membeli barang dari TEMU. Bahkan memboikotnya. Semurah apapun harga produknya, sebesar apapun diskonnnya.

1. Laporan DPR Amerika Serikat

Dalam laporan DPR AS, mereka melaporkan bahwa TEMU tidak memiliki complience untuk memenuhi Uyghur Forced Labor Prevention Act (UFLPA).  UFLPA mencegah penggunaan tenaga kerja Uyghur tanpa bayaran (lihat alasan 3).  Artinya, karena tidak memenuhi UFLPA, besar kemungkinan TEMU menjual barang yang berasal dari perusahaan yang tidak menggaji karyawannya (kerja paksa); karenanya harga barangnya menjadi murah sekali.

2. Laporan Seorang Teman Uyghur

Iklan TEMU yang betul-betul menggiurkan (Shops like billionaire!) membuat saya bertanya kepada seorang teman yang berasal dari Uyghur sebelum memutuskan membeli di TEMU. Saya bertanya kepada dia apakah benar TEMU tidak membayar pekerjanya (Orang Uyghur yang bekerja di perusahaan yang memproduksi barang dijual di TEMU). Jawabannya sangat mencengangkan, tidak hanya TEMU dari juga online shop yang lain menggunakan tenaga yang tidak dibayar; bahkan teman saya sendiri pernah mengalami bekerja tanpa di gaji. Tip singkatnya, jangan membeli barang yang country of origin nya dari China atau online shop dari China.

3. Laporan Pribadi

Karena massifnya promo Temu di Jepang, dan saya beberapa kali tergiur untuk membeli barang di Temu (harganya sangat murah sekali bahkan banyak yang gratis katanya), saya mengontak perwakilan mereka (Jepang) via messenger. Mereka tidak mau mengkonfirmasi kalau tidak comply dengan UFLPA; jadi saya asumsikan mereka, TEMU, benar-benar menggunakan tenaga saudara-saudara kita di Uyghur tanpa di bayar.

Two Papers Accepted in O-COCOSDA 2024

Our two papers were accepted in O-COCOSDA 2024:

• Check Your Audio Data: Nkululeko for Bias Detection
• UNCERTAINTY-BASED ENSEMBLE LEARNING FOR SPEECH CLASSIFICATION

 See you in Hsinchu!

Two papers got accepted in TENCON 2024

Two of my papers were accepted in TENCON 2024. Here is the list of titles:

1. Multi-label Emotion Share Regression From Speech Using Pre-Trained Self-Supervised Learning Models
2. Evaluating Hyperparameter Optimization for Machinery Anomalous Sound Detection

The first paper talks about emotion (share) recognition, meaning how to predict more than a single emotion from utterance. It differs from general speech emotion recognition (SER), although we can select n highest probabilities from SER. In the former, the total share should be 1 (or 100%). In the latter, the probabilities of each emotion category are independent, i.e., each could have 0.85 and 0.75 of probabilities. Usually, the highest probability is selected.

Here is a more detailed example.

Emotion (share) recognition

Angry: 0.54

Fear: 0.43

Other: 0.03

Speech emotion recognition

Angry: 0.64

Fear: 0.53

Sad: 0.23

In the first, the sum up of all probabilities is 1; this is not the case for the second approach (SER).

In the second article, I optimized anomalous machine sound detection via Optuna. The results on two different databases show different values of optimal parameters; however, the top three parameters to optimize remain the same (learning rate, patience, and type of loss function).

See you in Singapore, inshallah! 

Memahami F1-score dan penggunaannya (Binary dan Multiclass)

Dari Wikipedia

F-score (sebelum masuk ke F1 score) adalah harmonic mean (kebalikan arithmetic mean) dari precision dan recall. Jadi kalau (arithmetic) mean dari precision dan recall adalah (precision + recall) / 2 maka F-score adalah 2 * (1/precision + 1/recall) atau dapat ditulis dengan 

$$ F-score = 2 \frac{\text { precision } \cdot \text { recall }}{\text { precision }+ \text { recall }} = \frac{2 \mathrm{tp}}{2 \mathrm{tp}+\mathrm{fp}+\mathrm{fn}} $$ Dari rumus di atas terlihat bahwa nilai F-score bergantung pada tp (true positive), fp (false positive), dan fn (false negative).

Kemudian dengan menggunakan scikit-learn "classification report" saya mendapatkan hasil berikut:

Gambar 1. Output "classification report" dari scikit-learn

Mana diantara nilai F1-score (kotak merah) yang harus saya pakai/laporkan?

Dari Scikit-learn 

Keterangan lebih jauh tentang F1-score bisa dipelajari dari manual Scikit-learn. Ada beberapa nilai F1-score yang bisa dipakai yakni: binary, micro, macro, dan average. Untuk kasus saya (Gambar 1 atau dari output "classification report" secara umum), hanya ada tiga: binary (n atau p), macro, dan weighted. Berikut penjelasannya.

• Binary, untuk binary classification, yang dilaporkan adalah F1-score untuk positive label, yakni 0.81 dengan mengambil label "p" sebagai label positif.
• Macro avg, menghitung metrik untuk tiap label seperti rumus di atas, dan menghitung rata-ratanya (tanpa memperhitungkan jumlah sample/support).
• Weighted avg, menghitung metrik untuk tiap label seperti rumus di atas dengan memperhitungkan jumlah sample/support.

Jadi mana yang harus dipakai/dilaporkan?

Berdasarkan keterangan Scikit-learn di atas maka:

• Jika task adalah binary classification, yang dilaporkan adalah binary F1-score untuk positive label (yakni 0.81 atau 81% dari Gambar 1 di atas)
• Jika task adalah multiclass, maka yang dilaporkan adalah weighted average (avg), contohnya 0.79 atau 79% dari Gambar 1 di atas.

Secara default, scikit-learn menggunakan label "1" untuk label positif jika argumen "pos_label" tidak diberikan. Saya curiga, dari sinilah asal kata F1-score bermula, yakni F-score untuk label "1" (atau bisa saja F-score untuk maksimal 1, tapi hampir semua metrik nilai maksimalnya adalah 1).

Pathological Voice Detection with Nkululeko

I tried to add a recipe to Nkululeko for pathological voice detection using the Saarbrueken Voice Database (SVD, the dataset currently perhaps cannot be downloaded due to a server problem). Using Nkululeko is easy; I just need two working days (with a lot of play and others) to process the data and get the initial result. The evaluation was mainly measured with F1-Score (Macro). The initial result is an F1-score of 71% obtained using open smile ('os') and SVM without any customization.

On the third day, I made some modifications, but I am still using the 'os' feature (so I don't need to extract the feature again, using the same 'exp' directory to boost my experiments). The best F1 score I achieved was 76% (macro). This time, the modifications were: without feature scaling, feature balancing with smote, and using XGB as a classifier. My goal is to obtain an F1 score of 80% before the end of the fiscal year (March 2025).

Here is the configuration (INI) file and a sample of outputs (terminal).

Configuration file:

[EXP]
root = /tmp/results/
name = exp_os
[DATA]
databases = ['train', 'dev', 'test']
train = ./data/svd/svd_a_train.csv
train.type = csv
train.absolute_path = True
train.split_strategy = train
train.audio_path = /data/SaarbrueckenVoiceDatabase/export_16k
dev = ./data/svd/svd_a_dev.csv
dev.type = csv
dev.absolute_path = True
dev.split_strategy = train
dev.audio_path = /data/SaarbrueckenVoiceDatabase/export_16k
test = ./data/svd/svd_a_test.csv
test.type = csv
test.absolute_path = True
test.split_strategy = test
test.audio_path = /data/SaarbrueckenVoiceDatabase/export_16k
target = label
; no_reuse = True
; labels = ['angry', 'calm', 'sad']
; get the number of classes from the target column automatically
[FEATS]
; type = ['wav2vec2']
; type = ['hubert-large-ll60k']
; type = []
type = ['os']
; scale = standard
balancing = smote
; no_reuse = True
[MODEL]
type = xgb

Outputs:

$ python3 -m nkululeko.nkululeko --config exp_svd/exp_os.ini 
DEBUG: nkululeko: running exp_os from config exp_svd/exp_os.ini, nkululeko version 0.88.12
DEBUG: dataset: loading train
DEBUG: dataset: Loaded database train with 1650 samples: got targets: True, got speakers: False (0), got sexes: False, got age: False
DEBUG: dataset: converting to segmented index, this might take a while...
DEBUG: dataset: loading dev
DEBUG: dataset: Loaded database dev with 192 samples: got targets: True, got speakers: False (0), got sexes: False, got age: False
DEBUG: dataset: converting to segmented index, this might take a while...
DEBUG: dataset: loading test
DEBUG: dataset: Loaded database test with 190 samples: got targets: True, got speakers: False (0), got sexes: False, got age: False
DEBUG: dataset: converting to segmented index, this might take a while...
DEBUG: experiment: target: label
DEBUG: experiment: Labels (from database): ['n', 'p']
DEBUG: experiment: loaded databases train,dev,test
DEBUG: experiment: reusing previously stored /tmp/results/exp_os/./store/testdf.csv and /tmp/results/exp_os/./store/traindf.csv
DEBUG: experiment: value for type is not found, using default: dummy
DEBUG: experiment: Categories test (nd.array): ['n' 'p']
DEBUG: experiment: Categories train (nd.array): ['n' 'p']
DEBUG: nkululeko: train shape : (1842, 3), test shape:(190, 3)
DEBUG: featureset: value for n_jobs is not found, using default: 8
DEBUG: featureset: reusing extracted OS features: /tmp/results/exp_os/./store/train_dev_test_os_train.pkl.
DEBUG: featureset: value for n_jobs is not found, using default: 8
DEBUG: featureset: reusing extracted OS features: /tmp/results/exp_os/./store/train_dev_test_os_test.pkl.
DEBUG: experiment: All features: train shape : (1842, 88), test shape:(190, 88)
DEBUG: experiment: scaler: False
DEBUG: runmanager: value for runs is not found, using default: 1
DEBUG: runmanager: run 0 using model xgb
DEBUG: modelrunner: balancing the training features with: smote
DEBUG: modelrunner: balanced with: smote, new size: 2448 (was 1842)
DEBUG: modelrunner: {'n': 1224, 'p': 1224})
DEBUG: model: value for n_jobs is not found, using default: 8
DEBUG: modelrunner: value for epochs is not found, using default: 1
DEBUG: modelrunner: run: 0 epoch: 0: result: test: 0.771 UAR
DEBUG: modelrunner: plotting confusion matrix to train_dev_test_label_xgb_os_balancing-smote_0_000_cnf
DEBUG: reporter: Saved confusion plot to /tmp/results/exp_os/./images/run_0/train_dev_test_label_xgb_os_balancing-smote_0_000_cnf.png
DEBUG: reporter: Best score at epoch: 0, UAR: .77, (+-.704/.828), ACC: .773
DEBUG: reporter: 
               precision    recall  f1-score   support

           n       0.65      0.76      0.70        67
           p       0.86      0.78      0.82       123

    accuracy                           0.77       190
   macro avg       0.76      0.77      0.76       190
weighted avg       0.79      0.77      0.78       190

DEBUG: reporter: labels: ['n', 'p']
DEBUG: reporter: Saved ROC curve to /tmp/results/exp_os/./results/run_0/train_dev_test_label_xgb_os_balancing-smote_0_roc.png
DEBUG: reporter: auc: 0.771, pauc: 0.560 from epoch: 0
DEBUG: reporter: result per class (F1 score): [0.703, 0.817] from epoch: 0
DEBUG: experiment: Done, used 11.065 seconds
DONE

Update 2024/08/30: 

• Using praat + xgb (no scaling, balancing: smote) achieves higher F1-score, i.e.,  78% (macro) and 79% (weighted)
   

A paper was accepted at ACM MM 2024 Workshop

 

I am delightful to show that my paper was accepted at the ACM MM 2024. This was my first ACM paper and was written by myself solely (solo author). Here is an abstract from the screenshot of the paper above.

Abstact

 Automatic social perception recognition is a new task to mimic the measurement of human traits, which was previously done by humans via questionnaires. We evaluated unimodal and multimodal systems to predict agentive and communal traits from the LMU-ELP dataset. We optimized variants of recurrent neural networks from each feature from audio and video data and then fused them to predict the traits. Results on the development set show a consistent trend that multimodal fusion outperforms unimodal systems. The performance-weighted fusion also consistently outperforms mean and maximum fusions. We found two important factors that influence the performance of performance-weighted fusion. These factors are normalization and the number of models.

Once the link of the paper is available in ACM Library, I will put the link here.

Link: XXX.

Behind The Scene and Tips!

I have participating in MuSe challenge (Multimodal Sentiment Analysis Challenge and Workshop) for several years. This challenge, along with other challenges in conference like ICASSP and Interspeech, usually provides baseline program (code) and the respected dataset (e.g., ComParE). From this baseline, we can further analyze, make experiments, and often get new ideas to implement. My idea for that challenge (social perception challenge) is two parts: parameter optimization and multimodal fusion. I implement a lot of ideas (e.g., tuning more than 15 parameters) and some works. Once I get improvement with consistent results/phenomena (science must consistent!), I documented my work and submit a paper. This time, my paper got accepted!

See you in Melbourne, inshallah!

New pre-print: Uncertainty-Based Ensemble Learning For Speech Classification

 Last week, I submitted a new pre-print to Arxiv. The link is below.

 https://arxiv.org/abs/2407.17009

This paper discusses the importance of accommodating uncertainty in addressing the issue of different  models in speech classification. We used several variants of uncertainty-based ensemble learning (aka late fusions) to combine predictions of machine learning methods.

Every machine learning models has uncertainty, which, for instance, can be calculated from logits or probabilities. Entropy can be calculated from distribution. This distribution is multiplication of logits with softmax. Then, we can use several models to find the lowest uncertainty score and infer the label from that score. Or, we can weigh the probabilities by those uncertainty scores. We evaluated four variants of uncertainty-based ensemble learning.

Our work is highly beneficial to the community as it will help you improve the prediction of speech classification using ensemble learning.

Some areas that still need further development are stability and generalization. We see the trends that ensemble learning tends to improve the recognition rate of different models, but it is not always the case. We invite readers to collaborate in addressing the various unanswered questions.

We extend our thanks to AIST for their full support of our research.

Happy reading. We welcome your feedback.

 

Additional information: 

Toolkit used in the research: Nkululeko https://github.com/felixbur/nkululeko

Configuration files: https://github.com/bagustris/nkululeko_ensemble_speech_classficcation

 

---

This  post is based on template from [1].

Reference:  

[1] https://medium.com/open-science-indonesia/template-memajang-makalah-di-medsos-190c228dd86a

Belajar Entropy dan Aplikasinya pada Teori Informasi

Entropy yang dibahas ini bukan entropi pada termodinamika, melainkan pada teori informasi, meski secara konsep sama. Yakni, entropi adalah derajat ketidakturan, atau ketidakpastian.

Seperti biasa, proses belajar saya dokumentasikan dengan bantuan asciinema. Perangkat yang saya gunakan adalah scipy.stat.entropy, bisa juga dikodekan manual dengan Numpy. Materi pembelajaran saya kembangan dari manual Scipy.

Berikut dokumentasi pembelajaran saya untuk Entropy.

Keterangan:
Makna koin bias pada pembelajaran di atas adalah bahwa peluang gambar dan angka menjadi tidak 50:50, tetapi 90:10. Bisa jadi karena secara fisik berat sebelah ataupun sebab lain yang menjadikan peluang munculnya gambar jauh lebih besar dari peluang munculnya angka.

Memahami Bash Return Value

Bash, salah satu Unix Shell yang paling banyak digunakan, merupakan salah satu (bahasa) pemrograman yang saya pakai selain Python. Fungsi Bash layaknya lem perekat, melekatkan program yang satu dengan yang lain, Python dengan C, Python dengan C++, dan yang paling sering, Python dengan Sistem Unix (Linux Kernel, OS, dl). Simpelnya, saya menulis program utama dengan Python dan memanggilnya dengan Bash. 

Ada salah satu konsep yang selama ini belum sepenuhnya saya pahami: return value. Kalau dalam Python return value sangat jelas, nilai yang dikembalikan dari fungsi tersebut. Dalam bash, maka nilai return value hanya ada dua: sukses atau gagal. Nilai return value tersebut bisa banyak, dari 0 sampai 255. Nilai 0 untuk sukses (perintah yang dieksekusi), nilai selainnya untuk gagal.

Kode bash di bawah ini mendemonstrasikan return value dalam bash. Tugasnya adalah mendeteksi nilai yang diberikan, saya masukkan dari 5 sampai 15. Jika nilainya lebih dari 10 maka sukses, jika kurang atau sama dengan 10 maka gagal ("failure").

#!/bin/bash
# bash_return_value_demo.sh

# set counter
failure_count=0
success_count=0

# Zero (0) return value as sign of success
success_function() {
    if [ $1 -gt 10 ]; then # greater than
        echo "Success!"
        success_count=$((success_count+1))
        return 0
    fi
}

# Non-zero (1-255) return value as sign of failure
failure_function() {
    if [ $1 -le 10 ]; then # less equal
        echo "Failure!"
        failure_count=$((failure_count+1))
        return 1
    fi
}

# loop from 5 to 15
for x in {5..15}; do
    # print the value of x
    echo "Value of x: $x"
    success_function $x 	# input x to success_function
    failure_function $x 	# input x to failure_function

    # Print the last return values via $?
    echo "Return value: $?"

done
# count the number of successful and failed commands
echo "Number of successful commands: $success_count"
echo "Number of failed commands: $failure_count"

Kode di atas sebenarnya self explanatory, bisa jelas sendiri per baris plus komentar di atas/sampingnya. Sederhananya, kita set counter di baris 7-8. Kemudian kita buat fungsi sukses dan gagal di baris 8 dan 17. Argument untuk fungsi di Bash di masukkan dalam fungsi yakni lewat $1 (untuk argumen pertama, $2 untuk argumen kedua dst). Kemudian buat loop untuk X mulai dari 5 sampai 15 (5..15), batas atas, 15, diproses juga, tidak seperti dalam bahasa Python. Di akhir skrip kita tampilkan jumlah perintah yang sukses dan gagal. Outputnya 5 untuk gagal, 6 untuk sukses, sesuai logika kode tersebut. Jika program di atas dijalankan (setelah disimpan dalam fail bash_return_value_demo.sh), maka hasilnya adalah sebagai berikut, sesuai dengan penjelasan di atas.

./bash_return_value_demo.sh
Value of x: 5
Failure!
Return value: 1
-----------------
Value of x: 6
Failure!
Return value: 1
-----------------
Value of x: 7
Failure!
Return value: 1
-----------------
Value of x: 8
Failure!
Return value: 1
-----------------
Value of x: 9
Failure!
Return value: 1
-----------------
Value of x: 10
Failure!
Return value: 1
-----------------
Value of x: 11
Success!
Return value: 0
-----------------
Value of x: 12
Success!
Return value: 0
-----------------
Value of x: 13
Success!
Return value: 0
-----------------
Value of x: 14
Success!
Return value: 0
-----------------
Value of x: 15
Success!
Return value: 0
-----------------
Number of successful commands: 5
Number of failed commands: 6

Perangkat AI yang saya gunakan untuk riset (pengodean)

Beberapa perangkat berikut saya gunakan secara masif satu tahun terakhir ini untuk riset, yakni untuk pengodean (coding). Urutan perangkat AI di bawah ini saya susun berdasarkan prioritas, mana yang paling penting saya urutkan paling atas.

1. Cody.dev

Saya menggunakan cody.dev versi berbayar (USD 9/bulan). Perangkat ini sangat efektif untuk mencari bug, code completion, dan chat tentang kode-kode kita. Fitur utamanya, Cody bisa membaca codebase kita (sampai 15 file) dan menggunakan LLM, paling ampuh Claude 3 Opus, untuk menjelaskan, menyarankan, dan mengedit code secara otomatis. Selain versi VS Code-nya, saya juga menggunakan versi web-chat van search-nya di sourcegraph.com.

2. Github copilot

Perangkat ini adalah perangkat AI pertama yang saya gunakan dan sangat fungsional (meski kalah dari Cody). Saya menggunakan code completion dan chatnya (kadang-kadang). Perangkat ini secara intensif saya gunakan sebelum menggunakan Cody dengan bantuan email kampus untuk registrasi.

3. Cursor.sh

Cursor adalah fork dari vscode yang dikhususkan untuk AI. Fitur utamanya adalah copilot++ yang lebih handal dari Github Copilot dan juga bisa membaca codebase seperti Cody namun lebih pintar (lebih solutif dibanding Cody). Kelemahannya adalah biaya yang lebih mahal dan kuota terbatas LLM Claude 3 Opus (10 limit perhari untuk versi berbayarnya, 20 USD/bulan). Saya menggunakan versi gratisnya. Tips: untuk membuat alias "code" ke "cursor" untuk terminal Cursor, ikuti arahan di issue ini.

4. Deepseek Coder

DeepSeek Coder adalah LLM khusus untuk pengodean gratis dan opensource. Saya menggunakan versi webnya. DeepSeek Coder, jika tanpa codebase (hanya satu kasus saja), akan menghasilkan hasil terbaik sepengalaman saya (mengalahkan Claude Opus).

5. Ollama

Ollama adalah platform untuk menggunakan LLM secara offline. Perangkat ini sangat bermanfaat ketika tidak bisa koneksi internet. Kelemahannya, butuh spek komputer yang tinggi (RAM ideal minimal 16GB dan CPU/GPU modern).

Kehadiran LLM (large language model) spt GPT-4 membuat riset menjadi berbeda. Sebelum adanya LLM (large-language model, seperti ChatGPT, Claude Opus, dll), saya membagi waktu kerja saya menjadi 2, riset dan menulis (proses/hasil riset). Masing-masing porsinya 50:50. Setelah adanya LLM, porsinya berubah, menjadi sekitar 65:35. Lebih banyak risetnya ketimbang menulisnya. Kenapa? Karena masalah yang dulu banyak ditemui ketika riset bisa diselesaikan dengan bantuan  LLM (kebanyakan masalah algoritma, koding, percepatan waktu komputasi). Hasilnya, riset saya lebih produktif tapi tulisannya saya (pertahun) lebih sedikit. Semoga tahun depan bisa lebih banyak porsi untuk menulis kembali.

Rekomendasi direktori untuk penyimpanan data

Ketika bekerja dalam tim, atau dengan tim, tempat penyimpanan data menjadi masalah. Si A menyimpan data di "download", si B di "my document", dan si C di "Files". Untuk menyamakan tempat penyimpanan data di komputer, saya merekomendasikan hal berikut.

Komputer dengan satu harddisk (SSD/HDD)

Untuk komputer dengan satu hardisk, tempat penyimpanan data terbaik adalah di "home", atau "/home/$USER/data", dimana $USER adalah nama user, misal "bagus" (sehingga menjadi "/home/bagus/data"). Di Linux, kita hanya butuh mengetik "cd" untuk "pulang ke rumah". Untuk memanggil path "data", siapapun usernya, dalam python, kita bisa menggunakan Path dari pathlib berikut.

from pathlib import Path
data = Path.home() / "data"

Oya, di era sekarang ini, kita tidak perlu membuat partisi tersendiri untuk data. Beda dengan zaman saya kuliah dulu yang perlu mempartisi satu HDD menjadi beberapa drive agar ketika drive satu rusak, drive lainnya masih bisa digunakan.

Komputer dengan multi harddisk

Untuk komputer dengan multi harddisk, tempat penyimpanan data yang saya rekomendasikan adalah di root, yakni "/data". Siapapun usernya, pathnya pasti akan sama dalam hal ini.

Pro-kontra:

Kenapa satu harddisk di "home" dan multi-hardisk di "/data"? Sebetulnya "/data" lebih universal karena tidak bergantung "User", namun karena lokasinya di "/" (root), menurut saya hal ini rentan masalah. Misalnya jika sistem korup atau clash, biasanya data di bawah root akan terkena juga. Alasan kedua karena sekuriti/akses terhadap root. Home bisanya lebih terisolasi.

Siapa Pencipta Tuhan?

Dalam filosofi, permasalahan siapa pencipta Tuhan (problem of the creator of God) adalah topik perdebatan yang tiada habisnya. Argumennya adalah: "Jika alam semesta diciptakan oleh Tuhan, maka siapa pencipta Tuhan?"

Saya ingin menjawab pertanyaan itu dengan sederhana. Begini analoginya.

Analogi #1

Jika alam semesta, sebagai ciptaan, diibaratkan oleh angka 2, maka sebelum angka dua itu pastilah ada angka sebelumnya, yaitu 1. Angka 2 adalah alam semesta dan angka 1 adalah Tuhan. Lalu, siapa/apa sebelum 1? Tidak ada alias nol, 0. Begitu juga dengan Tuhan, tidak ada penciptanya. 

Analogi #2.

Dari video ini, adanya Tuhan Allah merusak teori sebab-akibat. Karena adanya penciptanya, maka siapa pencipta pencipta? Jawabannya adalah bahwa teori sebab-akibat tidak wajib ada (not necessarily exist). Dari mana hukum sebab-akibat itu berasal? Dari Fisika. Darimana Hukum Fisika itu berasal? Dari Matematika. Jadi pasti ada ujungnya, sebagaimana kita saat ini (fixed ada). Pencipta alam semesta tidak punya pencipta!

Jika semua, anggap, ada sebab-akibatnya, apa sebab dari hukum sebab-akibat (cause-effect relantionship)? Allah!

Membuat Alias untuk Github Copilot CLI

Untuk membuat alias untuk Github Copilot, misal ?? untuk menggantikan `gh copilot suggest`, beberapa baris alias berikut dapat ditambahkan pada fail `.bashrc`.

alias '??'='gh copilot suggest -t shell'
alias 'git?'='gh copilot suggest -t git'
alias 'explain'='gh copilot explain'

Dengan cara ini kita bisa mempermudah hidup dan menghemat waktu. Berikut contohnya:

bagus@m049:~$ ?? list WAV files less than 1 MB

Welcome to GitHub Copilot in the CLI!
version 0.5.4-beta (2024-01-04)

I'm powered by AI, so surprises and mistakes are possible. Make sure to verify any generated code or suggestions, and share feedback so that we can learn and improve. For more information, see https://gh.io/gh-copilot-transparency

Suggestion:                                                                     
                                                                                
  find . -name "*.wav" -size -1M                                                

? Select an option
> Exit
bagus@m049:~$ git? show history

Welcome to GitHub Copilot in the CLI!
version 0.5.4-beta (2024-01-04)

I'm powered by AI, so surprises and mistakes are possible. Make sure to verify any generated code or suggestions, and share feedback so that we can learn and improve. For more information, see https://gh.io/gh-copilot-transparency

Suggestion:                                                                     
                                                                                
  git log                                                                       

? Select an option
> Exit
bagus@m049:~$ explain "make -j 5"

Welcome to GitHub Copilot in the CLI!
version 0.5.4-beta (2024-01-04)

I'm powered by AI, so surprises and mistakes are possible. Make sure to verify any generated code or suggestions, and share feedback so that we can learn and improve. For more information, see https://gh.io/gh-copilot-transparency

Explanation:                                                                    
                                                                                
  • make is a build automation tool used to compile and build projects.         
    • -j 5 specifies the maximum number of jobs (parallel tasks) that make can  
    run simultaneously. In this case, it is set to 5.  

Menggunakan (Mini) Conda Untuk Komersial (Institusi Riset, dll)

Per 30 September 2020, term of service Anaconda berubah; lisensi berbayar dibutuhkan untuk menggunakan Anaconda untuk keperluan komersial (gratis untuk skala kecil, perusahaan kurang 200 orang pekerja). Miniconda dapat digunakan secara gratis, namun setting default dapat menyebabkan akses ke repository berbayarnya (meskipun gratis).

Solusi singkatnya adalah menambahkan `conda-forge` pada channel di `.condarc` untuk menggantikan konfigurasi default. Cek dengan `conda config --show channels` sebelum dan sesudah mengganti channel default (tidak tertulis di `.condarc`) dengan `conda-forge`.

Cek setting default channel:

$ conda config --show channels
channels:
  - defaults

Ganti channel default dengan menambahkan conda-forge di fail `.condarc` (default di direktori home)

 auto_activate_base: false
  channels: 
    - conda-forge

Cek kembali config conda:

$ conda config --show channels
channels:
  - conda-forge

Dengan cara ini, Miniconda dapat digunakan secara sah dan halal. Saya menggunakan Miniconda (daripada Anaconda) hanya untuk membuat virtual environment dengan versi python yang berbeda (misal dengan python3.8, python3.12, dll). Instalasi paket dalam python (seperti Numpy, Pandas) tetap saya lakukan dengan pip, bukan dengan Conda.

Laporan Bulanan Januari 2024

Pada bulan ini, saya melakukan dua kali kerja jarak jauh setengah hari dan tiga kali kerja jarak jauh sepanjang hari. Isi dari pekerjaan jarak jauh ini entah menulis laporan (makalah penelitian) untuk pengembangan sistem pengenalan emosi ucapan waktu nyata atau melihat sistem e-learning di kantor (Kursus Pelatihan Dasar untuk Karyawan Asing). Saya terus membangun adapter WavLM untuk sistem pengenalan emosi ucapan Jepang, tetapi hasilnya belum diperoleh. Saya juga meninjau beberapa pengenalan emosi ucapan dan ekspresi vokal termasuk dataset dari Vietnam (dari Konferensi APSIPA 2023), Korpus Ucapan Emosional Anak Rusia (EmoChildRu), vokalisasi nonverbal Jepang (JNV), dan Ucapan Emosional Jepang dengan Konten Verbal dan Ekspresi Nonverbal (JVNV). Saya juga sedang menyiapkan tanggapan untuk sebuah makalah yang diajukan ke LREC/Coling 2024. Dalam diskusi tertulis, saya menjelaskan daya saing model pra-pelatihan dengan HuBERT Large yang mencapai hasil terbaik di antara model-model pra-pelatihan lainnya, dan juga kesulitan dengan model-model pra-pelatihan lain seperti UniSpeech-SAT dan XLSR-2B. Kesulitan pertama disebabkan oleh desain UniSpeech-SAT yang ditujukan untuk verifikasi pembicara dengan informasi terpisah di antara pembicara, sementara kesulitan kedua disebabkan oleh batasan memori GPU (saat ini saya melatih model saya dengan RTX3090 24 GB VRAM). Komputasi sebelumnya menggunakan model besar seperti XLSR 2B tidak dapat dilakukan karena masalah out-of-memory. Meskipun masalah ini dapat diatasi dengan meningkatkan memori (misalnya, dengan mengupgrade GPU ke A6000 dengan 48 GB VRAM), model yang dihasilkan akan besar ukurannya, yang dapat memperpanjang waktu pemuatan model untuk inferensi. Selain itu, saya juga melakukan pekerjaan administratif menyiapkan dokumen untuk perpanjangan visa.