Raspberry Bluetooth Printer

You have to perform several steps in order to establish communication.

You have to pair your desired bluetooth device using bluetoothctl

sudo bluetoothctl -a

scan on

devices

pair XX:XX:XX:XX:XX:XX

trust XX:XX:XX:XX:XX:XX

quit

Where XX:XX:XX:XX:XX:XX is the MAC address of your bluetooth device.

You have to create the serial device that binds to your paired bluetooth device.

sudo rfcomm bind /dev/rfcomm0 XX:XX:XX:XX:XX:XX 1

The last number is the communication channel. It has to bee unique for all your connections.

Then you should be able to open a connection. (Assuming your bluetooth device actually supports the required SPP protocol.)

echo “test” > /dev/rfcomm0

source: https://raspberrypi.stackexchange.com/questions/78155/using-dev-rfcomm0-in-raspberry-pi/78301#78301?s=39be540452a34b55af09cb19d04ea700

Machine Learning #7 – Menuju Klasifikasi

Pada tulisan Machine Learning #5 telah diceritakan tentang Neural Network dengan 2 input dan 1 output. Mari kita kembangkan jika menggunakan 1 input dan 2 output. Percobaan ini mengarah ke klasifikasi.

Sabagai gambaran apabila inputnya adalah suara yang diubah menjadi nilai dalam bentuk matrik x dan hasilnya adalah 2 output, yaitu output y= [0 0]. Output y = [1 0], jika hasil klasifikasinya mengarah pada output pertama, misalkan saya kata “YA”, dan outputnya y = [0 1] jika hasil klasifikasinya adalah output kedua, misalkan kata “Tidak”.

Dari model di atas, tentunya agak kesulitan untuk diterapkan di mikrokontroler. Hasil dari training dalam bentuk TFLite >5Mb. Padahal mikrokontroler, katakanlah BLE 33 Sense, tidak memiliki Flash Memori yang berkapasitas 5Mb

Cara yang pertama yaitu mengubah kuantisasi dari float menjadi int pada mikrokontoler. Berikut contoh perbandingan kuantisasi menggunakan float dibandingkan menggunakan int. Memang akurasi menjadi sedikit berubah, namun penggunaan memori jauh lebih kecil.

Menghilangkan parameter yang tidak begitu penting, dengan pruning.

Dan beberapa proses yang dapat disimpulkan seperti gambar berikut:

Mencoba seonsor yang ada pada Nano BLE Sense

Melanjutkan tulisan Mencoba Nano 33 BLE Sense saatnya mencoba sensor-sensor yang ada pada modul ini. Sensor yang ada adalah 3D accelerometer, 3D gyroscope, 3D magnetometer (LSM9DS1), MEMS Digital Microphone (MP34DT05), Digital Proximity, Ambient Light, RGB and Gesture (APDS9960), Tekanan Udara (LPS22HB), Suhu dan Kelambaban (HTS221) Chip sensornya kecil kecil sekali!

Arduino Nano 33 BLE Sense Harddware Overview

Langsung saja, untuk mencoba Microphone, bisa kita lihat di sample skecthnya. Pastikan Board sudah bisa terpilih, driver terpasang dan Port juga sudah benar, cek di tulisan Mencoba Nano 33 BLE Sense. Selanjutnya pilih di bagian example -> PDM ->PDMSerialPlotter

Program ini menggunakan mikrofon on-board untuk mendengarkan audio dan memplotnya pada plotter serial. Kita akan melakukan kompilasi yang sangat lambat, membutuhkan waktu sekitar 10 menit untuk mengkompilasi dan mengunggah program. Ini karena integrasi Mbed OS dengan Arduino IDE, semoga Komunitas Arduino bisa memberikan solusi untuk ini.

Hasil tampilan di serial plotter.

Sedangkan untuk mencoba sensor-sensor lain, perlu mengistall library sesuai dengan chip sensornya berikut:

Selanjutnya gunakan contoh sketch berikut:

#include <Arduino_LSM9DS1.h> //IMU
#include <Arduino_LPS22HB.h> //Tekanan 
#include <Arduino_HTS221.h> //Suhu dan kelembaban 
#include <Arduino_APDS9960.h> //Gerakan, cahaya dan proksimiti

