Pembelajaran Mendalam dengan Python: Panduan Pemula untuk Pembelajaran Mendalam

adalah salah satu topik Terpanas 2018-19 dan untuk alasan yang bagus. Ada begitu banyak kemajuan dalam Industri dimana telah tiba saatnya mesin atau Program Komputer benar-benar menggantikan Manusia. Ini Pembelajaran Mendalam dengan Python Artikel ini akan membantu Anda memahami apa itu Pembelajaran Mendalam dan Bagaimana transisi ini bisa terjadi. Saya akan membahas topik-topik berikut dalam artikel ini:

• Ilmu Data dan Komponennya
• Kebutuhan akan Pembelajaran Mendalam
• Apa itu Pembelajaran Mendalam?
• Perceptron dan Jaringan Syaraf Tiruan
• Aplikasi Deep Learning
• Mengapa Python untuk Deep Learning?
• Pembelajaran Mendalam dengan Python: Contoh Perceptron
• Pembelajaran Mendalam Dengan Python: Membuat Jaringan Neural Dalam

Ilmu Data dan Komponennya

Nah, Ilmu Data adalah sesuatu yang telah ada sejak lama. Ilmu data adalah ekstraksi pengetahuan dari data dengan menggunakan teknik dan algoritma yang berbeda.

adalah teknik yang memungkinkan mesin meniru perilaku manusia. Ide di balik AI cukup sederhana namun menarik, yaitu membuat mesin cerdas yang dapat mengambil keputusan sendiri. Selama bertahun-tahun, ada anggapan bahwa komputer tidak akan pernah bisa menyamai kekuatan otak manusia.

Dulu kami tidak memiliki cukup data dan daya komputasi, tetapi sekarang dengan Data besar muncul dan dengan munculnya GPU, Artificial Intelligence menjadi mungkin.

adalah bagian dari teknik AI yang menggunakan metode statistik untuk memungkinkan mesin menjadi lebih baik dengan pengalaman.

Pembelajaran mendalam adalah bagian dari ML yang membuat komputasi jaringan neural multi-lapisan menjadi layak. Ini menggunakan jaringan Neural untuk mensimulasikan pengambilan keputusan seperti manusia.

Kebutuhan akan Pembelajaran Mendalam

Langkah Menuju Kecerdasan Buatan adalah Pembelajaran Mesin. Pembelajaran Mesin adalah bagian dari AI dan didasarkan pada gagasan bahwa mesin harus diberi akses ke data, dan harus dibiarkan untuk belajar dan mengeksplorasi sendiri. Ini berkaitan dengan ekstraksi pola dari kumpulan data besar. Menangani kumpulan data yang besar bukanlah masalah.

• Algoritma Pembelajaran Mesin tidak dapat menangani Data Dimensi Tinggi - di mana kami memiliki sejumlah besar input dan output: sekitar ribuan dimensi. Penanganan dan pemrosesan jenis data seperti itu menjadi sangat kompleks dan menghabiskan banyak sumber daya. Ini disebut sebagai Kutukan Dimensi.

• Tantangan lain yang dihadapi adalah, untuk menentukan fitur yang akan diekstraksi . Ini memainkan peran penting dalam memprediksi hasil juga dalam mencapai akurasi yang lebih baik. Oleh karena itu, tanpa ekstraksi fitur, tantangan bagi pemrogram meningkat karena keefektifan algoritme sangat bergantung pada seberapa mendalam pemrogram tersebut.

Sekarang, di sinilah Deep Learning datang untuk menyelamatkan. Pembelajaran mendalam mampu menangani data berdimensi tinggi dan juga efisien dalam berfokus pada fitur yang tepat dengan dirinya sendiri.

Apa itu Pembelajaran Mendalam?

Pembelajaran Mendalam adalah bagian dari Pembelajaran Mesin yang menggunakan Algoritme Pembelajaran Mesin yang serupa untuk berlatih untuk mencapai akurasi yang lebih baik dalam kasus-kasus di mana yang pertama tidak berkinerja sesuai dengan sasaran. Pada dasarnya, Pembelajaran mendalam meniru cara otak kita berfungsi yaitu belajar dari pengalaman.

Seperti yang Anda ketahui,otak kita terdiri dari miliaran neuron yang memungkinkan kami melakukan hal-hal menakjubkan. Bahkan otak seorang anak kecil mampu memecahkan masalah kompleks yang sangat sulit dipecahkan bahkan dengan menggunakan Super-Komputer. Jadi, Bagaimana kita bisa mencapai fungsi yang sama dalam sebuah program? Sekarang, disinilah kami mengerti Neuron Buatan (Perceptron) dan Jaringan Syaraf Tiruan.

