tensorflow_cookbook

Tensorflow Machine Learning Cookbook

Buku penerbitan paket

Oleh Nick McClure

==================

Membangun:

==================

Daftar isi

• Bab 1: Memulai dengan TensorFlow
• CH 2: Cara Tensorflow
• Bab 3: Regresi linier
• Bab 4: Dukungan mesin vektor
• Bab 5: Metode tetangga terdekat
• Bab 6: Jaringan Saraf
• Bab 7: Pemrosesan Bahasa Alami
• Bab 8: Jaringan Saraf Konvolusional
• Bab 9: Jaringan Saraf Berulang
• Bab 10: Membawa Tensorflow ke Produksi
• Bab 11: Lebih lanjut dengan TensorFlow

---

Bab 1: Memulai dengan TensorFlow

Bab ini bermaksud untuk memperkenalkan objek dan konsep utama dalam TensorFlow. Kami juga memperkenalkan cara mengakses data untuk sisa buku ini dan menyediakan sumber daya tambahan untuk belajar tentang TensorFlow.

1. Garis besar algoritma TF

• Di sini kami memperkenalkan TensorFlow dan garis besar umum tentang cara kerja algoritma TensorFlow.

2. Membuat dan menggunakan tensor

• Cara membuat dan menginisialisasi tensor di tensorflow. Kami juga menggambarkan bagaimana operasi ini muncul di Tensorboard.

3. Menggunakan variabel dan placeholder

• Cara membuat dan menggunakan variabel dan placeholder di TensorFlow. Kami juga menggambarkan bagaimana operasi ini muncul di Tensorboard.

4. Bekerja dengan matriks

• Memahami bagaimana TensorFlow dapat bekerja dengan matriks sangat penting untuk memahami bagaimana algoritma bekerja.

5. Mendeklarasikan operasi

• Cara menggunakan berbagai operasi matematika di TensorFlow.

6. Menerapkan fungsi aktivasi

• Fungsi aktivasi adalah fungsi unik yang telah dibangun TensorFlow untuk Anda gunakan dalam algoritma.

7. Bekerja dengan Sumber Data

• Di sini kami menunjukkan cara mengakses semua berbagai sumber data yang diperlukan dalam buku ini. Ada juga tautan yang menggambarkan sumber data dan dari mana asalnya.

8. Sumber daya tambahan

• Sebagian besar sumber daya dan kertas resmi. Makalah adalah makalah tensorflow atau sumber belajar yang mendalam.

CH 2: Cara Tensorflow

Setelah kami menetapkan objek dan metode dasar di TensorFlow, kami sekarang ingin membuat komponen yang membentuk algoritma TensorFlow. Kami mulai dengan memperkenalkan grafik komputasi, dan kemudian pindah ke fungsi kerugian dan perambatan kembali. Kami berakhir dengan membuat classifier sederhana dan kemudian menunjukkan contoh mengevaluasi algoritma regresi dan klasifikasi.

1. Satu operasi sebagai grafik komputasi

• Kami menunjukkan cara membuat operasi pada grafik komputasi dan cara memvisualisasikannya menggunakan Tensorboard.

2. Layering Operasi bersarang

• Kami menunjukkan cara membuat beberapa operasi pada grafik komputasi dan cara memvisualisasikannya menggunakan Tensorboard.

3. Bekerja dengan banyak lapisan

• Di sini kami memperluas penggunaan grafik komputasi untuk membuat banyak lapisan dan menunjukkan bagaimana mereka muncul di Tensorboard.

4. Menerapkan fungsi kerugian

• Untuk melatih model, kita harus dapat mengevaluasi seberapa baik kinerjanya. Ini diberikan oleh fungsi kerugian. Kami merencanakan berbagai fungsi kerugian dan berbicara tentang manfaat dan keterbatasan beberapa orang.

5. Menerapkan propagasi kembali

• Di sini kami menunjukkan cara menggunakan fungsi kerugian untuk beralih melalui data dan kembali menyebarkan kesalahan untuk regresi dan klasifikasi.

6. Bekerja dengan pelatihan stokastik dan batch

• TensorFlow memudahkan untuk menggunakan pelatihan batch dan stokastik. Kami menunjukkan cara mengimplementasikan keduanya dan berbicara tentang manfaat dan keterbatasan masing -masing.

7. Menggabungkan semuanya bersama -sama