void setup(){
  Serial.begin(9600);  

  if (!IMU.begin()) 
  { Serial.println("Chip IMU tidak ditemukan!"); while (1);}

  if (!BARO.begin())  
  { Serial.println("Chip Sensor Tekanan tidak ditemukan!"); while (1);}

  if (!HTS.begin()) 
  { Serial.println("Chip Sensor Suhu &amp; Kelembaban tidak ditemukan!"); while (1);}

  if (!APDS.begin())  
  { Serial.println("Chip Gesture, cahaya dan proksimiti tidak ditemukan!"); while (1);}
 }

float accel_x, accel_y, accel_z;
float gyro_x, gyro_y, gyro_z;
float mag_x, mag_y, mag_z;
float Pressure;
float Temperature, Humidity;
int Proximity;

void loop()
{
  //Accelerometer
  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(accel_x, accel_y, accel_z);
    Serial.print("Accelerometer = ");Serial.print(accel_x); Serial.print(", ");Serial.print(accel_y);Serial.print(", ");Serial.println(accel_z);
  }
delay (200);

  //Gyroscope 
  if (IMU.gyroscopeAvailable()) {
    IMU.readGyroscope(gyro_x, gyro_y, gyro_z);
    Serial.print("Gyroscope = ");Serial.print(gyro_x); Serial.print(", ");Serial.print(gyro_y);Serial.print(", ");Serial.println(gyro_z);
  }
delay (200);

  //Magnetometer 
  if (IMU.magneticFieldAvailable()) {
    IMU.readMagneticField(mag_x, mag_y, mag_z);
    Serial.print("Magnetometer = ");Serial.print(mag_x); Serial.print(", ");Serial.print(mag_y);Serial.print(", ");Serial.println(mag_z);
  }
delay (200);

  //Pressure 
  Pressure = BARO.readPressure();
  Serial.print("Tekanan= ");Serial.println(Pressure);
  delay (200);

  //Temperature 
  Temperature = HTS.readTemperature();
  Serial.print("Suhu= ");Serial.println(Temperature);
  delay (200);

  //Humidity 
  Humidity = HTS.readHumidity();
  Serial.print("Kelembaban= ");Serial.println(Humidity);
  delay (200);

  //Proximity 
  if (APDS.proximityAvailable()) {
    Proximity = APDS.readProximity();
    Serial.print("Proksimiti= ");Serial.println(Proximity); 
    }
  delay (200);

  Serial.println(); 
  delay(1000);
}

HAsil bisa dilihat di serial monitor

Machine Learning #6 – Menerapkan Machine Learning ke Mikrokontroler (via Arduino + TinyML)

Dilihat dari situs resmi TensorFlow, saat ini board yang support dengan model training TensorFlowLite adalah board berikut:

Jadi mari kita gunakan yang saya punya, yaitu ESP-EYE (murah, 200an ribu) dan Nano 33 BLE Sense (mahal, 1,2 juta).

Untuk dapat menggunakan TinyML ada penjelasan di situs resminya, tapi cukup ribet. Mari gunakan milik Simone yang bernama EloquentTinyML. Siapkan dahulu library-nya melalui Library Manager

Selanjutnya pilih papan (board) yang tepat. Untuk Nano 33 BLE Sense lihat tutorialnya di tulisan Mencoba Nano 33 BLE Sense sedangkan jika menggunakan ESP-EYS, lihat tutorialnya di tulisan Memulai Percobaan ESP-CAM. Dicontohkan untuk kali ini kita gunakan Nano 33 BLE Sense:

Tuliskan sketch pada arduino dengan kode berikut:

#include <EloquentTinyML.h>
#include "sine_model.h"

#define NUMBER_OF_INPUTS 1
#define NUMBER_OF_OUTPUTS 1
#define TENSOR_ARENA_SIZE 2*1024

Eloquent::TinyML::TfLite<NUMBER_OF_INPUTS, NUMBER_OF_OUTPUTS, TENSOR_ARENA_SIZE> ml;


void setup() {
    Serial.begin(115200);
    ml.begin(sine_model);
}

void loop() {

    float x = 3.14 * random(100) / 100;
    float y = sin(x);
    float input[1] = { x };
    float predicted = ml.predict(input);

    Serial.print("Nilai sin(");
    Serial.print(x);
    Serial.print(") = ");
    Serial.print(y);
    Serial.print("\t Nilai prediksi: ");
    Serial.println(predicted);
    delay(1000);
}