Perceptron dan Jaringan Syaraf Tiruan

Pembelajaran Mendalam mempelajari unit dasar otak yang disebut sel otak atau neuron. Sekarang, mari kita pahami fungsi neuron biologis dan bagaimana kita meniru fungsi ini dalam persepsi atau neuron buatan.

• Dendrit: Menerima sinyal dari neuron lain
• Tubuh Sel: Menjumlahkan semua input
• Akson: Ini digunakan untuk mengirimkan sinyal ke sel lain

Neuron Buatan atau a Perceptron adalah model linier yang digunakan untuk klasifikasi biner. Ini memodelkan neuron yang memiliki serangkaian input, yang masing-masing diberi bobot tertentu. Neuron menghitung beberapa fungsi ini tertimbang masukan dan memberikan keluaran.

fibonacci c ++ rekursif

Ini menerima input n (sesuai dengan setiap fitur). Kemudian menjumlahkan input tersebut, menerapkan transformasi dan menghasilkan output. Ini memiliki dua fungsi:

• Penjumlahan
• Transformasi (Aktivasi)

Bobot menunjukkan keefektifan masukan tertentu. Semakin banyak bobot input, semakin berdampak pada jaringan saraf . Di samping itu, Bias adalah parameter tambahan di Perceptron yang digunakan untuk menyesuaikan output bersama dengan jumlah bobot input ke neuron yang membantu model dengan cara yang paling sesuai untuk data yang diberikan.

Fungsi Aktivasi menerjemahkan masukan menjadi keluaran. Ini menggunakan ambang batas untuk menghasilkan keluaran. Ada banyak fungsi yang digunakan sebagai Fungsi Aktivasi, seperti:

• Linear atau Identitas
• Unit atau Langkah Biner
• Sigmoid atau Logistik
• Tanh
• ULT
• Softmax

Baik. jika menurut Anda Perceptron menyelesaikan masalah, maka Anda salah. Ada dua masalah utama:

• Perceptron Lapisan Tunggal tidak dapat mengklasifikasikan titik data yang dapat dipisahkan secara non-linear .
• Masalah kompleks, yang melibatkan banyak parameter tidak bisa diselesaikan dengan Single-Layer Perceptrons.

Pertimbangkan contoh di sini dan kompleksitas dengan parameter yang terlibat untuk mengambil Keputusan oleh tim pemasaran.

Satu Neuron, tidak dapat menerima begitu banyak masukan dan itulah sebabnya lebih dari satu neuron akan digunakan untuk memecahkan masalah ini. Neural Network benar-benar hanya a komposisi Perceptrons, dihubungkan dengan berbagai cara dan beroperasi pada fungsi aktivasi yang berbeda.

• Input Node memberikan informasi dari dunia luar ke jaringan dan bersama-sama disebut sebagai 'Lapisan Masukan'.
• Node Tersembunyi melakukan perhitungan dan mentransfer informasi dari node input ke node output. Kumpulan node tersembunyi membentuk 'Lapisan Tersembunyi'.
• Node keluaran secara kolektif disebut sebagai 'Lapisan Keluaran' dan bertanggung jawab atas penghitungan dan pengiriman informasi dari jaringan ke dunia luar.

Sekarang setelah Anda memiliki gambaran tentang bagaimana perceptron berperilaku, berbagai parameter yang terlibat, dan berbagai lapisan Jaringan Neural, Mari lanjutkan Pembelajaran Mendalam dengan Blog Python ini dan lihat beberapa aplikasi keren dari Pembelajaran Dalam.

Aplikasi Deep Learning

Ada berbagai aplikasi Pembelajaran Mendalam di Industri, berikut beberapa yang penting yang hadir dalam tugas Sehari-hari kita.

• Pengenalan suara

• Mesin penerjemah

• Pengenalan Wajah dan Pemberian Tag Otomatis

• Asisten Pribadi Virtual

• Mobil Mengemudi Sendiri

• Chatbots

Mengapa Python untuk Deep Learning?

• adalah salah satu alat yang memiliki atribut unik, menjadi a bahasa pemrograman tujuan umum sebagai makhluk mudah digunakan dalam hal komputasi analitis dan kuantitatif.
• Itu sangat mudah dimengerti
• Python adalah Diketik Secara Dinamis
• Besar
• Berbagai macam Perpustakaan untuk berbagai tujuan seperti Numpy, Seaborn, Matplotlib, Pandas, dan Scikit-learn