• Kami sekarang menggabungkan semuanya bersama -sama yang telah kami pelajari dan membuat classifier sederhana.

8. Mengevaluasi model

• Model apa pun hanya sebagus evaluasi. Di sini kami menunjukkan dua contoh (1) mengevaluasi algoritma regresi dan (2) algoritma klasifikasi.

Bab 3: Regresi linier

Di sini kami menunjukkan cara menerapkan berbagai teknik regresi linier di TensorFlow. Dua bagian pertama menunjukkan cara melakukan pemecahan regresi linier matriks standar dalam tensorflow. Enam bagian yang tersisa menggambarkan cara menerapkan berbagai jenis regresi menggunakan grafik komputasi di TensorFlow.

1. Menggunakan metode matriks terbalik

• Cara memecahkan regresi 2D dengan matriks terbalik dalam tensorflow.

2. Menerapkan metode dekomposisi

• Memecahkan regresi linier 2D dengan dekomposisi Cholesky.

3. Mempelajari cara tensorflow regresi linier

• Regresi linier iterasi melalui grafik komputasi dengan kehilangan L2.

4. Memahami fungsi kerugian dalam regresi linier

• Kehilangan L2 vs L1 dalam regresi linier. Kami berbicara tentang manfaat dan keterbatasan keduanya.

5. Menerapkan Regresi Deming (Total Regresi)

• Deming (total) regresi diterapkan di TensorFlow dengan mengubah fungsi kerugian.

6. Menerapkan regresi Lasso dan Ridge

• Regresi Lasso dan Ridge adalah cara mengatur koefisien. Kami menerapkan keduanya di TensorFlow melalui mengubah fungsi kerugian.

7. Menerapkan regresi bersih elastis

• Elastic Net adalah teknik regularisasi yang menggabungkan kehilangan L2 dan L1 untuk koefisien. Kami menunjukkan cara mengimplementasikannya di TensorFlow.

8. Menerapkan regresi logistik

• Kami menerapkan regresi logistik dengan menggunakan fungsi aktivasi dalam grafik komputasi kami.

Bab 4: Dukungan mesin vektor

Bab ini menunjukkan cara mengimplementasikan berbagai metode SVM dengan TensorFlow. Kami pertama -tama membuat SVM linier dan juga menunjukkan bagaimana hal itu dapat digunakan untuk regresi. Kami kemudian memperkenalkan kernel (kernel Gaussian RBF) dan menunjukkan cara menggunakannya untuk membagi data non-linear. Kami selesai dengan implementasi multi-dimensi SVM non-linear untuk bekerja dengan beberapa kelas.

1. Perkenalan

• Kami memperkenalkan konsep SVM dan bagaimana kami akan menerapkannya dalam kerangka TensorFlow.

2. Bekerja dengan SVM linier

• Kami membuat SVM linier untuk memisahkan I. setosa berdasarkan panjang sepal dan lebar pedal dalam set data IRIS.

3. Pengurangan regresi linier

• Jantung SVM memisahkan kelas dengan garis. Kami sedikit mengubah algoritma untuk melakukan regresi SVM.

4. Bekerja dengan kernel di tensorflow

• Untuk memperluas SVM ke dalam data non-linear, kami menjelaskan dan menunjukkan cara mengimplementasikan kernel yang berbeda di TensorFlow.

5. Menerapkan SVM non-linear

• Kami menggunakan kernel Gaussian (RBF) untuk memisahkan kelas non-linear.

6. Menerapkan SVM multi-kelas

• SVM secara inheren adalah prediktor biner. Kami menunjukkan cara memperluasnya dalam strategi satu-VS-semua di TensorFlow.

Bab 5: Metode tetangga terdekat

Metode tetangga terdekat adalah algoritma ML yang sangat populer. Kami menunjukkan cara mengimplementasikan tetangga K-Nearest, tetangga K-Nearest tertimbang, dan tetangga K-Nearest dengan fungsi jarak campuran. Dalam bab ini kami juga menunjukkan cara menggunakan jarak levenshtein (jarak edit) di tensorflow, dan menggunakannya untuk menghitung jarak antar string. Kami mengakhiri bab ini dengan menunjukkan cara menggunakan tetangga K-Nearest untuk prediksi kategori dengan pengakuan digit tulisan tangan MNIST.

1. Perkenalan