Pada baris 2, isikan nama file hasil pengubahan tflile, misalkan hasilnya adalah sine_model.h Model yang akan digunakan adalah model 1 input dan 1 ouput sesuai pada artikel Machine Learning #3 Selanjutnya ketikkan jumlah input dan jumlah outputnya seperti yang dicontohkan di baris 4 dan 5, yaitu 1 input dan 1 output.

Di baris 8, adalah inisialisasi object EloquentTinyML sedangkan baris 13 adalah membaca model sine_model.h agar dapat diproses oleh library TinyML.

Untuk melihat hasil prediksi cukup gunakan .predict(nilai input) seperti yang terlihat di baris 21.

Saatnya upload skecth ke Nano 33 BLE Sense

Penampakan Nano 33 BLE Sense

Mari dilihat hasilnya, apakah mikrokontroler mampu memprediksi nilai y berdasarkan nilai input x? dimana rumus sebenarnya adalah y = sin(x). Mungkin ada sedikit selisih, namun untuk percobaan dengan 1 hidden layer ini bisa dimaklumi. Perlu banyak neuron dan hidden layer untuk mendapatkan nilai kesalahan (loss) yang sangat kecil.

Machine Learning #5 – Persiapan File Model untuk Mikrokontroler

Setelah mendapatkan model dari hasil training, model dapat disimpan ke file .tflite, file ini dapat kita gunakan untuk framework lain misalnya untuk mikrokontroller. Untuk membentuk file .tflite dari hasil training gunakan kode berikut:

# Convert model ke file tflite
tflite_model_name = 'sine_model'  # .tflite 

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]
tflite_model = converter.convert()

#for 1.2 to 2.3
#open(tflite_model_name + '.tflite', 'wb').write(tflite_model)

#for 2.4 or later
with tf.io.gfile.GFile(tflite_model_name +'.tflite', 'wb') as f:
  f.write(tflite_model)


Hasil dari code diatas adalah file sine_model.tflite atau dapat mnegubah nama filenya di baris 2

Karena mikrokontroler yang akan digunakan dibangun menggunakan bahasa C, maka perlu mengubah tflite menjadi file header agar dapat dikenali pada bahasa pemrograman C. Ada code fungsi (prosedur) yang sudah dibuat oleh pegiat machine learning, tinggal dipakai saja.

# Function: Convert some hex value into an array for C programming
def hex_to_c_array(hex_data, var_name):

  c_str = ''

  # Create header guard
  c_str += '#ifndef ' + var_name.upper() + '_H\n'
  c_str += '#define ' + var_name.upper() + '_H\n\n'

  # Add array length at top of file
  c_str += '\nunsigned int ' + var_name + '_len = ' + str(len(hex_data)) + ';\n'

  # Declare C variable
  c_str += 'unsigned char ' + var_name + '[] = {'
  hex_array = []
  for i, val in enumerate(hex_data) :

    # Construct string from hex
    hex_str = format(val, '#04x')

    # Add formatting so each line stays within 80 characters
    if (i + 1) < len(hex_data):
      hex_str += ','
    if (i + 1) % 12 == 0:
      hex_str += '\n '
    hex_array.append(hex_str)

  # Add closing brace
  c_str += '\n ' + format(' '.join(hex_array)) + '\n};\n\n'

  # Close out header guard
  c_str += '#endif //' + var_name.upper() + '_H'

  return c_str


Selanjutnya, gunakan fungsi di atas untuk mengubah .tflite menjadi .h, nama filenya dapat diset pada baris ke-2. Kali ini dinamai dengan sine_model.h

# Write TFLite model to a C source (or header) file
c_model_name = 'sine_model'       # .h 

with open(c_model_name + '.h', 'w') as file:
  file.write(hex_to_c_array(tflite_model, c_model_name))

Machine Learning #4 – 2 input, 3 HL, 1 output

Kali ini mari membuat model untuk 2 input dan 1 output dengan menggunakan 3 hidden layer. Sebagai contoh kasus ada data dengan rumus matematika: y = cos(x1) – sin(x2) + sin(x1+x2) data ini memiliki 1 input yaitu x1 dan x2. Sedangkan nilai outputnya 1 , yaitu y. Apakah MESIN bisa memprediksi rumus matematika di atas? Mari kita mulai dengan membuat datanya.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import math
from tensorflow.keras import layers

