[TUTORIAL] Apa itu TensorFlow? Inilah Pengertian, Manfaat, hingga Cara melakukan Instalasi (+ Video Tutorial)

Assalamu‘alaikum wr. wb.

Dalam Machine Learning khususnya Deep Learning, TensorFlow sangat dibutuhkan untuk mengerjakan Proyek-proyek yang lebih Kompleks. Kali ini kita akan membahas tentang Apa itu TensorFlow, dan Bagaimana Cara melakukan Instalasinya.

Sumber Artikel : Simplilearn.com, Revou.co, Itbox.id (Blog), dan Kozyrk.Medium.com

A. Pengertian TensorFlow

TensorFlow merupakan kerangka kerja sumber terbuka milik Google yang dirancang untuk pengembangan dan pelatihan model dalam berbagai bidang, termasuk Machine Learning, Deep Learning, dan Analisis Statistik lainnya.

Meskipun awalnya tidak dirancang untuk komputasi numerik berskala besar, TensorFlow berkembang menjadi sebuah alat yang sangat berharga untuk pengembangan deep learning. Google kemudian mengambil langkah untuk membuat perangkat lunak ini menjadi open-source, memungkinkan akses publik ke fungsionalitasnya.

Perangkat lunak TensorFlow mengelola kumpulan data dalam bentuk grafik dengan node dan edge. Edge, yang menghubungkan node dalam Grafik, mewakili vektor dan membentuk apa yang disebut sebagai tensor.

Dalam praktiknya, TensorFlow sering digunakan dalam jaringan saraf untuk berbagai tujuan, seperti pengenalan Gambar, pengenalan suara, dan Pemrosesan Bahasa Alami (NLP). Kode yang ada dalam perpustakaan TensorFlow dapat diintegrasikan ke dalam berbagai aplikasi, memungkinkan aplikasi tersebut melaksanakan berbagai tugas yang terkait dengan machine learning.

Teknologi ini mempercepat dan menyederhanakan proses implementasi model machine learning bagi pengembang dengan membantu dalam perolehan data, penyajian prediksi dalam skala besar, dan penyempurnaan hasil.

Dalam pembangunan aplikasi dan kerangkanya, TensorFlow menggunakan bahasa pemrograman Python sebagai front-end API. Pemilihan Python untuk tugas ini bertujuan untuk mempermudah perhitungan numerik dan aliran data, menjadikan machine learning lebih cepat dan lebih mudah dipahami bagi para pengembang.

B. Sejarah Perkembangan TensorFlow

TensorFlow pertama kali diperkenalkan secara publik pada Tahun 2015, sementara versi Stabil Pertama muncul pada Tanggal 11 Februari 2017 (14 Jumadil Awal 1438 H). TensorFlow dibuat dan dikelola oleh Google. Sejak saat itu, TensorFlow telah menjadi salah satu framework paling populer untuk proyek deep learning dan machine learning. Ini memiliki perpustakaan yang luas untuk machine learning dan komputasi numerik berukuran besar. Berikut adalah beberapa tonggak TensorFlow :

• Pada Desember 2017, Kubeflow dirilis untuk operasi dan implementasi TensorFlow di Kubernetes.
• Pada Maret 2018, TensorFlow 1.0 dirilis untuk machine learning dalam JavaScript.
• Pada Januari 2019, TensorFlow 2.0 dirilis yang menambahkan sejumlah komponen ke TensorFlow.
• Pada Mei 2019, TensorFlow Graphic dirilis untuk deep learning dalam grafika komputer.

C. Alasan memilih TensorFlow

1. TensorFlow Menyediakan Keduanya API C++ dan Python

Sebelum adanya perpustakaan ini, mekanisme Coding untuk pembelajaran mesin dan pembelajaran mendalam jauh lebih rumit. Perpustakaan ini menyediakan API tingkat tinggi, dan Coding yang kompleks tidak diperlukan untuk menyiapkan Neural Network, mengonfigurasi neuron, atau memprogram neuron. Perpustakaan ini menyelesaikan semua tugas ini. TensorFlow juga memiliki integrasi dengan Java dan R.

