Memulai TensorFlow: Tutorial Pembelajaran Mesin

TensorFlow adalah pustaka perangkat lunak sumber terbuka yang dibuat oleh Google yang digunakan untuk mengimplementasikan pembelajaran mesin dan sistem pembelajaran mendalam. Kedua nama ini berisi serangkaian algoritme canggih yang memiliki tantangan yang sama—untuk memungkinkan komputer mempelajari cara mengenali pola kompleks secara otomatis dan/atau membuat keputusan sebaik mungkin.

Jika Anda tertarik dengan detail tentang sistem ini, Anda dapat mempelajari lebih lanjut dari posting blog Toptal tentang pembelajaran mesin dan pembelajaran mendalam.

TensorFlow, pada intinya, adalah pustaka untuk pemrograman aliran data. Ini memanfaatkan berbagai teknik pengoptimalan untuk membuat perhitungan ekspresi matematika lebih mudah dan lebih berkinerja.

Beberapa fitur utama TensorFlow adalah:

• Efisien bekerja dengan ekspresi matematika yang melibatkan array multi-dimensi
• Dukungan yang baik dari jaringan saraf dalam dan konsep pembelajaran mesin
• Komputasi GPU/CPU di mana kode yang sama dapat dieksekusi pada kedua arsitektur
• Skalabilitas komputasi yang tinggi di seluruh mesin dan kumpulan data yang sangat besar

Bersama-sama, fitur-fitur ini menjadikan TensorFlow kerangka kerja yang sempurna untuk kecerdasan mesin pada skala produksi.

Dalam tutorial TensorFlow ini, Anda akan mempelajari cara menggunakan metode pembelajaran mesin yang sederhana namun canggih di TensorFlow dan bagaimana Anda dapat menggunakan beberapa library tambahannya untuk men-debug, memvisualisasikan, dan mengubah model yang dibuat dengannya.

Memasang TensorFlow

Kami akan menggunakan TensorFlow Python API, yang bekerja dengan Python 2.7 dan Python 3.3+. Versi GPU (khusus Linux) memerlukan Cuda Toolkit 7.0+ dan cuDNN v2+.

Kami akan menggunakan sistem manajemen ketergantungan paket Conda untuk menginstal TensorFlow. Conda memungkinkan kita untuk memisahkan beberapa lingkungan pada sebuah mesin. Anda dapat mempelajari cara menginstal Conda dari sini.

Setelah menginstal Conda, kita dapat membuat lingkungan yang akan kita gunakan untuk instalasi dan penggunaan TensorFlow. Perintah berikut akan membuat lingkungan kita dengan beberapa pustaka tambahan seperti NumPy, yang sangat berguna setelah kita mulai menggunakan TensorFlow.

Versi Python yang diinstal di dalam lingkungan ini adalah 2.7, dan kami akan menggunakan versi ini di artikel ini.

 conda create --name TensorflowEnv biopython

Untuk mempermudah, kami memasang biopython di sini, bukan hanya NumPy. Ini termasuk NumPy dan beberapa paket lain yang akan kita perlukan. Anda selalu dapat menginstal paket-paket yang Anda butuhkan menggunakan perintah conda install atau pip install .

Perintah berikut akan mengaktifkan lingkungan Conda yang dibuat. Kami akan dapat menggunakan paket yang diinstal di dalamnya, tanpa bercampur dengan paket yang diinstal secara global atau di beberapa lingkungan lain.

 source activate TensorFlowEnv

Alat instalasi pip adalah bagian standar dari lingkungan Conda. Kami akan menggunakannya untuk menginstal perpustakaan TensorFlow. Sebelum melakukan itu, langkah pertama yang baik adalah memperbarui pip ke versi terbaru, menggunakan perintah berikut:

 pip install --upgrade pip

Sekarang kita siap untuk menginstal TensorFlow, dengan menjalankan:

 pip install tensorflow

Pengunduhan dan pembuatan TensorFlow dapat memakan waktu beberapa menit. Pada saat penulisan, ini menginstal TensorFlow 1.1.0.

Grafik Aliran Data

Di TensorFlow, komputasi dijelaskan menggunakan grafik aliran data. Setiap simpul grafik mewakili turunan dari operasi matematika (seperti penambahan, pembagian, atau perkalian) dan setiap tepi adalah kumpulan data multi-dimensi (tensor) tempat operasi dilakukan.

Karena TensorFlow bekerja dengan grafik komputasi, grafik tersebut dikelola di mana setiap node mewakili pembuatan instance operasi di mana setiap operasi memiliki nol atau lebih input dan nol atau lebih output.