# Membuat 100, 77 dan 66 nilai random berdasarkan seed 1234
np.random.seed(1234)
x1_values = np.linspace(0,2*math.pi,100)
x2_values = np.linspace(0,2*math.pi,100)
x1_valuesV = np.linspace(0,2*math.pi,77)
x2_valuesV = np.linspace(0,2*math.pi,77)
x1_valuesT = np.linspace(0,2*math.pi,66)
x2_valuesT = np.linspace(0,2*math.pi,66)

# masing masing nilai dibuat dalam bentuk sinusoida, cos(x1) - sin(x2) + sin(x1+x2)
y_values = np.sin(x1_values) - np.cos(x2_values) - np.sin(x1_values+x2_values) + (0.2 * np.random.randn(x1_values.shape[0]))
y_valuesV = np.sin(x1_valuesV) - np.cos(x2_valuesV) - np.sin(x1_valuesV+x2_valuesV) + (0.2 * np.random.randn(x1_valuesV.shape[0]))
y_valuesT = np.sin(x1_valuesT) - np.cos(x2_valuesT) - np.sin(x1_valuesT+x2_valuesT) + (0.2 * np.random.randn(x1_valuesT.shape[0]))

plt.plot(x1_values, y_values, 'r.', label="Data u/ Training")
plt.plot(x1_valuesV, y_valuesV, 'b.', label="Data u/ Validasi")
plt.plot(x1_valuesT, y_valuesT, 'g.', label="Data u/ Test")
plt.legend()


Kode di atas adalah untuk membuat data training, data validasi dan data test. Hasil dari plot data x dan y adalah berikut:

Selanjutnya mari kita buat permodelan NN seperti berikut:

Karena inputnya 2, maka baris 28 kita ketikkan: input_shape=(2,)

# Membuat model dengan 3 hidden layer
model = tf.keras.Sequential()
model.add(layers.Dense(2, activation='tanh', input_shape=(2,)))
model.add(layers.Dense(10, activation='tanh'))
model.add(layers.Dense(10, activation='tanh'))
model.add(layers.Dense(10, activation='tanh'))
model.add(layers.Dense(1))
# Lihat pemodelan, lihat secara grafis di https://alexlenail.me/NN-SVG/index.html
model.summary()

Kedua input (x1 dan x2) perlu dibuat stack agar dapat diproses untuk permodelan. Kali ini, data training dan data validasi saja yang perlu dibuat stack. Lihat cara membuat stack pada baris 36-37.

x1x2_array = np.stack([x1_values, x2_values], axis=1)
x1x2V_array = np.stack([x1_valuesV, x2_valuesV], axis=1)

Saatnya membuat model. Kali ini menggunakan tensorboard untuk memvisualisasikannya. Jumlah epochnya adalah 1000 percobaan, dengan batch size 100

import datetime
%load_ext tensorboard
log_dir =  datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

# Gunakan optimizer adam , loss function Mean square error
model.compile(optimizer='adam', loss='mse', metrics=['mse'])

# Training model
#model.fit(x1x2_array,y_values, batch_size=100, epochs=1000)
history = model.fit(x1x2_array, y_values, epochs=1000, batch_size=100,
   validation_data=(x1x2V_array, y_valuesV), 
          callbacks=[tensorboard_callback])

# %tensorboard --logdir logs/gradient_tape # buka komentar jika ingin melihat di tensorboard

Setelah proses belajar berlangsung, saatnya mencoba, membutktikan prediksi MESIN dengan data yang sebenarnya

# Plot hasil prediksi terhadap nilai sebenarnya yaitu y = sin(x)
x1x2T_array = np.stack([x1_valuesT, x2_valuesT], axis=1)

predictions = model.predict(x1x2T_array)

plt.clf()
plt.title("Perbandingan nilai Test dengan nilai Prediksi")
plt.plot(x1_valuesT, y_valuesT, 'b.', label='Nilai Test')
plt.plot(x1_valuesT, predictions, 'r.', label='Nilai  Prediksi')
plt.legend()
plt.show()