2. TensorFlow Mendukung Perangkat Komputasi CPU dan GPU

Aplikasi pembelajaran mendalam sangat rumit, dengan proses pelatihan memerlukan banyak perhitungan. Ini membutuhkan waktu lama karena ukuran data yang besar, dan melibatkan beberapa proses iteratif, perhitungan matematis, perkalian matriks, dan sebagainya. Jika Anda melakukan kegiatan ini pada Central Processing Unit (CPU) biasa, biasanya akan memakan waktu lebih lama.

Graphical Processing Unit (GPU) populer dalam konteks permainan, di mana Anda membutuhkan layar dan gambar beresolusi tinggi. GPU awalnya dirancang untuk tujuan ini. Namun, mereka juga digunakan untuk mengembangkan aplikasi pembelajaran mendalam.

Salah satu keunggulan utama TensorFlow adalah bahwa ia mendukung GPU, serta CPU. Ini juga memiliki waktu kompilasi yang lebih cepat daripada perpustakaan pembelajaran mendalam lainnya, seperti Keras dan Torch.

D. Kelebihan dan Kekurangan TensorFlow

Berikut ini adalah Kelebihan dan Kekurangan TensorFlow :

1. Kelebihan TensorFlow

• Dapat diubah Skala : Selain dapat beroperasi di desktop, TensorFlow juga mendukung penggunaan di perangkat seluler. Kemampuan perangkat lunak ini untuk diimplementasikan pada berbagai perangkat memungkinkan pengembang mengadopsinya untuk sistem-sistem berbagai jenis.
• Open Source : TensorFlow disediakan secara gratis untuk siapa pun. Pengembang dapat memanfaatkan modul-modul yang ada di TensorFlow tanpa biaya.
• Debugging yang Efisien : Keberadaan Tensorboard di TensorFlow mempermudah pengembang dalam melakukan debugging node tanpa perlu melihat seluruh kode secara terpisah untuk menyelesaikan jaringan saraf.
• Paralelisme : TensorFlow menggunakan sistem GPU dan CPU sebagai fungsinya. Pengembang memiliki kebebasan untuk memilih menggunakan salah satu arsitektur sesuai kebutuhan, yang dapat mengurangi penggunaan memori.
• Kompatibilitas yang Luas : TensorFlow tidak hanya terbatas pada Python, melainkan juga kompatibel dengan berbagai bahasa pemrograman lain seperti C++ dan JavaScript. Pengembang dapat memilih bahasa pemrograman yang paling nyaman dan dikuasai oleh mereka.
• Dukungan untuk Berbagai Arsitektur : Selain CPU dan GPU, TensorFlow juga menyertakan arsitektur TPU yang dapat melakukan komputasi dengan lebih cepat. Model yang dibuat dengan menggunakan TPU dapat lebih mudah diintegrasikan dengan cloud dan beroperasi lebih cepat dibandingkan dengan dua model lainnya.

2. Kekurangan TensorFlow

• Tidak Mendukung Windows : TensorFlow memiliki keterbatasan dalam fitur yang disediakannya untuk pengguna Windows. Software ini menawarkan lebih banyak fitur untuk pengguna Linux.
• Kecepatan yang Relatif Lambat : Dibandingkan dengan kompetitornya, TensorFlow memiliki kinerja yang cenderung lebih lambat.
• Pembaruan yang Sering : TensorFlow sering kali menerapkan pembaruan sistem, yang berarti pengembang harus sering melakukan instalasi ulang.
• Homonim yang Mengganggu : TensorFlow mengandung homonim, di mana kata yang dieja sama memiliki makna yang berbeda. Contohnya, dalam TensorFlow, kata "Conv2d" memiliki beberapa arti yang berbeda, yang membuat pengguna sulit untuk mengingat dan menggunakan dengan konsisten.
• Ketergantungan pada Platform : Meskipun TensorFlow membantu mengurangi panjang kode dan membuatnya lebih mudah diakses oleh pengembang, setiap kode membutuhkan platform lain untuk eksekusi, menciptakan ketergantungan pada platform tertentu.