Tepi di TensorFlow dapat dikelompokkan dalam dua kategori: Tepi normal mentransfer struktur data (tensor) di mana dimungkinkan bahwa output dari satu operasi menjadi input untuk operasi lain dan tepi khusus, yang digunakan untuk mengontrol ketergantungan antara dua node untuk mengatur urutan operasi di mana satu node menunggu yang lain selesai.

Ekspresi Sederhana

Sebelum kita melanjutkan membahas elemen TensorFlow, pertama-tama kita akan melakukan sesi bekerja dengan TensorFlow, untuk memahami seperti apa program TensorFlow.

Mari kita mulai dengan ekspresi sederhana dan berasumsi bahwa, untuk beberapa alasan, kita ingin mengevaluasi fungsi y = 5*x + 13 dalam mode TensorFlow.

Dalam kode Python sederhana, itu akan terlihat seperti:

 x = -2.0 y = 5*x + 13 print y

yang memberi kita dalam hal ini hasil 3.0.

Sekarang kita akan mengubah ekspresi di atas menjadi istilah TensorFlow.

Konstanta

Di TensorFlow, konstanta dibuat menggunakan konstanta fungsi, yang memiliki constant(value, dtype=None, shape=None, name='Const', verify_shape=False) , di mana value adalah nilai konstanta aktual yang akan digunakan dalam perhitungan lebih lanjut, dtype adalah parameter tipe data (misalnya, float32/64, int8/16, dll.), shape adalah dimensi opsional, name adalah nama opsional untuk tensor, dan parameter terakhir adalah boolean yang menunjukkan verifikasi bentuk nilai.

Jika Anda membutuhkan konstanta dengan nilai tertentu di dalam model pelatihan Anda, maka objek constant dapat digunakan seperti pada contoh berikut:

 z = tf.constant(5.2, name="x", dtype=tf.float32)

Variabel

Variabel dalam TensorFlow adalah buffer dalam memori yang berisi tensor yang harus diinisialisasi secara eksplisit dan digunakan dalam grafik untuk mempertahankan status di seluruh sesi. Dengan hanya memanggil konstruktor variabel ditambahkan dalam grafik komputasi.

Variabel sangat berguna setelah Anda memulai dengan model pelatihan, dan digunakan untuk menyimpan dan memperbarui parameter. Nilai awal yang diteruskan sebagai argumen konstruktor mewakili tensor atau objek yang dapat dikonversi atau dikembalikan sebagai tensor. Itu berarti jika kita ingin mengisi variabel dengan beberapa nilai yang telah ditentukan atau acak untuk digunakan setelahnya dalam proses pelatihan dan diperbarui melalui iterasi, kita dapat mendefinisikannya dengan cara berikut:

 k = tf.Variable(tf.zeros([1]), name="k")

Cara lain untuk menggunakan variabel di TensorFlow adalah dalam penghitungan di mana variabel tersebut tidak dapat dilatih dan dapat ditentukan dengan cara berikut:

 k = tf.Variable(tf.add(a, b), trainable=False)

Sesi

Untuk benar-benar mengevaluasi node, kita harus menjalankan grafik komputasi dalam satu sesi.

Sesi merangkum kontrol dan status runtime TensorFlow. Sesi tanpa parameter akan menggunakan grafik default yang dibuat di sesi saat ini, jika tidak, kelas sesi menerima parameter grafik, yang digunakan dalam sesi tersebut untuk dieksekusi.

Di bawah ini adalah cuplikan kode singkat yang menunjukkan bagaimana istilah yang didefinisikan di atas dapat digunakan di TensorFlow untuk menghitung fungsi linier sederhana.

 import tensorflow as tf x = tf.constant(-2.0, name="x", dtype=tf.float32) a = tf.constant(5.0, name="a", dtype=tf.float32) b = tf.constant(13.0, name="b", dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) print session.run(y)

Menggunakan TensorFlow: Mendefinisikan Grafik Komputasi

Hal yang baik tentang bekerja dengan grafik aliran data adalah bahwa model eksekusi dipisahkan dari eksekusinya (pada CPU, GPU, atau beberapa kombinasi) di mana, setelah diimplementasikan, perangkat lunak di TensorFlow dapat digunakan pada CPU atau GPU di mana semua kerumitan terkait dengan kode eksekusi disembunyikan.

Grafik komputasi dapat dibangun dalam proses menggunakan library TensorFlow tanpa harus membuat instance objek Graph secara eksplisit.