• Kami memperkenalkan konsep dan metode yang diperlukan untuk melakukan tetangga K-Nearest di TensorFlow.

2. Bekerja dengan tetangga terdekat

• Kami membuat algoritma tetangga terdekat yang mencoba memprediksi nilai perumahan (regresi).

3. Bekerja dengan jarak berbasis teks

• Untuk menggunakan fungsi jarak pada teks, kami menunjukkan cara menggunakan jarak edit di TensorFlow.

4. Menghitung fungsi jarak pencampuran

• Di sini kami menerapkan penskalaan fungsi jarak dengan standar deviasi fitur input untuk tetangga k-nearest.

5. Menggunakan pencocokan alamat

• Kami menggunakan fungsi jarak jauh untuk mencocokkan alamat. Kami menggunakan jarak numerik untuk kode zip, dan string edit jarak untuk nama jalan. Nama jalan diizinkan memiliki kesalahan ketik.

6. Menggunakan tetangga terdekat untuk pengenalan gambar

• Koleksi gambar digit MNIST adalah kumpulan data yang bagus untuk ilustrasi cara melakukan tetangga K-Nearest untuk tugas klasifikasi gambar.

Bab 6: Jaringan Saraf

Jaringan saraf sangat penting dalam pembelajaran mesin dan semakin populer karena terobosan utama dalam masalah yang belum terpecahkan sebelumnya. Kita harus mulai dengan memperkenalkan jaringan saraf 'dangkal', yang sangat kuat dan dapat membantu kita meningkatkan hasil algoritma ML sebelumnya. Kami mulai dengan memperkenalkan unit NN yang sangat dasar, gerbang operasional. Kami secara bertahap menambahkan lebih banyak dan lebih banyak ke jaringan saraf dan mengakhiri dengan melatih model untuk bermain tic-tac-toe.

1. Perkenalan

• Kami memperkenalkan konsep jaringan saraf dan bagaimana TensorFlow dibangun untuk dengan mudah menangani algoritma ini.

2. Menerapkan gerbang operasional

• Kami menerapkan gerbang operasional dengan satu operasi. Kemudian kami menunjukkan cara memperluas ini ke beberapa operasi bersarang.

3. Bekerja dengan Gerbang dan Fungsi Aktivasi

• Sekarang kita harus memperkenalkan fungsi aktivasi di gerbang. Kami menunjukkan bagaimana fungsi aktivasi yang berbeda beroperasi.

4. Menerapkan jaringan saraf satu lapisan

• Kami memiliki semua bagian untuk mulai menerapkan jaringan saraf pertama kami. Kami melakukannya di sini dengan regresi pada set data IRIS.

5. Menerapkan lapisan yang berbeda

• Bagian ini memperkenalkan lapisan konvolusi dan lapisan max-pool. Kami menunjukkan cara rantai ini bersama -sama dalam contoh 1D dan 2D dengan lapisan yang sepenuhnya terhubung juga.

6. Menggunakan jaringan saraf multi-lapisan

• Di sini kami menunjukkan cara memfungsikan berbagai lapisan dan variabel untuk jaringan saraf multi-lapisan yang lebih bersih.

7. Meningkatkan prediksi model linier

• Kami menunjukkan bagaimana kami dapat meningkatkan konvergensi regresi logistik kami sebelumnya dengan satu set lapisan tersembunyi.

8. Belajar bermain tic-tac-toe

• Mengingat satu set papan tic-tac-toe dan gerakan optimal yang sesuai, kami melatih model klasifikasi jaringan saraf untuk dimainkan. Di akhir skrip, Anda dapat mencoba bermain melawan model yang terlatih.

Bab 7: Pemrosesan Bahasa Alami

Natural Language Processing (NLP) adalah cara memproses informasi tekstual ke dalam ringkasan, fitur, atau model numerik. Dalam bab ini kita akan memotivasi dan menjelaskan cara terbaik berurusan dengan teks di TensorFlow. Kami menunjukkan cara menerapkan 'tas-of-word' klasik dan menunjukkan bahwa mungkin ada cara yang lebih baik untuk menanamkan teks berdasarkan masalah yang dihadapi. Ada embeddings jaringan saraf yang disebut Word2Vec (CBOW dan Skip-Gram) dan DOC2VEC. Kami menunjukkan cara menerapkan semua ini di TensorFlow.

1. Perkenalan