E. Komponen-komponen pada TensorFlow

1. Tensor

Tensor membentuk kerangka kerja inti dari TensorFlow. Semua perhitungan di TensorFlow melibatkan tensor. Ini adalah matriks n-dimensi yang mewakili berbagai jenis data. Sebuah tensor dapat menjadi hasil dari suatu perhitungan atau dapat berasal dari data input.

2. Graf

Graf menggambarkan semua operasi yang terjadi selama pelatihan. Setiap operasi disebut node op dan terhubung dengan yang lain. Graf menunjukkan node op dan koneksi antara node, tetapi tidak menampilkan nilai.

F. Elemen Program pada TensorFlow

Program-program TensorFlow bekerja berdasarkan dua konsep dasar, yaitu:

• Membangun Grafik Komputasi
• Mengeksekusi Grafik Komputasi

Pertama, Anda perlu memulai dengan menulis kode untuk mempersiapkan grafik. Setelah itu, Anda membuat sesi di mana Anda mengeksekusi grafik ini.

Pemrograman TensorFlow sedikit berbeda dari pemrograman reguler. Meskipun Anda familiar dengan pemrograman Python atau pemrograman machine learning di sci-kit-learn, ini mungkin konsep baru bagi Anda.

Cara data ditangani di dalam program itu sendiri agak berbeda dari bahasa pemrograman reguler. Untuk segala sesuatu yang selalu berubah dalam pemrograman reguler, perlu dibuat variabel.

Namun, dalam TensorFlow, data dapat disimpan dan dimanipulasi menggunakan 4 (Empat) Elemen Pemrograman yang berbeda :

• Konstan (Constant)
• Variabel
• Placeholder
• Sesi (Session)

1. Konstan (Constant)

Konstan adalah parameter dengan nilai yang tidak berubah. Untuk mendefinisikan konstan, kita menggunakan perintah tf.constant().

Contoh :

a = tf.constant(2.0, tf.float32)
b = tf.constant(3.0)
print(a, b)

Pada kasus konstan, Anda tidak dapat mengubah nilai mereka selama komputasi.

2. Variabel

Variabel memungkinkan kita menambahkan parameter yang dapat diatur ulang ke grafik. Untuk mendefinisikan variabel, kita menggunakan perintah tf.Variable() dan menginisialisasinya sebelum menjalankan grafik dalam sesi.

Contoh :

W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

3. Placeholder

Placeholder memungkinkan kita memberi makan data ke model TensorFlow dari luar model. Ini memungkinkan nilai diisi nanti. Untuk mendefinisikan placeholder, kita menggunakan perintah tf.placeholder().

Contoh :

a = tf.placeholder(tf.float32)
b = a * 2

with tf.Session() as sess:
    result = sess.run(b, feed_dict={a: 3.0})
    print(result)

Placeholder adalah jenis khusus dari variabel dan mungkin konsep baru bagi banyak orang. Placeholder mirip dengan variabel, tetapi digunakan untuk memberi makan data dari luar. Biasanya, ketika Anda melakukan perhitungan, Anda perlu memuat data dari file lokal atau dari file gambar, file CSV, dll. Ada ketentuan dengan jenis variabel khusus yang dapat diisi secara teratur. Salah satu alasan memiliki jenis ketentuan ini adalah bahwa jika Anda mendapatkan seluruh input sekaligus, mungkin menjadi sangat sulit untuk menangani memori.

Ada cara tertentu untuk mengisi placeholder yang disebut feed_dict, yang menentukan tensor yang memberikan nilai kepada placeholder.

Secara singkat, konstan, variabel, dan placeholder menangani data dalam program aliran, setelah itu Anda harus membuat grafik dan menjalankan sesi.

Mari ketahui lebih lanjut tentang Sesi pada bagian berikutnya dari artikel Apa itu TensorFlow.

4. Sesi (Session)

Sesi dijalankan untuk mengevaluasi node. Ini disebut sebagai TensorFlow Runtime.