Objek Graph di TensorFlow dapat dibuat sebagai hasil dari baris kode sederhana seperti c = tf.add(a, b) . Ini akan membuat simpul operasi yang mengambil dua tensor a dan b yang menghasilkan jumlah c sebagai output.

Grafik komputasi adalah proses built-in yang menggunakan perpustakaan tanpa perlu memanggil objek grafik secara langsung. Objek grafik di TensorFlow, yang berisi sekumpulan operasi dan tensor sebagai unit data, digunakan di antara operasi yang memungkinkan proses yang sama dan berisi lebih dari satu grafik di mana setiap grafik akan ditetapkan ke sesi yang berbeda. Misalnya, baris kode sederhana c = tf.add(a, b) akan membuat simpul operasi yang menggunakan dua tensor a dan b sebagai input dan menghasilkan jumlah c sebagai output.

TensorFlow juga menyediakan mekanisme feed untuk menambal tensor ke operasi apa pun dalam grafik, di mana feed menggantikan output operasi dengan nilai tensor. Data umpan diteruskan sebagai argumen dalam pemanggilan fungsi run() .

Placeholder adalah cara TensorFlow yang memungkinkan pengembang memasukkan data ke dalam grafik komputasi melalui placeholder yang terikat di dalam beberapa ekspresi. Tanda tangan dari placeholder adalah:

 placeholder(dtype, shape=None, name=None)

di mana dtype adalah jenis elemen dalam tensor dan dapat memberikan bentuk tensor yang akan diumpankan dan nama operasinya.

Jika bentuknya tidak dilewati, tensor ini dapat diumpankan dengan bentuk apa pun. Catatan penting adalah bahwa tensor placeholder harus diisi dengan data, jika tidak, pada saat eksekusi sesi dan jika bagian itu hilang, placeholder menghasilkan kesalahan dengan struktur berikut:

 InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'y' with dtype float

Keuntungan dari placeholder adalah mereka memungkinkan pengembang untuk membuat operasi, dan grafik komputasi secara umum, tanpa perlu menyediakan data terlebih dahulu untuk itu, dan data dapat ditambahkan dalam waktu proses dari sumber eksternal.

Mari kita ambil masalah sederhana mengalikan dua bilangan bulat x dan y dalam mode TensorFlow, di mana placeholder akan digunakan bersama dengan mekanisme feed melalui metode session run .

 import tensorflow as tf x = tf.placeholder(tf.float32, name="x") y = tf.placeholder(tf.float32, name="y") z = tf.multiply(x, y, name="z") with tf.Session() as session: print session.run(z, feed_dict={x: 2.1, y: 3.0})

Memvisualisasikan Grafik Komputasi dengan TensorBoard

TensorBoard adalah alat visualisasi untuk menganalisis grafik aliran data. Ini dapat berguna untuk mendapatkan pemahaman yang lebih baik tentang model pembelajaran mesin.

Dengan TensorBoard, Anda dapat memperoleh wawasan tentang berbagai jenis statistik tentang parameter dan detail tentang bagian grafik komputasi secara umum. Bukan hal yang aneh bahwa jaringan saraf yang dalam memiliki sejumlah besar node. TensorBoard memungkinkan developer mendapatkan wawasan tentang setiap node dan cara komputasi dijalankan selama runtime TensorFlow.

Sekarang mari kembali ke contoh kita dari awal tutorial TensorFlow ini di mana kita mendefinisikan fungsi linier dengan format y = a*x + b .

Untuk mencatat peristiwa dari sesi yang nantinya dapat digunakan di TensorBoard, TensorFlow menyediakan kelas FileWriter . Ini dapat digunakan untuk membuat file acara untuk menyimpan ringkasan di mana konstruktor menerima enam parameter dan terlihat seperti:

 __init__(logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None, filename_suffix=None)