Ternyata hasil prediksi mesin mirip dengan data sebenarnya. Hanya saja pada nilai input 5 ke atas masih ada kesalahan. Titik warna merah(nilai prediksi), terletak agak jauh dengan titik warna biru(nilai seharusnya). Untuk memperbaikinya bisa dengan mengubah aktivasi, menambah neuron atau layer. Silahkan dicoba coba hingga hasil terbaik. Setidaknya MESIN sudah belajar dengan baik

Jika ingin menyimpan hasil model training, skrip kode berikut bisa digunakan untuk mengexport model hasil training ke tflite. Dengan file tflite ini kita bisa gunakan untuk menyimpan hasilnya dan dibuka di platform lain.

# Convert Keras model to a tflite model
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]
tflite_model = converter.convert()

#for 1.2 to 2.3
#open(tflite_model_name + '.tflite', 'wb').write(tflite_model)

#for 2.4 or later
with tf.io.gfile.GFile('2input.tflite', 'wb') as f:
  f.write(tflite_model)

Machine Learning #3 – Persamaan NonLinier

Pada Machine Learning #2 MESIN belajar (training) untuk menyelesaikan persamaan linear, sekarang selanjutnya training untuk persamaan non linear. Kita contohkan menggunaan persamaan sinusoida.

Mari gunakan persamaan sederhana y = sin(x).

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import math
from tensorflow.keras import layers

# Membuat 1000 nilai random berdasarkan seed 1234, silahkan diganti untuk pola random lain
nsamples=1000
np.random.seed(1234)
x_values = np.random.uniform(low=0, high=(2 * math.pi), size=nsamples)
# masing masing nilai dibuat dalam bentuk sinusoida
y_values = np.sin(x_values) + (0.1 * np.random.randn(x_values.shape[0]))
plt.plot(x_values, y_values, '.')

# membagi menjadi 3 kategori data, untuk validasi, untuk test dan untuk training
val_ratio = 0.2     # 20% untuk data validasi
test_ratio = 0.2    # 20% untuk data test, dan sisanya untuk data training

val_split = int(val_ratio * nsamples)
test_split = int(val_split + (test_ratio * nsamples))
x_val, x_test, x_train = np.split(x_values, [val_split, test_split])
y_val, y_test, y_train = np.split(y_values, [val_split, test_split])

# Cek hasil split apakah benar, jika salah maka munculkan assertment
assert(x_train.size + x_val.size + x_test.size) == nsamples

# TAmpilkan data dengan warna yang berbeda:
plt.plot(x_train, y_train, 'b.', label="Data u/ Train")
plt.plot(x_test, y_test, 'r.', label="Data u/ Test")
plt.plot(x_val, y_val, 'y.', label="Data u/ Validasi")
plt.legend()
plt.show()
# Membuat model dengan 2 layer
model = tf.keras.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(1,)))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1))
# Lihat pemodelan
model.summary()

Kode diatas adalah untuk membuat model 2 layer yang sekuensial. Layer pertama 16 neuron dengan 1 input. Layer kedua dengan 16 neuron, dan outpunya 1 neuron untuk 1 output. jenis aktivasinya adalah ReLU atau Rectified Linear Unit

Hasil Kompilasi
# Gunakan optimizer RMSprop , loss function Mean absolute error
model.compile(optimizer='rmsprop', loss='mae', metrics=['mae'])

# Training model
history = model.fit(x_train, y_train, epochs=500, batch_size=100,
   validation_data=(x_val, y_val))

Untuk kali ini, menggunakan RMSProp sebagai optimizer. Pada training untuk persamaan linear Machine Learning #1, yang digunakan adalah SGD (Stochastic Gradient Descent). Pada training ini SGD terlalu lambat dan bisa jadi tidak bisa menemukan nilai minimum lost terendah. Perhatikan perbandingan berikut, SGD ditunjukkan dot warna merah:

Sedangkan untuk mencari nilai loss, yang digunakan adalah MAE (Mean absolute error) dimana selisih erornya di absolutekan jadi nilai positif semua. Berbeda dengan yang sebelumnya, dimana menggunakan MSE (Mean Squared Error) yang mengakarkan total nilai error.

Pada baris ke 47, MESIN diberikan 500 epoch untuk proses training, berdasarkan data training (x_train, y_train) dan kemudian mengevaluasi dengan data evaluasi (x_val, y_val). Ukuran batch yang digunakan adalah 100.