Contoh :

a = tf.constant(5.0)
b = tf.constant(3.0)
c = a * b


# Membuka Sesia
sess = tf.Session()

# Mengevaluasi tensor c
print(sess.run(c))

Ketika membuat sesi, Anda menjalankan perhitungan, node, atau operasi tertentu. Setiap variabel atau perhitungan yang Anda lakukan seperti operasi pada node dalam grafik. Awalnya, grafik akan menjadi grafik default. Saat Anda membuat objek TensorFlow, ada grafik default yang tidak berisi operasi atau node apa pun. Saat Anda menetapkan variabel, konstan, atau placeholder, masing-masing dari mereka dikenal sebagai operasi (dalam istilah TensorFlow).

Ini berbeda dengan konsep tradisional, di mana membuat konstan atau variabel bukanlah operasi. Seperti yang terlihat pada contoh di atas, hanya perintah 'c = a * b' yang akan menjadi operasi. Tetapi dalam TensorFlow, menetapkan variabel atau konstan juga adalah operasi. Selama sesi, Anda sebenarnya dapat menjalankan semua operasi atau node ini.

Pada contoh kami, untuk tiga perintah teratas, Anda hanya membuat grafik, dan eksekusi tidak terjadi sampai Anda membuat sesi (dengan perintah sess = tf.Session()).

G. Cara Install TensorFlow

Sumber : Tutorialspoint.com dan Upwork.com

1. Periksa Versi Python

Pertama, bukalah Command Prompt (CMD) dan ketiklah Perintah berikut ini untuk memeriksa Versi Python :

python --version

2. Instalasi Anaconda

Setelah itu, bisa Anda lakukan Instalasi Anaconda dan dapat di-Download di sini (Anaconda.com). Untuk melihat Tutorial-nya, silakan lihat di sini.

3. Instalasi TensorFlow

Setelah itu, buka lagi Command Prompt (CMD) dan ketiklah :

pip install tensorflow

Kemudian, ketiklah Perintah berikut ini :

python.exe -m pip install --upgrade pip

Catatan :

• Biasanya saat menginstal TensorFlow membutuhkan sedikit Waktu yang Lama dan bisa sampai Lebih dari 10 Menit.

4. Memeriksa TensorFlow

Selanjutnya, bisa membuat Program Python Sederhana atau membuka Python IDLE Shell dan ketiklah Program berikut ini untuk memeriksa Versi TensorFlow : 

import tensorflow as tf

print("Tensorflow Version : " + tf.__version__)

Kemudian, simpanlah Program di atas dan Jalankan (Compile) dengan menggunakan CMD atau Terminal, dan inilah hasilnya :

5. Install TensorFlow di Anaconda

Buka Anaconda dan klik pada bagian "Environments". Jika sudah, klik Tombol "Create (➕)" di bawah dan ketiklah "tensorflow" dan klik "Create".

Maka, akan melakukan Proses Instalasi Anaconda.

Setelah itu, pilihlah "Not Installed" pada Opsi di atas, dan ketiklah "tensorflow" dan pilihlah Package dari Tensorflow dan Keras. Setelah itu, klik Tombol "Apply" di bawah.

Jika belum bisa, maka Carilah Anaconda Prompt (Seperti CMD) dan ketiklah :

conda install tensorflow

Untuk mencari Anaconda Prompt, carilah "anaconda_prompt" dan klik "Launch".

Kemudian, ketiklah Perintah ini untuk Lingkungan TensorFlow Anda, seperti "tf" :

conda create --name tf tensorflow

Kemudian, ketiklah "y" untuk melanjutkan Pembuatan Lingkungan/Environment TensorFlow.

Gunakan perintah berikut untuk menginstal rilis TensorFlow terkini. Bagi pemula, hanya CPU yang direkomendasikan. Selanjutnya, Ketiklah :

conda activate tf

H. Contoh Program Python TensorFlow (Untuk Deep Learning dan Neural Network)

Sumber : Toptal.com

1. Sebelum Memulai dan Langkah-langkah Awal