• Kami memperkenalkan metode untuk mengubah teks menjadi vektor numerik. Kami memperkenalkan fitur 'embedding' tensorflow juga.

2. Bekerja dengan tas-of-words

• Di sini kami menggunakan TensorFlow untuk melakukan satu-panas dari kata-kata yang disebut Bag-of-Words. Kami menggunakan metode ini dan regresi logistik untuk memprediksi apakah pesan teks adalah spam atau ham.

3. Menerapkan TF-IDF

• Kami mengimplementasikan frekuensi teks - Frekuensi Dokumen Terbalik (TFIDF) dengan kombinasi Sci -Kit Learn dan TensorFlow. Kami melakukan regresi logistik pada vektor TFIDF untuk meningkatkan prediksi pesan teks spam/ham kami.

4. Bekerja dengan Skip-Gram

• Implementasi pertama kami dari Word2Vec berjudul, "Skip-Gram" pada database ulasan film.

5. Bekerja dengan CBOW

• Selanjutnya, kami mengimplementasikan bentuk Word2Vec yang disebut, "CBOW" (tas kata -kata kontinu) pada database ulasan film. Kami juga memperkenalkan metode untuk menyimpan dan memuat embeddings kata.

6. Menerapkan contoh Word2Vec

• Dalam contoh ini, kami menggunakan embeddings Word Word yang disimpan sebelumnya untuk meningkatkan regresi logistik TF-IDF kami dari sentimen ulasan film.

7. Melakukan analisis sentimen dengan doc2vec

• Di sini, kami memperkenalkan metode DOC2VEC (gabungan DOC dan Word Embeddings) untuk meningkatkan model logistik dari sentimen ulasan film.

Bab 8: Jaringan Saraf Konvolusional

Convolutional Neural Networks (CNNs) adalah cara untuk mendapatkan jaringan saraf untuk menangani data gambar. CNN memperoleh nama mereka dari penggunaan lapisan konvolusional yang menerapkan filter ukuran tetap di gambar yang lebih besar, mengenali pola di bagian mana pun dari gambar. Ada banyak alat lain yang mereka gunakan (max-pooling, dropout, dll ...) yang kami tunjukkan cara menerapkan dengan TensorFlow. Kami juga menunjukkan cara melatih kembali arsitektur yang ada dan mengambil CNN lebih jauh dengan Stylenet dan Deep Dream.

1. Perkenalan

• Kami memperkenalkan Convolutional Neural Networks (CNN), dan bagaimana kami dapat menggunakannya di TensorFlow.

2. Menerapkan CNN sederhana.

• Di sini, kami menunjukkan cara membuat arsitektur CNN yang berkinerja baik pada tugas pengenalan digit MNIST.

3. Menerapkan CNN tingkat lanjut.

• Dalam contoh ini, kami menunjukkan cara mereplikasi arsitektur untuk tugas pengenalan gambar CIFAR-10.

4. Melatih kembali arsitektur yang ada.

• Kami menunjukkan cara mengunduh dan mengatur data CIFAR-10 untuk tutorial TensorFlow Retraining/Fine-tuning.

5. Menggunakan Stylenet/NeuralStyle.

• Dalam resep ini, kami menunjukkan implementasi dasar menggunakan stylenet atau neuralstyle.

6. Menerapkan mimpi yang mendalam.

• Skrip ini menunjukkan penjelasan baris demi baris tentang tutorial DeepDream TensorFlow. Diambil dari Deepdream di TensorFlow. Perhatikan bahwa kode di sini dikonversi ke Python 3.

Bab 9: Jaringan Saraf Berulang

Jaringan saraf berulang (RNNs) sangat mirip dengan jaringan saraf biasa kecuali bahwa mereka memungkinkan koneksi 'berulang', atau loop yang bergantung pada keadaan jaringan sebelumnya. Ini memungkinkan RNN untuk secara efisien menangani data berurutan, sedangkan jenis jaringan lain tidak bisa. Kami kemudian memotivasi penggunaan jaringan LSTM (memori jangka pendek panjang) sebagai cara mengatasi masalah RNN secara teratur. Kemudian kami menunjukkan betapa mudahnya menerapkan tipe RNN ini di TensorFlow.

1. Perkenalan

• Kami memperkenalkan jaringan saraf berulang dan bagaimana mereka dapat memakan urutan dan memprediksi target tetap (kategorikal/numerik) atau urutan lain (urutan ke urutan).