di mana parameter logdir diperlukan, dan yang lainnya memiliki nilai default. Parameter grafik akan diteruskan dari objek sesi yang dibuat dalam program pelatihan. Kode contoh lengkap terlihat seperti:

 import tensorflow as tf x = tf.constant(-2.0, name="x", dtype=tf.float32) a = tf.constant(5.0, name="a", dtype=tf.float32) b = tf.constant(13.0, name="b", dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: merged = tf.summary.merge_all() // new writer = tf.summary.FileWriter("logs", session.graph) // new session.run(init) print session.run(y)

Kami menambahkan hanya dua baris baru. Kami menggabungkan semua ringkasan yang dikumpulkan dalam grafik default, dan FileWriter digunakan untuk membuang acara ke file seperti yang kami jelaskan di atas, masing-masing.

Setelah menjalankan program, kami memiliki file di log direktori, dan langkah terakhir adalah menjalankan tensorboard :

 tensorboard --logdir logs/

Sekarang TensorBoard dimulai dan berjalan pada port default 6006. Setelah membuka http://localhost:6006 dan mengklik item menu Graphs (terletak di bagian atas halaman), Anda akan dapat melihat grafik, seperti grafik pada gambar di bawah ini:

TensorBoard menandai konstanta dan simpul ringkasan simbol tertentu, yang dijelaskan di bawah ini.

Matematika dengan TensorFlow

Tensor adalah struktur data dasar di TensorFlow, dan mewakili tepi penghubung dalam grafik aliran data.

Tensor hanya mengidentifikasi array atau daftar multidimensi. Struktur tensor dapat diidentifikasi dengan tiga parameter: rank, shape, dan type.

• Rank: Mengidentifikasi jumlah dimensi tensor. Sebuah rank dikenal sebagai orde atau n-dimensi dari sebuah tensor, dimana sebagai contoh tensor rank 1 adalah vektor atau tensor rank 2 adalah matriks.
• Bentuk: Bentuk tensor adalah jumlah baris dan kolom yang dimilikinya.
• Tipe: Tipe data yang ditetapkan ke elemen tensor.

Untuk membangun tensor di TensorFlow, kita bisa membangun array n-dimensi. Ini dapat dilakukan dengan mudah menggunakan pustaka NumPy, atau dengan mengonversi larik n-dimensi Python menjadi tensor TensorFlow.

Untuk membangun tensor 1-d, kita akan menggunakan array NumPy, yang akan kita buat dengan meneruskan daftar Python bawaan.

 import numpy as np tensor_1d = np.array([1.45, -1, 0.2, 102.1])

Bekerja dengan array semacam ini mirip dengan bekerja dengan daftar Python bawaan. Perbedaan utama adalah bahwa array NumPy juga berisi beberapa properti tambahan, seperti dimensi, bentuk, dan tipe.

 > > print tensor1d [ 1.45 -1. 0.2 102.1 ] > > print tensor1d[0] 1.45 > > print tensor1d[2] 0.2 > > print tensor1d.ndim 1 > > print tensor1d.shape (4,) > > print tensor1d.dtype float64

Array NumPy dapat dengan mudah diubah menjadi tensor TensorFlow dengan fungsi tambahan convert_to_tensor, yang membantu pengembang mengonversi objek Python menjadi objek tensor. Fungsi ini menerima objek tensor, array NumPy, daftar Python, dan skalar Python.

 tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64)

Sekarang jika kita mengikat tensor kita ke sesi TensorFlow, kita akan dapat melihat hasil konversi kita.

 tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tensor) print session.run(tensor[0]) print session.run(tensor[1])

Keluaran:

 [ 1.45 -1. 0.2 102.1 ] 1.45 -1.0

Kita dapat membuat tensor 2-d, atau matriks, dengan cara yang serupa:

 tensor_2d = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_1 = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_2 = np.array(np.random.rand(4, 4), dtype='float32') m1 = tf.convert_to_tensor(tensor_2d) m2 = tf.convert_to_tensor(tensor_2d_1) m3 = tf.convert_to_tensor(tensor_2d_2) mat_product = tf.matmul(m1, m2) mat_sum = tf.add(m2, m3) mat_det = tf.matrix_determinant(m3) with tf.Session() as session: print session.run(mat_product) print session.run(mat_sum) print session.run(mat_det)

Operasi Tensor

Dalam contoh di atas, kami memperkenalkan beberapa operasi TensorFlow pada vektor dan matriks. Operasi melakukan perhitungan tertentu pada tensor. Perhitungan mana yang ditunjukkan pada tabel di bawah ini.

Operasi TensorFlow yang tercantum dalam tabel di atas berfungsi dengan objek tensor, dan dilakukan berdasarkan elemen. Jadi jika Anda ingin menghitung kosinus untuk vektor x, operasi TensorFlow akan melakukan perhitungan untuk setiap elemen dalam tensor yang diteruskan.

 tensor_1d = np.array([0, 0, 0]) tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tf.cos(tensor))

Keluaran:

 [ 1. 1. 1.]

Operasi Matriks

Operasi matriks sangat penting untuk model pembelajaran mesin, seperti regresi linier, karena sering digunakan di dalamnya. TensorFlow mendukung semua operasi matriks yang paling umum, seperti perkalian, transposisi, inversi, menghitung determinan, memecahkan persamaan linier, dan banyak lagi.