Karena kita akan mendemonstrasikan API Python, pemahaman tentang Numpy juga bermanfaat. Untuk mengatur TensorFlow, silakan ikuti petunjuk yang ditemukan di sini.

Jika Anda menggunakan Windows, perlu dicatat bahwa, pada saat penulisan, Anda harus menggunakan Python 3.4+, bukan 2.7. Ketika Anda sudah siap, seharusnya Anda dapat mengimpor perpustakaan dengan :

import tensorflow as tf

Langkah 1 : Membuat Graf (Kurva)

Pembangunan program TensorFlow pada umumnya terdiri dari dua langkah utama, yang pertama adalah membangun grafik komputasi, yang akan menjelaskan perhitungan yang ingin Anda lakukan, tetapi tidak benar-benar melakukannya atau menyimpan nilai apa pun.

Seperti halnya grafik apa pun, kita memiliki node dan tepi. Tepi mewakili tensor, yang merupakan representasi array n-dimensi. Sebagai contoh, tensor dengan dimensi (atau peringkat dalam bahasa TensorFlow) 0 adalah skalar, peringkat 1 adalah vektor, peringkat 2 adalah matriks, dan seterusnya.

Node mewakili operasi yang menghasilkan tensor output, mengambil tensor sebagai input jika diperlukan. Operasi tersebut mencakup penambahan (tf.add), perkalian matriks (tf.matmul), dan juga pembuatan konstan (tf.constant).

Jadi, mari gabungkan beberapa hal ini untuk Grafik pertama kita.

a = tf.constant([2.5, 2])
b = tf.constant([3, 6], dtype=tf.float32)
total = tf.add(a, b)

Di sini, kita telah membuat tiga operasi, dua di antaranya untuk membuat array konstan 1 dimensi.

Tipe data disimpulkan dari argumen nilai yang dilewatkan, atau Anda dapat menentukannya dengan argumen dtype. Jika saya tidak melakukan ini untuk b, maka int32 akan disimpulkan dan kesalahan akan terjadi karena tf.add akan mencoba mendefinisikan penambahan pada dua jenis yang berbeda.

Langkah 2 : Mengeksekusi Operasi Program

Grafiknya sudah ditentukan, tetapi untuk benar-benar melakukan penghitungan apa pun pada grafik tersebut (atau bagian mana pun dari grafik tersebut), kita harus menyiapkan Sesi TensorFlow.

sess = tf.Session()

Alternatifnya, jika kita menjalankan sesi di shell interaktif seperti IPython (Jupyter Notebook), maka kita menggunakan :

sess = tf.InteractiveSession()

Pada titik ini, kita memperkenalkan kelas Variable dari TensorFlow. Sementara konstan adalah bagian tetap dari definisi grafik, variabel dapat diperbarui. Konstruktor kelas memerlukan nilai awal, tetapi bahkan dengan itu, variabel perlu operasi untuk menginisialisasi mereka secara eksplisit sebelum operasi lain dilakukan pada mereka.

Variabel menyimpan status grafik dalam sesi tertentu, jadi kita seharusnya memperhatikan apa yang terjadi dengan beberapa sesi yang menggunakan grafik yang sama untuk lebih memahami variabel.

# Create a variable with an initial value of 1
some_var = tf.Variable(1)

# Create op to run variable initializers
init_op = tf.global_variables_initializer()
 
# Create an op to replace the value held by some_var to 3
assign_op = some_var.assign(3)
 
# Set up two instances of a session
sess1 = tf.Session()
sess2 = tf.Session()

# Initialize variables in both sessions
sess1.run(init_op)
sess2.run(init_op)
print(sess1.run(some_var)) # Outputs 1

# Change some_var in session1
sess1.run(assign_op)
print(sess1.run(some_var)) # Outputs 3
print(sess2.run(some_var)) # Outputs 1

# Close sessions
sess1.close()
sess2.close()

Kita telah menyiapkan grafik dan dua sesi.