Sekarang cukup teori, Mari kita lihat bagaimana kita bisa memulai Pembelajaran Mendalam dengan Python dengan contoh kecil namun menarik.

Pembelajaran Mendalam Dengan Python: Contoh Perceptron

Sekarang saya yakin kalian pasti sudah terbiasa dengan cara kerja ' ATAU' gerbang. Outputnya adalah satu jika salah satu masukan juga satu.

apa arti transient di java

Oleh karena itu, Perceptron dapat digunakan sebagai pemisah atau garis keputusan yang membagi input set Gerbang OR, menjadi dua kelas:

Kelas 1: Input yang memiliki output 0 yang terletak di bawah garis keputusan.
Kelas 2: Input yang memiliki output 1 yang terletak di atas garis keputusan atau pemisah.

Sampai saat ini, kami memahami bahwa perceptron linier dapat digunakan untuk mengklasifikasikan kumpulan data masukan menjadi dua kelas. Tapi, bagaimana sebenarnya itu mengklasifikasikan data?

Secara matematis, perceptron dapat dianggap seperti persamaan Bobot, Input, dan Bias.

Langkah 1: Impor semua perpustakaan yang diperlukan

Di sini saya hanya akan mengimpor satu perpustakaan, yaitu. TensorFlow

impor tensorflow sebagai tf

Langkah 2: Tentukan Variabel Vektor untuk Input dan Output

Selanjutnya, kita perlu membuat variabel untuk menyimpan input, output, dan bias Perceptron.

train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]

Langkah 3: Tentukan Variabel Bobot

Di sini kita akan menentukan variabel tensor bentuk 3 × 1 untuk bobot kita dan menetapkan beberapa nilai acak pada awalnya.

w = tf.Variable (tf.random_normal ([3, 1], seed = 15))

Langkah 4: Tentukan placeholder untuk Input dan Output

Kita perlu mendefinisikan placeholder sehingga mereka dapat menerima input eksternal saat dijalankan.

x = tf.placeholder (tf.float32, [Tidak ada, 3]) y = tf.placeholder (tf.float32, [Tidak ada, 1])

Langkah 5: Hitung Output dan Fungsi Aktivasi

Seperti yang telah dibahas sebelumnya, masukan yang diterima oleh perceptron pertama kali dikalikan dengan bobot masing-masing dan kemudian, semua masukan yang diberi bobot ini dijumlahkan. Nilai yang dijumlahkan ini kemudian diumpankan ke aktivasi untuk mendapatkan hasil akhir.

keluaran = tf.nn.relu (tf.matmul (x, w))

Catatan: Dalam hal ini, saya telah menggunakan relu sebagai fungsi aktivasi saya. Anda bebas menggunakan salah satu fungsi aktivasi sesuai kebutuhan Anda.

Langkah 6: Hitung Biaya atau Kesalahan

Kita perlu menghitung Cost = Mean Squared Error yang tidak lain adalah kuadrat dari selisih keluaran perceptron dan keluaran yang diinginkan.

kerugian = tf.reduce_sum (tf.square (keluaran - y))

Langkah 7: Minimalkan Kesalahan

Tujuan dari perceptron adalah meminimalkan Kerugian atau Biaya atau Kesalahan. Jadi di sini kita akan menggunakan Gradient Descent Optimizer.

optimizer = tf.train.GradientDescentOptimizer (0,01) train = optimizer.minimize (loss)

Langkah 8: Inisialisasi semua variabel

Variabel hanya ditentukan dengan tf. Variabel. Jadi, kita perlu menginisialisasi variabel yang ditentukan.

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

Langkah 9: Melatih Perceptron dalam Iterasi

Kita perlu melatih perceptron kita yaitu memperbarui nilai bobot dan bias dalam iterasi berturut-turut untuk meminimalkan kesalahan atau kerugian. Di sini, saya akan melatih perceptron kita dalam 100 epoch.

