adalah salah satu topik Terhangat 2018-19 dan untuk alasan yang baik. Terdapat begitu banyak kemajuan dalam Industri di mana masanya telah tiba ketika mesin atau Program Komputer benar-benar menggantikan Manusia. Ini Pembelajaran mendalam dengan Python artikel akan membantu anda memahami apa sebenarnya Pembelajaran Dalam dan Bagaimana peralihan ini dimungkinkan. Saya akan membahas topik berikut dalam artikel ini:
- Sains Data dan Komponennya
- Keperluan untuk Pembelajaran Dalam
- Apa itu Pembelajaran Dalam?
- Rangkaian Neural Perceptron dan Buatan
- Aplikasi Pembelajaran Dalam
- Mengapa Python untuk Pembelajaran Dalam?
- Pembelajaran Dalam dengan Python: Contoh Perceptron
- Pembelajaran Dalam Dengan Python: Membuat Rangkaian Neural Dalam
Sains Data dan Komponennya
Nah, Sains Data adalah sesuatu yang telah lama wujud di sana. Sains data adalah pengekstrakan pengetahuan dari data dengan menggunakan teknik dan algoritma yang berbeza.
adalah teknik yang membolehkan mesin meniru tingkah laku manusia. Idea di sebalik AI cukup mudah namun menarik, iaitu membuat mesin pintar yang dapat membuat keputusan sendiri. Selama bertahun-tahun, difikirkan bahawa komputer tidak akan pernah sepadan dengan kekuatan otak manusia.
Baiklah, ketika itu kita tidak mempunyai cukup data dan kekuatan pengiraan, tetapi sekarang dengan Data besar wujud dan dengan munculnya GPU, Kecerdasan Buatan adalah mungkin.
apa itu pojo di java
adalah subset teknik AI yang menggunakan kaedah statistik untuk membolehkan mesin bertambah baik dengan pengalaman.
Pembelajaran mendalam adalah subset ML yang menjadikan pengiraan rangkaian saraf pelbagai lapisan dapat dilaksanakan. Ia menggunakan rangkaian Neural untuk mensimulasikan pembuatan keputusan seperti manusia.
Keperluan untuk Pembelajaran Dalam
Langkah Menuju Kecerdasan Buatan adalah Pembelajaran Mesin. Pembelajaran Mesin adalah sebahagian daripada AI dan didasarkan pada idea bahawa mesin harus diberi akses ke data, dan harus dibiarkan belajar dan diterokai sendiri. Ia berkaitan dengan pengekstrakan corak dari set data yang besar. Mengendalikan set data yang besar tidak menjadi masalah.
- Algoritma Pembelajaran Mesin tidak dapat mengendalikan Data Dimensi Tinggi - di mana kita mempunyai sebilangan besar input dan output: ribuan dimensi bulat. Pengendalian dan pemprosesan jenis data menjadi sangat rumit dan lengkap. Ini disebut sebagai Kutukan Dimensi.
- Cabaran lain yang dihadapi adalah, untuk menentukan ciri yang hendak diekstrak . Ini memainkan peranan penting dalam meramalkan hasilnya juga dalam mencapai ketepatan yang lebih baik. Oleh itu, tanpa pengekstrakan ciri, cabaran untuk pengaturcara meningkat kerana keberkesanan algoritma sangat bergantung pada betapa berwawasannya pengaturcara.
Sekarang, di sinilah Pembelajaran Dalam menyelamatkan diri. Pembelajaran mendalam adalah mampu menangani data dimensi tinggi dan juga cekap dalam memberi tumpuan kepada ciri yang betul dengan sendirinya.
Apa itu Pembelajaran Dalam?
Pembelajaran Dalam adalah subkumpulan Pembelajaran Mesin di mana Algoritma Pembelajaran Mesin serupa digunakan untuk melatih untuk mencapai ketepatan yang lebih baik dalam kes-kes di mana yang pertama tidak menunjukkan prestasi yang tinggi. Pada asasnya, Pembelajaran mendalam meniru cara otak kita berfungsi ia belajar dari pengalaman.
Seperti yang anda tahu,otak kita terdiri daripada berbilion-bilion neuron yang membolehkan kita melakukan perkara yang menakjubkan. Bahkan otak anak kecil mampu menyelesaikan masalah kompleks yang sangat sukar diselesaikan walaupun menggunakan Super-Komputer. Jadi, Bagaimana kita dapat mencapai fungsi yang sama dalam program? Sekarang, di sinilah kita faham Neuron Buatan (Perceptron) dan Rangkaian Neural Buatan.
Rangkaian Neural Perceptron dan Buatan
Pembelajaran mendalam mengkaji unit asas otak yang disebut sel otak atau neuron. Sekarang, mari kita fahami fungsi neuron biologi dan bagaimana kita meniru fungsi ini dalam persepsi atau neuron buatan.
- Dendrite: Menerima isyarat dari neuron lain
- Badan Sel: Merumuskan semua input
- Axon: Ia digunakan untuk menghantar isyarat ke sel lain
Neuron Buatan atau a Perceptron adalah model linear yang digunakan untuk klasifikasi binari. Ini memodelkan neuron yang memiliki satu set input, yang masing-masing diberi berat tertentu. Neuron mengira beberapa fungsi pada ini berwajaran input dan memberikan output.
Ia menerima input n (sesuai dengan setiap ciri). Ia kemudian merangkum input tersebut, menerapkan transformasi dan menghasilkan output. Ia mempunyai dua fungsi:
- Penjumlahan
- Transformasi (Pengaktifan)
Berat menunjukkan keberkesanan input tertentu. Lebih banyak berat input, lebih banyak akan memberi kesan pada rangkaian saraf . Sebaliknya, Berat sebelah adalah parameter tambahan di Perceptron yang digunakan untuk menyesuaikan output bersama dengan jumlah wajaran input ke neuron yang membantu model dengan cara yang paling sesuai untuk data yang diberikan.
Fungsi Pengaktifan menterjemahkan input menjadi output. Ia menggunakan ambang untuk menghasilkan output. Ada banyak fungsi yang digunakan sebagai Fungsi Pengaktifan, seperti:
- Linear atau Identiti
- Langkah Unit atau Perduaan
- Sigmoid atau Logistik
- Tanh
- ReLU
- Softmax
Baiklah. jika anda fikir Perceptron menyelesaikan masalah tersebut, maka anda salah. Terdapat dua masalah utama:
- Perceptron Lapisan Tunggal tidak dapat mengelaskan titik data yang tidak boleh dipisahkan secara linear .
- Masalah kompleks, yang melibatkan banyak parameter tidak dapat diselesaikan oleh Perceptron Lapisan Tunggal.
Pertimbangkan contoh di sini dan kerumitan dengan parameter yang terlibat untuk mengambil Keputusan oleh pasukan pemasaran.
One Neuron, tidak dapat menerima begitu banyak input dan itulah sebabnya lebih daripada satu neuron akan digunakan untuk menyelesaikan masalah ini. Rangkaian Neural benar-benar hanya komposisi Perceptrons, dihubungkan dengan cara yang berbeza dan beroperasi pada fungsi pengaktifan yang berbeza.
- Nod Input memberikan maklumat dari dunia luar ke jaringan dan bersama-sama disebut sebagai 'Input Layer'.
- Nod Tersembunyi melakukan pengiraan dan memindahkan maklumat dari nod input ke nod output. Kumpulan simpul tersembunyi membentuk 'Lapisan Tersembunyi'.
- Nod output secara kolektif disebut sebagai 'Output Layer' dan bertanggungjawab untuk pengiraan dan memindahkan maklumat dari rangkaian ke dunia luar.
Sekarang setelah anda mempunyai idea tentang bagaimana perceptron berkelakuan, parameter yang berbeza yang terlibat dan lapisan yang berbeza dari Rangkaian Neural, Mari kita lanjutkan Pembelajaran Dalam ini dengan Python Blog dan lihat beberapa aplikasi Deep Learning yang menarik.
Aplikasi Pembelajaran Dalam
Terdapat pelbagai aplikasi Pembelajaran Dalam dalam Industri, berikut adalah beberapa aplikasi penting yang terdapat dalam tugas Hari ke Hari kita.
- Pengenalan suara
- Terjemahan Mesin
- Pengecaman Muka dan Penandaan Automatik
- Pembantu Peribadi Maya
- Kereta Memandu Sendiri
- Berbual
Mengapa Python untuk Pembelajaran Dalam?
- adalah salah satu alat yang mempunyai atribut yang unik, iaitu menjadi bahasa pengaturcaraan tujuan umum sebagai mudah untuk digunakan mengenai pengkomputeran analitik dan kuantitatif.
- Ia sangat mudah untuk difahami
- Python adalah Dinaip secara Dinamik
- Besar
- Sebilangan besar Perpustakaan untuk tujuan yang berbeza seperti Numpy, Seaborn, Matplotlib, Pandas, dan Scikit-belajar
Sudah cukup teori, Mari kita lihat bagaimana kita dapat memulakan Pembelajaran Dalam dengan Python dengan contoh kecil namun menarik.
Pembelajaran Dalam Dengan Python: Contoh Perceptron
Sekarang saya yakin kalian mesti biasa dengan kerja “ ATAU ' pintu gerbang. Keluarannya adalah satu jika ada input juga satu.
Oleh itu, Perceptron boleh digunakan sebagai pemisah atau garis keputusan yang membahagikan set input OR Gate, kepada dua kelas:
Kelas 1: Input mempunyai output sebagai 0 yang terletak di bawah garis keputusan.
Kelas 2: Input mempunyai output sebagai 1 yang terletak di atas garis keputusan atau pemisah.
apa maksud sementara dalam java
Hingga kini, kami memahami bahawa perceptron linier dapat digunakan untuk mengklasifikasikan set data input menjadi dua kelas. Tetapi, bagaimana ia benar-benar mengklasifikasikan data?
Secara matematik perceptron boleh dianggap seperti persamaan Berat, Input, dan Bias.
Langkah 1: Import semua perpustakaan yang diperlukan
Di sini saya hanya akan mengimport satu perpustakaan, iaitu. TensorFlow
import tensorflow sebagai tf
Langkah 2: Tentukan Pemboleh ubah Vektor untuk Input dan Output
Seterusnya, kita perlu membuat pemboleh ubah untuk menyimpan input, output, dan bias untuk Perceptron.
train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]
Langkah 3: Tentukan Pembolehubah Berat
Di sini kita akan menentukan pemboleh ubah tensor bentuk 3 × 1 untuk berat kita dan memberikan beberapa nilai rawak pada awalnya.
w = tf.Variabel (tf.random_normal ([3, 1], biji = 15))
Langkah 4: Tentukan tempat letak untuk Input dan Output
Kita perlu menentukan tempat letak supaya mereka dapat menerima input luaran semasa dijalankan.
x = tf.placeholder (tf.float32, [Tiada, 3]) y = tf.placeholder (tf.float32, [Tiada, 1])
Langkah 5: Kira Fungsi Output dan Pengaktifan
Seperti yang dibincangkan sebelumnya, input yang diterima oleh perceptron dikalikan terlebih dahulu dengan bobot masing-masing dan kemudian, semua input berwajaran ini dijumlahkan bersama. Nilai penjumlahan ini kemudian dimasukkan ke pengaktifan untuk mendapatkan hasil akhir.
output = tf.nn.relu (tf.matmul (x, w))
Catatan: Dalam kes ini, saya telah menggunakan relu sebagai fungsi pengaktifan saya. Anda bebas menggunakan salah satu fungsi pengaktifan sesuai dengan keperluan anda.
Langkah 6: Hitung Kos atau Ralat
Kita perlu mengira Kos = Ralat Kuadrat Rata-rata yang tidak lain adalah kuadrat perbezaan output perceptron dan output yang diinginkan.
kerugian = tf.reduce_sum (tf.square (output - y))
Langkah 7: Minimumkan Ralat
Matlamat perceptron adalah untuk mengurangkan Kerugian atau Kos atau Kesalahan. Jadi di sini kita akan menggunakan Gradient Descent Optimizer.
optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimumkan (kerugian)
Langkah 8: Memulakan semua pemboleh ubah
Pemboleh ubah hanya ditentukan dengan t. Berubah. Oleh itu, kita perlu memulakan pemboleh ubah yang ditentukan.
init = tf.global_variables_initializer () sess = tf. Sesi () sess.run (init)
Langkah 9: Melatih Perceptron dalam Iterasi
Kita perlu melatih perceptron kita iaitu mengemas kini nilai bobot dan bias dalam lelaran berturut-turut untuk mengurangkan ralat atau kerugian. Di sini, saya akan melatih perceptron kita dalam 100 zaman.
untuk i dalam jarak (100): sess.run (kereta api, {x: train_in, y: train_out}) kos = sess.run (kerugian, feed_dict = {x: train_in, y: train_out}) cetakan ('Epoch-- ', i,' - kerugian - ', kos)Langkah 10: Keluaran
……
……
Seperti yang anda lihat di sini, kerugian bermula pada 2.07 dan berakhir pada 0.27
.
Pembelajaran Dalam Dengan Python: Membuat Rangkaian Neural Dalam
Sekarang kita berjaya membuat perceptron dan melatihnya untuk pintu OR. Mari lanjutkan artikel ini dan lihat bagaimana boleh membuat Rangkaian Neural kita sendiri dari Scratch, di mana kita akan membuat Lapisan Input, Lapisan Tersembunyi dan Lapisan Output.
Kami akan menggunakan set data MNIST. Set data MNIST terdiri daripada 60,000 latihan sampel dan 10,000 ujian contoh gambar digit tulisan tangan. Gambarnya bersaiz besar 28 × 28 piksel dan output boleh terletak di antara 0-9 .
Tugas di sini adalah untuk melatih model yang dapat mengenal pasti digit yang ada pada gambar dengan tepat
Pertama, kita akan menggunakan import di bawah untuk membawa fungsi cetak dari Python 3 ke Python 2.6+. Penyataan __future__ perlu berada di bahagian atas fail kerana mereka mengubah perkara asas mengenai bahasa, dan oleh itu penyusun perlu mengetahui tentangnya dari awal
dari __future__ import_fungsi_fungsi
Berikut adalah kod dengan komen di setiap langkah
# Import data MNIST dari tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) import tensorflow sebagai tf import matplotlib.pyplot sebagai plt # Parameter learning_rate = 0.001 training_epochs batch_size = 100 display_step = 1 # Parameter Rangkaian n_hidden_1 = 256 # Lapisan pertama bilangan ciri n_hidden_2 = 256 # Lapisan ke-2 bilangan ciri n_input = 784 # MNIST input data (bentuk img: 28 * 28) n_classes = 10 # MNIST jumlah kelas ( 0-9 digit) # tf Grafik input 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 lapisan pengaktifan RELU_1 = tf.add (tf.matmul (x, weight ['h1']), biases ['b1']) layer_1 = tf.nn.relu (layer_1) # Lapisan tersembunyi dengan lapisan pengaktifan RELU_2 = tf.add (tf.matmul (layer_1, bobot ['h2']), bias ['b2']) layer_2 = tf.nn.relu (layer_2) # Lapisan output dengan pengaktifan linear out_layer = tf. matmul (lapisan _2, bobot ['out']) + bias ['out'] return out_layer # Simpan berat lapisan & berat 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]))} # Model konstruk pred = multilayer_perceptron (x, bobot, bias) # Tentukan kerugian dan kos pengoptimum = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate). minimumkan (kos) # Memulakan pemboleh ubah init = tf.global_variables_initializer () #ciptakan senarai kosong untuk menyimpan sejarah kos dan sejarah ketepatan cost_history = [] ketepatan_history = [] # Lancarkan grafik dengan tf.Sesi () sebagai sess: sess.run (init # # Kitaran latihan untuk zaman dalam jangkauan (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Gelung semua kumpulan untuk i dalam julat (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Jalankan op pengoptimuman (backprop) dan kos op (untuk mendapatkan nilai kerugian) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Hitung purata kerugian avg_cost + = c / total_batch # Paparkan log setiap langkah zaman jika epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Hitung ketepatan ketepatan = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = ketepatan.eval ({x: mnist.test.images, y: mnist.test.labels}) #lampirkan ketepatan ke senarai ketepatan_history.append (acu_temp) #lampirkan cetakan sejarah kos_history.append (avg_cost) ('Epoch:', '% 04d'% (zaman + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) cetak ('Pengoptimuman Selesai! ') #plot sejarah kos plt.plot (cost_history) plt.show () #plot sejarah ketepatan plt.plot (ketepatan _history) plt.show () # Model ujian betul_prediksi = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Hitung ketepatan ketepatan = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) cetak (' Ketepatan: ', ketepatan.eval ({x: mnist.test.images, y: mnist.test.labels}))Pengeluaran:
data tableau mengadun gabung kiri
Sekarang dengan ini, kita sampai pada akhir artikel Deep Learning with Python ini. Saya harap anda mendapat pemahaman tentang pelbagai komponen Pembelajaran Dalam, Bagaimana semuanya bermula dan Bagaimana menggunakan Python kita dapat membuat perceptron sederhana dan Jaringan Neural Dalam.
Edureka's dikuratori oleh profesional industri mengikut kehendak & permintaan industri. Anda akan menguasai konsep-konsep seperti fungsi SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) dan bekerjasama dengan perpustakaan seperti Keras & TFLearn. Kursus ini telah dikuratori khas oleh pakar industri dengan kajian kes masa nyata.
Ada soalan untuk kami? Sila sebutkan di bahagian komen 'Deep Learning with Python' dan kami akan menghubungi anda.