Jika ukuran tumpukan batch kecil, misalnya 1, maka gradien hanya dihitung dengan satu contoh pelatihan. Hal ini dapat membuat kerugian pelatihan yang berosilasi, karena setiap kali memperkirakan gradien hanya dengan satu contoh pelatihan, yang sering kali tidak mewakili seluruh data pelatihan. Jadi, semakin banyak contoh pelatihan yang digunakan, semakin baik dalam memperkirakan gradien (yang akan sesuai dengan semua contoh pelatihan), sehingga ini berpotensi mengarah pada konvergensi yang lebih cepat. Namun, jika menggunakan banyak contoh pelatihan, biayanya juga bisa mahal secara komputasi. Misalnya, bayangkan data pelatihan terdiri dari jutaan contoh pelatihan. Dalam hal ini, untuk melakukan satu langkah penurunan gradien, harus melalui semua pelatihan yang dapat memakan banyak waktu.

Line Plots of Classification Accuracy on Train and Test Datasets With Different Batch Sizes
Akurasi dari hasil training dan pengetesan pada nilai batch yang berbeda. Jika batch 1 maka banyak hasil test jauh meleset berdasarkan nilai proses training

Jika ingin melihat history loss dari hasil training, dapat gunakan skrip berikut:

# Plot hasil training, jika tidak diperlukan kode ini bisa diabaikan
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(loss) + 1)

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()

Selanjutnya mari buat perbandingan hasil training berdasarkan dengan model matematikan sebenarnya (y=sin(x))

# Plot hasil prediksi terhadap nilai sebenarnya yaitu y = sin(x)
predictions = model.predict(x_test)

plt.clf()
plt.title("Perbandingan hasil training berdasarkan dengan model matematikan sebenarnya")
plt.plot(x_test, y_test, 'b.', label='Nilai Test')
plt.plot(x_test, predictions, 'r.', label='Nilai Prediksi')
plt.legend()
plt.show()

Warna biru adalah nilai data test hasil sinus yang sudah diberi noise. Warna merah adalah prediksi MESIN. Walaupun data training sudah ditambahkan noise (Baris 12), mesin dapat mesin dapat memprediksi bahwa data training adalah persamanan sinus.

Machine Learning #2 – Neural Network

Berdasarkan pengalaman Machine Learning #1 maka mari memanfaatkan Neural Network untuk proses pembelajaran MESIN

Dari:

Kita ubah menjadi:

import tensorflow as tf
import numpy as np
from tensorflow import keras


xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

"""#### Gunakan 2 Layer """

my_layer_1 = keras.layers.Dense(units=2, input_shape=[1])
my_layer_2 = keras.layers.Dense(units=1)
model = tf.keras.Sequential([my_layer_1, my_layer_2])
model.compile(optimizer='sgd', loss='mean_squared_error')

xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

model.fit(xs, ys, epochs=50)


print(my_layer_1.get_weights()[0])
print(my_layer_1.get_weights()[1])
print(my_layer_2.get_weights())

print(model.predict([4.0]))

Baris 11 membentuk layer ke 1 dengan 2 unit dense, dimana inputnya adalah 1, yaitu x

Baris 12 membentuk layer ke 2 dengan 1 unit dense

Baris 13 membentuk model dalam bentuk sequensial (berurutan) dari layer ke-1 dilanjutkan layer ke-2

Baris 14 membuat model training menggunakan optimizer SGD (Stochastic Gradient Descent), sedangkan lost function-nya (untuk mengurangi kesalahannannya) menggunakan metode Mean Square Error (MSE). Lihat di Machine Learning #1 untuk lebih jelasnya

Selanjutnya lakukan training 50 kali, sesuai perintah di baris 19

Hasil nilai w dan b di setiap dense adalah berikut:

Pada layer ke-1, dense 1: w=0,9896864 dan b=-1,0169075 sedangkan dense 2: w=-0,38317692 dan b=0,24202025

Pada layer ke-2, dense: w1=0,8393119; w2=-1,0042762; b=0,06092146

Hasil prediksinya saat nilai x 4 adalah 6,90 yang sudah lebih mendekati angka 7, dibandingkan dengan di Machine Learning #1 yang hasilnya 6,80

Machine Learning #1 – Hello World!