Setelah menjalankan inisialisasi pada kedua sesi (jika kita tidak menjalankan ini dan kemudian mengevaluasi variabel, kita akan mendapatkan kesalahan), kita hanya menjalankan operasi penugasan pada satu sesi. Seperti yang dapat kita lihat, nilai variabel tetap, tetapi tidak melintasi sesi.

2. Memberi Makan Grafik untuk Mengatasi Masalah Numerik

Konsep penting lain dari TensorFlow adalah placeholder. Sementara variabel menyimpan status, placeholder digunakan untuk mendefinisikan input apa yang dapat diharapkan oleh grafik beserta tipe datanya (dan opsionalnya bentuknya). Kemudian kita dapat memberikan data ke dalam grafik melalui placeholder saat kita menjalankan komputasinya.

Grafik TensorFlow mulai menyerupai jaringan saraf yang ingin kita latih, tetapi sebelum itu, mari gunakan konsep-konsep ini untuk menyelesaikan masalah numerik umum dari dunia keuangan.

Misalkan kita ingin menemukan y dalam suatu persamaan seperti ini:

v = Ce-0.5y+ Ce-y+Ce-1.5y+(C+P)e-2y

Untuk suatu nilai v (dengan C dan P konstan).

Ini adalah rumus untuk menghitung yield-to-maturity (y) pada obligasi dengan nilai pasar v, pokok P, dan kupon C yang dibayar setiap enam bulan sekali tetapi dengan arus kas yang di-diskontokan dengan bunga majemuk kontinu.

Secara dasar, kita harus menyelesaikan suatu persamaan seperti ini dengan metode coba dan error, dan kita akan memilih metode bisection untuk mendekati nilai akhir kita untuk y.

Pertama, kita akan memodelkan masalah ini sebagai grafik TensorFlow.

C dan P adalah konstanta tetap dan merupakan bagian dari definisi grafik kita. Kita ingin memiliki proses yang menyempurnakan batas bawah dan atas y. Oleh karena itu, batas-batas ini (dinyatakan sebagai a dan b) adalah kandidat baik untuk variabel yang perlu diubah setelah setiap tebakan y (dianggap sebagai titik tengah a dan b).

# Specify the values our constant ops will output
C = tf.constant(5.0)
P = tf.constant(100.0)

# We specify the initial values that our lower and upper bounds will be when initialised.
# Obviously the ultimate success of this algorithm depends on decent start points
a = tf.Variable(-10.0)
b = tf.Variable(10.0)
 
# We expect a floating number to be inserted into the graph
v_target = tf.placeholder("float")
 
# Remember the following operations are definitions,
# none are carried out until an operation is evaluated in a session!
y = (a+b)/2
v_guess = C*tf.exp(-0.5*y) + C*tf.exp(-y) + C*tf.exp(-1.5*y) + (C + P)*tf.exp(-2*y)
 
# Operations to set temporary values (a_ and b_) intended to be the next values of a and b.
# e.g. if the guess results in a v greater than the target v,
# we will set a_ to be the current value of y
a_ = tf.where(v_guess > v_target, y, a)
b_ = tf.where(v_guess < v_target, y, b)
 
# The last stage of our graph is to assign the two temporary vals to our variables
step = tf.group(a.assign(a_), b.assign(b_))

Jadi sekarang kita memiliki daftar operasi dan variabel, di mana salah satunya dapat dievaluasi dalam sesi tertentu. Beberapa operasi ini bergantung pada operasi lain untuk dijalankan, sehingga menjalankan, katakanlah, v_guess akan memicu reaksi berantai untuk mengevaluasi tensor lain, seperti C dan P, terlebih dahulu.

Beberapa operasi ini bergantung pada placeholder yang memerlukan nilai yang harus ditentukan, jadi bagaimana kita sebenarnya memberikan nilai itu?

Ini dilakukan melalui argumen feed_dict dalam fungsi run itu sendiri.

Jika kita ingin mengevaluasi a_, kita memasukkan nilai untuk placeholder v_target kita, seperti ini :

sess.run(a_, feed_dict={v_target: 100})

memberikan kita hasil 0.0.