Selanjutnya, kami akan menjelaskan beberapa operasi matriks. Mereka cenderung menjadi penting ketika datang ke model pembelajaran mesin, seperti dalam regresi linier. Mari kita menulis beberapa kode yang akan melakukan operasi matriks dasar seperti perkalian, mendapatkan transpos, mendapatkan determinan, perkalian, sol, dan banyak lagi.

Di bawah ini adalah contoh dasar pemanggilan operasi ini.

 import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) m1 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m2 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m3 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m4 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m5 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m_tranpose = tf.transpose(m1) m_mul = tf.matmul(m1, m2) m_det = tf.matrix_determinant(m3) m_inv = tf.matrix_inverse(m4) m_solve = tf.matrix_solve(m5, [[1], [1], [1], [1]]) with tf.Session() as session: print session.run(m_tranpose) print session.run(m_mul) print session.run(m_inv) print session.run(m_det) print session.run(m_solve)

Mengubah Data

Pengurangan

TensorFlow mendukung berbagai jenis reduksi. Reduksi adalah operasi yang menghilangkan satu atau lebih dimensi dari sebuah tensor dengan melakukan operasi tertentu di seluruh dimensi tersebut. Daftar pengurangan yang didukung untuk versi TensorFlow saat ini dapat ditemukan di sini. Kami akan menyajikan beberapa di antaranya dalam contoh di bawah ini.

 import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert( np.array( [ (1, 2, 3), (4, 5, 6), (7, 8, 9) ]), tf.int32) bool_tensor = convert([(True, False, True), (False, False, True), (True, False, False)], tf.bool) red_sum_0 = tf.reduce_sum(x) red_sum = tf.reduce_sum(x, axis=1) red_prod_0 = tf.reduce_prod(x) red_prod = tf.reduce_prod(x, axis=1) red_min_0 = tf.reduce_min(x) red_min = tf.reduce_min(x, axis=1) red_max_0 = tf.reduce_max(x) red_max = tf.reduce_max(x, axis=1) red_mean_0 = tf.reduce_mean(x) red_mean = tf.reduce_mean(x, axis=1) red_bool_all_0 = tf.reduce_all(bool_tensor) red_bool_all = tf.reduce_all(bool_tensor, axis=1) red_bool_any_0 = tf.reduce_any(bool_tensor) red_bool_any = tf.reduce_any(bool_tensor, axis=1) with tf.Session() as session: print "Reduce sum without passed axis parameter: ", session.run(red_sum_0) print "Reduce sum with passed axis=1: ", session.run(red_sum) print "Reduce product without passed axis parameter: ", session.run(red_prod_0) print "Reduce product with passed axis=1: ", session.run(red_prod) print "Reduce min without passed axis parameter: ", session.run(red_min_0) print "Reduce min with passed axis=1: ", session.run(red_min) print "Reduce max without passed axis parameter: ", session.run(red_max_0) print "Reduce max with passed axis=1: ", session.run(red_max) print "Reduce mean without passed axis parameter: ", session.run(red_mean_0) print "Reduce mean with passed axis=1: ", session.run(red_mean) print "Reduce bool all without passed axis parameter: ", session.run(red_bool_all_0) print "Reduce bool all with passed axis=1: ", session.run(red_bool_all) print "Reduce bool any without passed axis parameter: ", session.run(red_bool_any_0) print "Reduce bool any with passed axis=1: ", session.run(red_bool_any)

Keluaran:

 Reduce sum without passed axis parameter: 45 Reduce sum with passed axis=1: [ 6 15 24] Reduce product without passed axis parameter: 362880 Reduce product with passed axis=1: [ 6 120 504] Reduce min without passed axis parameter: 1 Reduce min with passed axis=1: [1 4 7] Reduce max without passed axis parameter: 9 Reduce max with passed axis=1: [3 6 9] Reduce mean without passed axis parameter: 5 Reduce mean with passed axis=1: [2 5 8] Reduce bool all without passed axis parameter: False Reduce bool all with passed axis=1: [False False False] Reduce bool any without passed axis parameter: True Reduce bool any with passed axis=1: [ True True True]

Parameter pertama dari operator reduksi adalah tensor yang ingin kita reduksi. Parameter kedua adalah indeks dimensi di mana kita ingin melakukan pengurangan. Parameter itu opsional, dan jika tidak lulus, pengurangan akan dilakukan di semua dimensi.

Kita dapat melihat operasi reduce_sum. Kami melewati tensor 2-d, dan ingin menguranginya sepanjang dimensi 1.