Jika ada nilai input: x = [-1 0 1 2 3 4] ternyata menghasilkan nilai ouput: y = [-3 -1 1 3 5 7]

Jadi, apa rumus dari y ? apakah y=2x+1 atau y=x-2 atau yang lainnya?

Mari kita ajarkan nilai input dan ouput ini ke “MESIN”, agar si MESIN ini bisa belajar mencari model matematikanya. Dalam hal ini kita sebut saja dengan Machine Learning.

MESIN kita berikan petunjuk bahwa rumus dari y adalah linier, (y = wx + b) dimana w dan b adalah bilangan yang harus dicari oleh mesin.

Anggap saja Mesin menebak, w=3 dan b=-1, (y = 3x – 1) namun ternyata dari hasil perhitungan rumus itu adalah y = [-4 -1 2 5 8 11]

Hijau => Tebakan Mesin, Biru => Nilai seharusnya
Selisih dari setiap elemen perhitungan adalah, gap = [-1 0 1 2 3 4]
Jika setiap selisih dikuadratkan, maka gap = [1 0 1 4 9 16]

Jumlah dari kesalahan gap adalah, err = 1 + 0 + 1 + 4 +9 +16 = 31. OK, bagaimana kalau diakarkan saja? gap-nya kan dikuadratkan, jadi agar sebanding maka err adalah akar dari 31. Ini disebut dengan Mean Square Error, MSE = 5,57 (atau akar dari 31).

Ok, mesin coba jika y = 2x – 2. Maka hasil perhitungannya, y = [-4 -2 0 2 4 6], kalau dihitung MSE-nya maka hasilnya adalah 1 (MSE= 2,23) Wow, MSE sudah mulai berkurang. Proses ini dilakukan berulang ualng.

Mesin mencoba lagi, y = 2x – 1. Maka hasil perhitungannya y = [-3 -1 1 3 5 7] nah… ini baru tepat!

Mesin berhasil menebak, rumus matematikanya adalah y = 2x – 1

Menerapkan analogi di atas pada Machine Learning lewat Colabs (Atau jupyter notebook)

import tensorflow as tf
import numpy as np
from tensorflow import keras

model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mean_squared_error')

x = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
y = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

model.fit(x, y, epochs=50)

Baris 1 – 3 adalah penggunaan library tensonflow, numpy dan keras.

Baris 5, kita membuat model 1 input dan 1 output.

Baris 6, kita gunakan optimizer SGD (Stochastic Gradient Descent), sedangkan lost function-nya (untuk mengurangi kesalahannannya) menggunakan metode Mean Square Error (MSE) seperti yang dianalogikan di atas.

Baris 8 adalah nilai masukan, sedangkan baris 9 adalah hasil ouputnya.

Baris 10, kita minta MESIN untuk mencari model matematikanya dengan mencobanya sebanyak 50 kali.

Pertama tama, w=3 dan b = 1, namun error (loss) nya adalah 15,1. Karena gradien dari loss sudah ditemukan, maka MESIN mulai mengubah w dan b sesuai arah gradien, dalam hal ini percebaan kedua w=1,53 dan b = 0,37. Proses berulang-ulang hingga mencapi perulangan (epoch) yang kita tentukan. Contoh dalam kode ini adalah 50 epoch.

Pada akhirnya di-epoch ke 50, ditemukan w=2 dan b = -0.99 dimana loss-nya mendekati 0 (0,00009)

Perkiraan w dan b oleh MESIN dari epoch 1 hingga 50

Saat ini MESIN yakin bahwa rumus matematika yang didapatkan adalah y = 2x – 0,99 selanjutnya mari kita coba jika x adalah 4.

print(model.predict([4]))

Kode diatas adalah untuk memeriksa, memprediksikan, jika x = 4 maka berapakah nilai y nya

Hasilnya adalah 6.8087044, walaupun seharusnya hasilnya adalah 7
hasil perhitungan MESIN mendekati benar, dari setiap elemen nilai x

Kode untuk menampilkan plot

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Tebakan awal
INITIAL_W = 3.0
INITIAL_B = 1.0

# Fungsi menghitung loss
def loss(predicted_y, target_y):
  return tf.reduce_mean(tf.square(predicted_y - target_y))