Masukkan nilai v_target sebesar 130 dan kita mendapatkan -10.0.

Ini adalah operasi "step" kita yang sebenarnya memerlukan semua operasi lain untuk dilakukan sebagai prasyarat dan pada kenyataannya menjalankan seluruh grafik. Ini juga merupakan operasi yang benar-benar mengubah keadaan sesungguhnya di seluruh sesi kita. Oleh karena itu, semakin kita menjalankan langkah ini, semakin kita secara bertahap memajukan variabel kita a dan b menuju nilai y yang sebenarnya.

Jadi, katakanlah nilai v dalam persamaan kita sama dengan 95. Mari buat sesi dan jalankan grafik kita di atasnya sebanyak 100 kali.

# Set up a session and initialize variables
sess = tf.Session()
tf.global_variables_initializer().run()
# Run the step operation (and therefore whole graph) 100 times
for i in range (100):
    sess.run(step, feed_dict={v_target:95})

Jika kita mengevaluasi tensor y sekarang, kita mendapatkan sesuatu yang menyerupai jawaban yang diinginkan.

print(sess.run(y)) # 0.125163

3. Neural Network

Sekarang bahwa kita memahami mekanika TensorFlow, kita dapat menggabungkannya dengan beberapa operasi pembelajaran mesin tambahan yang ada di TensorFlow untuk melatih jaringan saraf sederhana.

Di sini, kita ingin mengklasifikasikan titik data pada sistem koordinat 2D tergantung pada apakah mereka berada dalam wilayah tertentu—sebuah lingkaran dengan radius 0.5 yang berpusat pada asal.

Tentu saja, ini dapat diverifikasi secara konkret dengan hanya memeriksa untuk suatu titik tertentu (a,b) apakah a^2 + b^2 < 0.5, tetapi untuk tujuan eksperimen pembelajaran mesin ini, kita ingin menggunakan set pelatihan: serangkaian titik acak dan apakah mereka berada dalam wilayah yang dimaksudkan. Berikut adalah salah satu cara membuatnya :

import numpy as np
NO_OF_RANDOM_POINTS = 100
CIRCLE_RADIUS = 0.5
random_spots = np.random.rand(NO_OF_RANDOM_POINTS, 2) * 2 - 1
is_inside_circle = (np.power(random_spots[:,0],2) + np.power(random_spots[:,1],2) < CIRCLE_RADIUS).astype(int)

Kita akan membuat jaringan saraf dengan karakteristik berikut :

• Terdiri dari lapisan input dengan dua node, di mana kita memberi makan serangkaian vektor dua dimensi kita yang terkandung dalam "random_spots". Ini akan diwakili oleh suatu placeholder yang menunggu data pelatihan.
• Lapisan output juga akan memiliki dua node, sehingga kita perlu memberi makan serangkaian label pelatihan kita ("is_inside_circle") ke dalam placeholder untuk skalar, dan kemudian mengonversi nilai-nilai itu menjadi vektor dua dimensi satu-hot.
• Kita akan memiliki satu lapisan tersembunyi yang terdiri dari tiga node, sehingga kita perlu menggunakan variabel untuk matriks bobot dan vektor bias kita, karena ini adalah nilai-nilai yang perlu disempurnakan saat melakukan pelatihan.

Sekarang, kita tentukan operasi grafik untuk jaringan saraf. Kita akan menggunakan arsitektur sederhana dengan satu lapisan tersembunyi dan aktivasi softmax untuk lapisan output. Mari atur placeholder, variabel, dan operasi :

INPUT_LAYER_SIZE = 2
HIDDEN_LAYER_SIZE = 3
OUTPUT_LAYER_SIZE = 2
 