Dalam kasus kami, jumlah yang dihasilkan adalah:

 [1 + 2 + 3 = 6, 4 + 5 + 6 = 15, 7 + 8 + 9 = 24]

Jika kita melewati dimensi 0, hasilnya adalah:

 [1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 18]

Jika kita tidak melewati sumbu apa pun, hasilnya hanyalah jumlah keseluruhan dari:

 1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 45

Semua fungsi reduksi memiliki antarmuka yang serupa dan tercantum dalam dokumentasi reduksi TensorFlow.

Segmentasi

Segmentasi adalah proses di mana salah satu dimensi adalah proses pemetaan dimensi ke indeks segmen yang disediakan, dan elemen yang dihasilkan ditentukan oleh baris indeks.

Segmentasi sebenarnya mengelompokkan elemen di bawah indeks berulang, jadi misalnya, dalam kasus kami, kami telah menyegmentasikan id [0, 0, 1, 2, 2] diterapkan pada tensor tens1 , artinya array pertama dan kedua akan ditransformasikan setelah segmentasi operasi (dalam penjumlahan kasus kami) dan akan mendapatkan array baru, yang terlihat seperti (2, 8, 1, 0) = (2+0, 5+3, 3-2, -5+5) . Elemen ketiga dalam tensor tens1 tidak tersentuh karena tidak dikelompokkan dalam indeks berulang apa pun, dan dua larik terakhir dijumlahkan dengan cara yang sama seperti yang terjadi pada grup pertama. Selain penjumlahan, TensorFlow mendukung product, mean, max, dan min.

 import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) seg_ids = tf.constant([0, 0, 1, 2, 2]) tens1 = convert(np.array([(2, 5, 3, -5), (0, 3, -2, 5), (4, 3, 5, 3), (6, 1, 4, 0), (6, 1, 4, 0)]), tf.int32) tens2 = convert(np.array([1, 2, 3, 4, 5]), tf.int32) seg_sum = tf.segment_sum(tens1, seg_ids) seg_sum_1 = tf.segment_sum(tens2, seg_ids) with tf.Session() as session: print "Segmentation sum tens1: ", session.run(seg_sum) print "Segmentation sum tens2: ", session.run(seg_sum_1)

 Segmentation sum tens1: [[ 2 8 1 0] [ 4 3 5 3] [12 2 8 0]] Segmentation sum tens2: [3 3 9]

Utilitas Urutan

Utilitas urutan mencakup metode seperti:

• fungsi argmin, yang mengembalikan indeks dengan nilai min melintasi sumbu tensor input,
• fungsi argmax, yang mengembalikan indeks dengan nilai maksimal melintasi sumbu tensor input,
• setdiff, yang menghitung perbedaan antara dua daftar angka atau string,
• di mana fungsi, yang akan mengembalikan elemen baik dari dua elemen yang dilewati x atau y, yang bergantung pada kondisi yang dilewati, atau
• fungsi unik, yang akan mengembalikan elemen unik dalam tensor 1-D.

Kami mendemonstrasikan beberapa contoh eksekusi di bawah ini:

 import numpy as np import tensorflow as tf def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert(np.array([ [2, 2, 1, 3], [4, 5, 6, -1], [0, 1, 1, -2], [6, 2, 3, 0] ])) y = convert(np.array([1, 2, 5, 3, 7])) z = convert(np.array([1, 0, 4, 6, 2])) arg_min = tf.argmin(x, 1) arg_max = tf.argmax(x, 1) unique = tf.unique(y) diff = tf.setdiff1d(y, z) with tf.Session() as session: print "Argmin = ", session.run(arg_min) print "Argmax = ", session.run(arg_max) print "Unique_values = ", session.run(unique)[0] print "Unique_idx = ", session.run(unique)[1] print "Setdiff_values = ", session.run(diff)[0] print "Setdiff_idx = ", session.run(diff)[1] print session.run(diff)[1]

Keluaran:

 Argmin = [2 3 3 3] Argmax = [3 2 1 0] Unique_values = [ 1. 2. 5. 3. 7.] Unique_idx = [0 1 2 3 4] Setdiff_values = [ 5. 3. 7.] Setdiff_idx = [2 3 4]

Pembelajaran Mesin dengan TensorFlow

Di bagian ini, kami akan menyajikan kasus penggunaan machine learning dengan TensorFlow. Contoh pertama adalah algoritma untuk mengklasifikasikan data dengan pendekatan kNN, dan yang kedua akan menggunakan algoritma regresi linier.

kNN