untuk saya dalam kisaran (100): sess.run (kereta, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - loss - ', cost)

Langkah 10: Keluaran

……

……

cara menggunakan trim di java

Seperti yang Anda lihat di sini, kerugian dimulai pada 2.07 dan berakhir pada 0.27

.

Pembelajaran Mendalam Dengan Python: Membuat Jaringan Neural Dalam

Sekarang kita telah berhasil membuat perceptron dan melatihnya untuk gerbang OR. Mari lanjutkan artikel ini dan lihat bagaimana cara membuat Jaringan Neural kita sendiri dari Awal, di mana kita akan membuat Lapisan Masukan, Lapisan Tersembunyi, dan Lapisan Keluaran.

Kami akan menggunakan kumpulan data MNIST. Kumpulan data MNIST terdiri dari 60.000 pelatihan sampel dan 10.000 pengujian sampel gambar digit tulisan tangan. Gambar berukuran besar 28 × 28 piksel dan keluarannya bisa berada di antaranya 0-9 .

Tugas di sini adalah untuk melatih model yang dapat secara akurat mengidentifikasi digit yang ada pada gambar

Pertama, kita akan menggunakan import di bawah ini untuk membawa fungsi print dari Python 3 ke Python 2.6+. Pernyataan __future__ harus berada di dekat bagian atas file karena mereka mengubah hal-hal mendasar tentang bahasa, dan kompilator perlu mengetahuinya dari awal

dari __future__ import print_function

Berikut adalah kode dengan komentar di setiap langkah

# Impor data MNIST dari tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) impor tensorflow sebagai tf import matplotlib.pyplot sebagai plt # Parameter learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # Parameter Jaringan n_hidden_1 = 256 # Jumlah lapisan pertama fitur n_hidden_2 = 256 # Jumlah lapisan kedua fitur n_input = 784 # input data MNIST (bentuk img: 28 * 28) n_classes = 10 # kelas total MNIST ( 0-9 digit) # tf Input grafik x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Buat model def multilayer_perceptron (x, bobot , bias): # Lapisan tersembunyi dengan aktivasi RELU layer_1 = tf.add (tf.matmul (x, bobot ['h1']), bias ['b1']) layer_1 = tf.nn.relu (layer_1) # Lapisan tersembunyi dengan RELU activation layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']), bias ['b2']) layer_2 = tf.nn.relu (layer_2) # Lapisan keluaran dengan out_layer aktivasi linier = tf. matmul (lapisan _2, bobot ['out']) + bias ['out'] return out_layer # Menyimpan bobot lapisan & bobot bias = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} bias = {'b1': tf.Variable (tf. random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))} # Buat model pred = multilayer_perceptron (x, bobot, bias) # Tentukan kerugian dan biaya pengoptimal = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, label = y)) pengoptimal = tf.train.AdamOptimizer (learning_rate = learning_rate). minimalkan (biaya) # Menginisialisasi variabel init = tf.global_variables_initializer () #membuat daftar kosong untuk menyimpan riwayat biaya dan riwayat akurasi cost_history = [] akurasi_history = [] # Luncurkan grafik dengan tf.Session () as sess: sess.run (init ) # Siklus pelatihan untuk periode dalam rentang (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Ulangi semua batch untuk i dalam rentang (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Jalankan op optimasi (backprop) dan biaya op (untuk mendapatkan nilai kerugian) _, c = sess.run ([pengoptimal, biaya], feed_dict = {x: batch_x, y: batch_y}) # Hitung kerugian rata-rata avg_cost + = c / total_batch # Tampilkan log per langkah epoch jika epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Hitung akurasi akurasi = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = akurasi.eval ({x: mnist.test.images, y: mnist.test.labels}) #tambahkan akurasi ke daftar akurasi_history.append (acu_temp) #tambahkan riwayat biaya cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Pengoptimalan Selesai! ') #plot riwayat biaya plt.plot (riwayat_biaya) plt.show () #plot riwayat akurasi plt.plot (akurasi _history) plt.show () # Model uji correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Hitung akurasi akurasi = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Akurasi: ', akurasi.eval ({x: mnist.test.images, y: mnist.test.labels}))

Keluaran:

Sekarang dengan ini, kita sampai pada akhir artikel Pembelajaran Mendalam dengan Python ini. Saya harap Anda mendapatkan pemahaman tentang berbagai komponen Deep Learning, Bagaimana semuanya dimulai dan Bagaimana menggunakan Python kita dapat membuat perceptron sederhana dan Deep Neural Network.

Edureka's dikurasi oleh para profesional industri sesuai kebutuhan & permintaan industri. Anda akan menguasai konsep-konsep seperti fungsi SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) dan bekerja dengan pustaka seperti Keras & TFLearn. Kursus ini telah dikurasi secara khusus oleh pakar industri dengan studi kasus waktu nyata.

Ada pertanyaan untuk kami? Harap sebutkan di bagian komentar 'Pembelajaran Mendalam dengan Python' dan kami akan menghubungi Anda kembali.