2. Menerapkan model RNN untuk prediksi spam

• Dalam contoh ini, kami membuat model RNN untuk meningkatkan prediksi teks spam/ham kami.

3. Menerapkan model LSTM untuk pembuatan teks

• Kami menunjukkan cara menerapkan RNN LSTM (memori jangka pendek) untuk generasi bahasa Shakespeare. (Kosakata Level Kata)

4. Menumpuk beberapa lapisan LSTM

• Kami menumpuk beberapa lapisan LSTM untuk meningkatkan generasi bahasa Shakespeare kami. (Kosakata Level Karakter)

5. Membuat Urutan untuk Model Terjemahan Urutan (SEQ2SEQ)

• Di sini, kami menggunakan model urutan-ke-urutan TensorFlow untuk melatih model terjemahan bahasa Inggris-Jerman.

6. Melatih ukuran kesamaan Siam

• Di sini, kami menerapkan RNN Siam untuk memprediksi kesamaan alamat dan menggunakannya untuk pencocokan catatan. Menggunakan RNN untuk pencocokan rekaman sangat fleksibel, karena kami tidak memiliki satu set kategori target tetap dan dapat menggunakan model terlatih untuk memprediksi kesamaan di seluruh alamat baru.

Bab 10: Membawa Tensorflow ke Produksi

Tentu saja ada lebih banyak TensorFlow daripada hanya membuat dan menyesuaikan model pembelajaran mesin. Setelah kami memiliki model yang ingin kami gunakan, kami harus memindahkannya ke arah penggunaan produksi. Bab ini akan memberikan tips dan contoh uji unit implementasi, menggunakan beberapa prosesor, menggunakan beberapa mesin (terdistribusi TensorFlow), dan selesai dengan contoh produksi penuh.

1. Menerapkan tes unit

• Kami menunjukkan cara mengimplementasikan berbagai jenis tes unit pada tensor (placeholder dan variabel).

2. Menggunakan beberapa pelaksana (perangkat)

• Cara menggunakan mesin dengan beberapa perangkat. Misalnya, mesin dengan CPU, dan satu atau lebih GPU.

3. Paralelisasi TensorFlow

• Cara mengatur dan menggunakan TensorFlow yang didistribusikan pada beberapa mesin.

4. Tips untuk Tensorflow dalam Produksi

• Berbagai tips untuk dikembangkan dengan TensorFlow

5. Contoh produksionalisasi tensorflow

• Kami menunjukkan cara mengambil model RNN untuk memprediksi ham/spam (dari bab 9, resep #2) dan memasukkannya ke dalam dua file tingkat produksi: pelatihan dan evaluasi.

Bab 11: Lebih lanjut dengan TensorFlow

Untuk mengilustrasikan betapa serbaguna TensorFlow, kami akan menunjukkan contoh tambahan dalam bab ini. Kami mulai dengan menunjukkan cara menggunakan papan tensorat logging/visualisasi. Kemudian kami menggambarkan cara melakukan pengelompokan K-means, menggunakan algoritma genetika, dan memecahkan sistem ODE.

1. Visualisasi Grafik Komputasi (dengan Tensorboard)

• Contoh menggunakan histogram, ringkasan skalar, dan membuat gambar di Tensorboard.

2. Bekerja dengan algoritma genetika

• Kami membuat algoritma genetika untuk mengoptimalkan individu (array 50 angka) menuju fungsi kebenaran dasar.

3. Clustering menggunakan k-means

• Cara menggunakan TensorFlow untuk melakukan pengelompokan K-means. Kami menggunakan set data IRIS, set K = 3, dan menggunakan K-Means untuk membuat prediksi.

4. Memecahkan Sistem Odes

• Di sini, kami menunjukkan cara menggunakan TensorFlow untuk memecahkan sistem ODES. Sistem yang menjadi perhatian adalah sistem Lotka-Volterra Predator-Prey.

5. Menggunakan hutan acak

• Kami mengilustrasikan cara menggunakan gradien TensorFlow meningkatkan regresi dan pohon klasifikasi.

6. Menggunakan TensorFlow dengan Keras

• Di sini kami menunjukkan cara menggunakan bangunan model sekuensial keras untuk jaringan saraf yang sepenuhnya terhubung dan model CNN dengan callback.