Algoritma pertama adalah k-Nearest Neighbors (kNN). Ini adalah algoritma pembelajaran terawasi yang menggunakan metrik jarak, misalnya jarak Euclidean, untuk mengklasifikasikan data terhadap pelatihan. Ini adalah salah satu algoritma paling sederhana, tetapi masih sangat kuat untuk mengklasifikasikan data. Kelebihan dari algoritma ini:

• Memberikan akurasi tinggi ketika model pelatihan cukup besar, dan
• Biasanya tidak sensitif terhadap outlier, dan kami tidak perlu memiliki asumsi tentang data.

Kekurangan dari algoritma ini:

• Komputasi mahal, dan
• Membutuhkan banyak memori di mana data rahasia baru perlu ditambahkan ke semua instance pelatihan awal.

Jarak yang akan kita gunakan dalam contoh kode ini adalah Euclidean, yang mendefinisikan jarak antara dua titik seperti ini:

Dalam rumus ini, n adalah jumlah dimensi ruang, x adalah vektor dari data pelatihan, dan y adalah titik data baru yang ingin kita klasifikasikan.

 import os import numpy as np import tensorflow as tf ccf_train_data = "train_dataset.csv" ccf_test_data = "test_dataset.csv" dataset_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../datasets')) ccf_train_filepath = os.path.join(dataset_dir, ccf_train_data) ccf_test_filepath = os.path.join(dataset_dir, ccf_test_data) def load_data(filepath): from numpy import genfromtxt csv_data = genfromtxt(filepath, delimiter=",", skip_header=1) data = [] labels = [] for d in csv_data: data.append(d[:-1]) labels.append(d[-1]) return np.array(data), np.array(labels) train_dataset, train_labels = load_data(ccf_train_filepath) test_dataset, test_labels = load_data(ccf_test_filepath) train_pl = tf.placeholder("float", [None, 28]) test_pl = tf.placeholder("float", [28]) knn_prediction = tf.reduce_sum(tf.abs(tf.add(train_pl, tf.negative(test_pl))), axis=1) pred = tf.argmin(knn_prediction, 0) with tf.Session() as tf_session: missed = 0 for i in xrange(len(test_dataset)): knn_index = tf_session.run(pred, feed_dict={train_pl: train_dataset, test_pl: test_dataset[i]}) print "Predicted class {} -- True class {}".format(train_labels[knn_index], test_labels[i]) if train_labels[knn_index] != test_labels[i]: missed += 1 tf.summary.FileWriter("../samples/article/logs", tf_session.graph) print "Missed: {} -- Total: {}".format(missed, len(test_dataset))

Dataset yang kita gunakan dalam contoh di atas adalah salah satu yang dapat ditemukan di bagian dataset Kaggle. Kami menggunakan yang berisi transaksi yang dilakukan oleh kartu kredit pemegang kartu Eropa. Kami menggunakan data tanpa pembersihan atau penyaringan dan sesuai deskripsi di Kaggle untuk dataset ini, sangat tidak seimbang. Dataset berisi 31 variabel: Waktu, V1, ..., V28, Jumlah, dan Kelas. Dalam contoh kode ini kami hanya menggunakan V1, …, V28 dan Kelas. Mengklasifikasikan transaksi yang curang dengan 1 dan yang tidak dengan 0.

Contoh kode sebagian besar berisi hal-hal yang kami jelaskan di bagian sebelumnya dengan pengecualian di mana kami memperkenalkan fungsi untuk memuat kumpulan data. Fungsi load_data(filepath) akan mengambil file CSV sebagai argumen dan akan mengembalikan Tuple dengan data dan label yang ditentukan dalam CSV.

Tepat di bawah fungsi itu, kami telah mendefinisikan placeholder untuk pengujian dan data terlatih. Data terlatih digunakan dalam model prediksi untuk menyelesaikan label untuk data masukan yang perlu diklasifikasikan. Dalam kasus kami, kNN menggunakan jarak Euclidian untuk mendapatkan label terdekat.

Tingkat kesalahan dapat dihitung dengan pembagian sederhana dengan nomor ketika pengklasifikasi terlewatkan dengan jumlah total contoh yang dalam kasus kami untuk dataset ini adalah 0,2 (yaitu, pengklasifikasi memberi kami label data yang salah untuk 20% dari data uji).

Regresi linier

Algoritma regresi linier mencari hubungan linier antara dua variabel. Jika kita melabeli variabel terikat sebagai y, dan variabel bebas sebagai x, maka kita mencoba mengestimasi parameter fungsi y = Wx + b .