# Starting values for weights and biases are drawn randomly and uniformly from  [-1, 1]
# For example W1 is a matrix of shape 2x3
W1 = tf.Variable(tf.random_uniform([INPUT_LAYER_SIZE, HIDDEN_LAYER_SIZE], -1, 1))
b1 = tf.Variable(tf.random_uniform([HIDDEN_LAYER_SIZE], -1, 1))
W2 = tf.Variable(tf.random_uniform([HIDDEN_LAYER_SIZE, OUTPUT_LAYER_SIZE], -1, 1))
b2 = tf.Variable(tf.random_uniform([OUTPUT_LAYER_SIZE], -1, 1))
# Specifying that the placeholder X can expect a matrix of 2 columns (but any number of rows)
# representing random spots
X = tf.placeholder(tf.float32, [None, INPUT_LAYER_SIZE])
# Placeholder Y can expect integers representing whether corresponding point is in the circle
# or not (no shape specified)
Y = tf.placeholder(tf.uint8)
# An op to convert to a one hot vector
onehot_output = tf.one_hot(Y, OUTPUT_LAYER_SIZE)

Untuk melengkapi definisi grafik kami, kami mendefinisikan beberapa operasi yang akan membantu kami melatih variabel untuk mencapai pengklasifikasi yang lebih baik. Ini termasuk perhitungan matriks, fungsi aktivasi, dan pengoptimal.

LEARNING_RATE = 0.01
# Op to perform matrix calculation X*W1 + b1
hidden_layer = tf.add(tf.matmul(X, W1), b1)
# Use sigmoid activation function on the outcome
activated_hidden_layer = tf.sigmoid(hidden_layer)
# Apply next weights and bias (W2, b2) to hidden layer and then apply softmax function
# to get our output layer (each vector adding up to 1)
output_layer = tf.nn.softmax(tf.add(tf.matmul(activated_hidden_layer, W2), b2))
# Calculate cross entropy for our loss function
loss = -tf.reduce_sum(onehot_output * tf.log(output_layer))
# Use gradient descent optimizer at specified learning rate to minimize value given by loss tensor
train_step = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(loss)

Setelah menyiapkan grafik, saatnya menyiapkan sesi dan menjalankan "train_step" (yang juga menjalankan op apa pun yang diperlukan). Beberapa dari operasi ini menggunakan placeholder, jadi nilai untuk itu perlu diberikan. Langkah pelatihan ini mewakili satu epoch dalam algoritma pembelajaran kita dan, sebagai contoh, diulang selama jumlah epoch yang ingin kita jalankan. Kita dapat menjalankan bagian lain dari grafik, seperti tensor "loss" untuk tujuan informatif.

EPOCH_COUNT = 1000
sess = tf.Session()
tf.global_variables_initializer().run()
for i in range(EPOCH_COUNT):
    if i%100 == 0:
        print('Loss after %d runs: %f' % (i, sess.run(loss, feed_dict={X: random_spots, Y: is_inside_circle})))
    sess.run(train_step, feed_dict={X: random_spots, Y: is_inside_circle})
print('Final loss after %d runs: %f' % (i, sess.run(loss, feed_dict={X: random_spots, Y: is_inside_circle})))

Setelah kita melatih algoritmenya, kita dapat memasukkan suatu titik dan mendapatkan keluaran dari jaringan saraf seperti ini :

sess.run(output_layer, feed_dict={X: [[1, 1]]}) # Hopefully something close to [1, 0]
sess.run(output_layer, feed_dict={X: [[0, 0]]}) # Hopefully something close to [0, 1]

Kita dapat mengklasifikasikan suatu titik di luar lingkaran jika anggota pertama dari vektor keluaran lebih besar dari 0.5, sebaliknya di dalam.

[Untuk selengkapnya, silakan baca dan klik di sini (Toptal.com).]

Untuk melihat Tutorial lainnya dan lebih jelasnya tentang TensorFlow, silakan lihat Video-video YouTube di bawah ini.

Untuk selengkapnya mengenai Instalasi TensorFlow, silakan lihat di sini (Dokumentasi dari TensorFlow) :

https://www.tensorflow.org/install/pip?hl=id

https://www.tensorflow.org/install?hl=id

Itulah Penjelasan dan Tutorial Cara Install TensorFlow.

Terima Kasih 😄😘👌👍 :)

Wassalamu‘alaikum wr. wb.