# Proses training
def train(model, inputs, outputs, learning_rate):
  with tf.GradientTape() as t:
    current_loss = loss(model(inputs), outputs)
  # mencari arah gradien loss
  dw, db = t.gradient(current_loss, [model.w, model.b])
  # perbaiki model untuk epoch berikutnya dengan mengubah w dan b berdasarkan learning_rate
  model.w.assign_sub(learning_rate * dw)
  model.b.assign_sub(learning_rate * db)
  return current_loss

# Mendefinisikan model regresi linier
class Model(object):
  def __init__(self):
    # Inisialisasi w dan b
    self.w = tf.Variable(INITIAL_W)
    self.b = tf.Variable(INITIAL_B)

  def __call__(self, x):
    return self.w * x + self.b

"""Proses Training"""

# tentukan input, output dan learning rate
xs = [-1.0, 0.0, 1.0, 2.0, 3.0, 4.0]
ys = [-3.0, -1.0, 1.0, 3.0, 5.0, 7.0]
LEARNING_RATE=0.09

# Instantiate model
model = Model()

# Menampilkan w, b dan loss di setiap epoch
list_w, list_b = [], []
epochs = range(50)
losses = []
for epoch in epochs:
  list_w.append(model.w.numpy())
  list_b.append(model.b.numpy())
  current_loss = train(model, xs, ys, learning_rate=LEARNING_RATE)
  losses.append(current_loss)
  print('Epoch %2d: w=%1.2f b=%1.2f, loss=%2.5f' %
        (epoch, list_w[-1], list_b[-1], current_loss))

"""### Plot hasil training"""

# Plot nilai w dan b perkiraan dari hasil training terhadap w dan b seharusnya
TRUE_w = 2.0
TRUE_b = -1.0
plt.plot(epochs, list_w, 'r', epochs, list_b, 'b')
plt.plot([TRUE_w] * len(epochs), 'r--', [TRUE_b] * len(epochs), 'b--')
plt.legend(['w perkiraan', 'b perkiraan', 'w seharusnya', 'b seharusnya'])
plt.show()

Mencoba Nano 33 BLE Sense

Papan Arduino NANO 33 BLE Sense dirancang untuk solusi hemat daya dan hemat biaya bagi pembuat piranti elektronika yang memiliki konektivitas Bluetooth Hemat Energi. Menggunakan modul NINA B306, terdiri dari chip mikrokontroler Cortex M4F besutan Nordik, yaitu nRF52480. Arduino NANO 33 BLE Sense sama dengan Arduino NANO 33 BLE namun dengan tambahan satu set sensor yang sangat populer untuk mempelajari Machine Learning sebagai bagian dari kecerdasan buatan atau Artificial Inteligence (AI).

Untuk menggunakan modul ini, perlu menambahkan pustaka (library) Arduino nRF528x mbed Core. Caranya dengan memilih menu Tools, kemudian Boards dan Boards Manager, seperti yang didokumentasikan di halaman Arduino Boards Manager.

Arduino NANO 33 BLE Sense adalah variasi perangkat keras dari Arduino NANO 33 BLE; kedua modul tersebut dikenali sebagai Arduino NANO 33 BLE dan ini normal.

menginstal Driver untuk Arduino NANO 33 BLE Sense.

Dengan nRF528x mbed core diinstal, saatnya melanjutkan dengan penginstalan driver.

Pada Windows, jika menginstal Core nRF528x mbed dengan benar, cukup hubungkan Arduino NANO 33 BLE Sense ke komputer dengan kabel USB. Windows akan memulai proses instalasi drivernya setelah papan dicolokkan.

Memulai contoh sketch: blink

Pilih jenis board yang benar

Pilih Port yang sesuai

Mikrokontroler pada Arduino NANO 33 BLE Sense berjalan pada 3.3V, yang berarti tidak boleh menggunakan lebih dari 3.3V ke pin Digital dan Analognya. Berhati-hatilah saat menghubungkan sensor dan aktuator untuk memastikan bahwa batas 3,3V ini tidak pernah terlampaui. Menghubungkan sinyal tegangan yang lebih tinggi, seperti 5V yang biasa digunakan dengan papan Arduino lainnya, akan merusak Sense Arduino NANO 33 BLE.

Tegangan kerja 5V sekarang hanya menjadi pilihan tambahan untuk berbagai modul, sedangkan tegangan 3,3V menjadi tegangan standar untuk IC elektronik.