Regresi linier adalah algoritma yang banyak digunakan di bidang ilmu terapan. Algoritme ini memungkinkan penambahan dalam implementasi dua konsep penting pembelajaran mesin: Fungsi biaya dan metode penurunan gradien untuk menemukan fungsi minimum.

Sebuah algoritma pembelajaran mesin yang diimplementasikan menggunakan metode ini harus memprediksi nilai y sebagai fungsi dari x dimana algoritma regresi linier akan menentukan nilai W dan b , yang sebenarnya tidak diketahui dan yang ditentukan di seluruh proses pelatihan. Fungsi biaya dipilih, dan biasanya kesalahan kuadrat rata-rata digunakan di mana penurunan gradien adalah algoritma optimasi yang digunakan untuk menemukan minimum lokal dari fungsi biaya.

Metode penurunan gradien hanya fungsi minimum lokal, tetapi dapat digunakan dalam pencarian minimum global dengan secara acak memilih titik awal baru setelah menemukan minimum lokal dan mengulangi proses ini berkali-kali. Jika jumlah minimum dari fungsi tersebut terbatas dan terdapat jumlah upaya yang sangat tinggi, maka ada kemungkinan besar bahwa pada titik tertentu minimum global terlihat. Beberapa detail lebih lanjut tentang teknik ini akan kami tinggalkan untuk artikel yang kami sebutkan di bagian pendahuluan.

 import tensorflow as tf import numpy as np test_data_size = 2000 iterations = 10000 learn_rate = 0.005 def generate_test_values(): train_x = [] train_y = [] for _ in xrange(test_data_size): x1 = np.random.rand() x2 = np.random.rand() x3 = np.random.rand() y_f = 2 * x1 + 3 * x2 + 7 * x3 + 4 train_x.append([x1, x2, x3]) train_y.append(y_f) return np.array(train_x), np.transpose([train_y]) x = tf.placeholder(tf.float32, [None, 3], name="x") W = tf.Variable(tf.zeros([3, 1]), name="W") b = tf.Variable(tf.zeros([1]), name="b") y = tf.placeholder(tf.float32, [None, 1]) model = tf.add(tf.matmul(x, W), b) cost = tf.reduce_mean(tf.square(y - model)) train = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost) train_dataset, train_values = generate_test_values() init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) for _ in xrange(iterations): session.run(train, feed_dict={ x: train_dataset, y: train_values }) print "cost = {}".format(session.run(cost, feed_dict={ x: train_dataset, y: train_values })) print "W = {}".format(session.run(W)) print "b = {}".format(session.run(b))

Keluaran:

 cost = 3.1083032809e-05 W = [[ 1.99049103] [ 2.9887135 ] [ 6.98754263]] b = [ 4.01742554]

Dalam contoh di atas, kami memiliki dua variabel baru, yang kami sebut cost dan train . Dengan dua variabel tersebut, kami mendefinisikan pengoptimal yang ingin kami gunakan dalam model pelatihan kami dan fungsi yang ingin kami minimalkan.

Pada akhirnya, parameter keluaran W dan b harus identik dengan yang didefinisikan dalam fungsi generate_test_values . Pada baris 17, kami sebenarnya mendefinisikan fungsi yang kami gunakan untuk menghasilkan titik data linier untuk dilatih di mana w1=2 , w2=3 , w3=7 dan b=4 . Regresi linier dari contoh di atas adalah multivariat dimana lebih dari satu variabel bebas digunakan.

Kesimpulan

Seperti yang dapat Anda lihat dari tutorial TensorFlow ini, TensorFlow adalah kerangka kerja yang kuat yang membuat bekerja dengan ekspresi matematika dan array multi-dimensi menjadi mudah—sesuatu yang secara fundamental diperlukan dalam pembelajaran mesin. Ini juga menghilangkan kerumitan dalam mengeksekusi grafik data dan penskalaan.

Seiring waktu, TensorFlow semakin populer dan sekarang digunakan oleh pengembang untuk memecahkan masalah menggunakan metode pembelajaran mendalam untuk pengenalan gambar, deteksi video, pemrosesan teks seperti analisis sentimen, dll. Seperti pustaka lainnya, Anda mungkin perlu waktu untuk membiasakan diri dengan konsep yang menjadi dasar TensorFlow. Dan, setelah Anda melakukannya, dengan bantuan dokumentasi dan dukungan komunitas, menampilkan masalah sebagai grafik data dan menyelesaikannya dengan TensorFlow dapat membuat pembelajaran mesin dalam skala besar menjadi proses yang tidak terlalu membosankan.