Rangkaian saraf dalam python. Cara membuat rangkaian saraf dengan perpustakaan Keras dalam Python: contoh

Bahagian ini mengandungi pautan ke artikel daripada RuNet tentang apa itu rangkaian saraf. Banyak artikel ditulis dalam bahasa asli, hidup dan sangat mudah difahami. Walau bagaimanapun, di sini, sebahagian besarnya, hanya yang paling asas, reka bentuk yang paling mudah, dipertimbangkan. Di sini anda juga boleh mencari pautan ke literatur mengenai rangkaian saraf. Buku teks dan buku, sebagaimana mestinya, ditulis dalam bahasa akademik atau bahasa yang serupa dan mengandungi contoh-contoh abstrak yang tidak jelas untuk membina rangkaian saraf, latihan mereka, dll. Perlu diingat bahawa istilah dalam artikel yang berbeza "terapung", seperti yang boleh dilihat dari komen hingga ke artikel. Kerana ini, pada mulanya mungkin terdapat "kekacauan di kepala."

Cara seorang petani Jepun mengisih timun menggunakan pembelajaran mendalam dan TensorFlow
Rangkaian saraf dalam gambar: daripada neuron tunggal kepada seni bina dalam
Contoh program rangkaian saraf dengan kod sumber dalam C++.
Pelaksanaan rangkaian neural satu lapisan - perceptron untuk masalah klasifikasi kenderaan
Muat turun buku mengenai rangkaian saraf. Sihat!
Teknologi pasaran saham: 10 salah tanggapan tentang rangkaian saraf
Algoritma untuk melatih rangkaian neural berbilang lapisan menggunakan kaedah perambatan belakang

Rangkaian saraf dalam Python

Anda boleh membaca secara ringkas tentang perpustakaan yang wujud untuk Python. Dari sini saya akan mengambil contoh ujian untuk memastikan pakej yang diperlukan dipasang dengan betul.

aliran tensor

Objek pusat TensorFlow ialah graf aliran data yang mewakili pengiraan. Bucu graf mewakili operasi, dan tepi mewakili tensor (tensor) ( tatasusunan berbilang dimensi, yang merupakan asas TensorFlow). Graf aliran data secara keseluruhan ialah penerangan penuh pengiraan yang dilaksanakan dalam sesi dan dilakukan pada peranti (CPU atau GPU). Seperti banyak sistem moden lain untuk pengkomputeran saintifik dan pembelajaran mesin TensorFlow mempunyai API yang didokumentasikan dengan baik untuk Python, di mana tensor diwakili sebagai tatasusunan ndarray NumPy yang biasa. TensorFlow melakukan pengiraan menggunakan C++ yang sangat dioptimumkan dan juga menyokong API asli untuk C dan C++.

Pengenalan kepada pembelajaran mesin dengan aliran tensor. Setakat ini, hanya artikel pertama daripada empat yang diumumkan telah diterbitkan.
TensorFlow mengecewakan. Pembelajaran mendalam Google tidak mempunyai "kedalaman"
Sepintas lalu Pembelajaran Mesin: Klasifikasi Teks dengan Rangkaian Neural dan TensorFlow
Pustaka pembelajaran mesin Google TensorFlow – tanggapan pertama dan perbandingan dengan pelaksanaan kami sendiri

Memasang aliran tensor diterangkan dengan baik dalam artikel pada pautan pertama. Walau bagaimanapun, Python 3.6.1 kini telah dikeluarkan. Ia tidak akan dapat digunakan. Sekurang-kurangnya sulfur pada masa ini (06/03/2017). Memerlukan versi 3.5.3, yang boleh dimuat turun. Di bawah ini saya akan memberikan urutan yang berkesan untuk saya (sedikit berbeza daripada artikel dari Habr). Tidak jelas mengapa, tetapi Python 64-bit dibuat untuk pemproses AMD Oleh itu, segala-galanya berlaku di bawahnya. Selepas memasang Phyton, jangan lupa untuk menetapkan akses penuh untuk pengguna jika Python telah dipasang untuk semua orang.

pip install --upgrade pip
pip install -U pip setuptools
pip3 install --upgrade tensorflow
pip3 install --upgrade tensorflow-gpu
pip install matplotlib /*Muat turun 8.9 MB dan beberapa lagi fail kecil */
pip pasang jupyter

"Sawa telanjang" mungkin kelihatan tidak menarik. Oleh itu, di bawah ialah arahan untuk memasang dalam persekitaran Anaconda. Ini adalah binaan alternatif. Python sudah disepadukan ke dalamnya.

Tapak ini sekali lagi menampilkan versi baharu untuk Python 3.6, yang belum disokong oleh produk Google baharu itu. Oleh itu, saya segera mengambil versi terdahulu dari arkib, iaitu Anaconda3-4.2.0 - ia sesuai. Jangan lupa untuk menyemak kotak pendaftaran Python 3.5. Khususnya, sebelum memasang Anaconda, lebih baik menutup terminal, jika tidak, ia akan terus berfungsi dengan PATH yang sudah lapuk. Juga, jangan lupa untuk menukar hak akses pengguna, jika tidak, tiada apa yang akan berfungsi.

conda create -n tensorflow
mengaktifkan aliran tensor
pemasangan pip --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/cpu/tensorflow-1.1.0-cp35-cp35m-win_amd64.whl /*Dimuat turun dari Internet 19.4 MB, kemudian 7 , 7 MB dan 0.317 MB lagi*/
pemasangan pip --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/gpu/tensorflow_gpu-1.1.0-cp35-cp35m-win_amd64.whl /*Muat turun 48.6 MB */

Tangkapan skrin skrin pemasangan: semuanya berjalan lancar di Anaconda.

Begitu juga untuk fail kedua.

Kesimpulannya: agar semua ini berfungsi, anda perlu memasang pakej CUDA Toolkits dari NVIDEA (sekiranya penggunaan GPU). Versi semasa yang disokong ialah 8.0. Anda juga perlu memuat turun dan membongkar pustaka cuDNN v5.1 ke dalam folder CUDA, tetapi bukan versi yang lebih baharu! Selepas semua manipulasi ini, TensorFlow akan berfungsi.

Theano

Rangkaian saraf berulang dalam 10 baris kod menilai maklum balas daripada penonton episod baharu "Star Wars"

Pakej Theano disertakan dalam PyPI milik Python sendiri. Dengan sendirinya ia kecil - 3.1 MB, tetapi ia menarik 15 MB lagi kebergantungan - scipy. Untuk memasang yang terakhir, anda juga memerlukan modul lapack... Secara umum, memasang pakej theano di bawah Windows bermaksud "menari dengan tamborin." Di bawah saya akan cuba menunjukkan urutan tindakan untuk membuat pakej berfungsi.

Apabila menggunakan Anaconda, "menari dengan rebana" semasa pemasangan tidak relevan. Perintah itu sudah cukup:

conda pasang theano

dan proses berlaku secara automatik. By the way, pakej GCC juga dimuatkan.

Scikit-Belajar

Di bawah Python 3.5.3, hanya lebih daripada versi awal 0.17.1 yang boleh anda ambil. Terdapat pemasang biasa. Walau bagaimanapun, ia tidak akan berfungsi secara langsung di bawah Windows - anda memerlukan perpustakaan scipy.

Memasang Pakej Pembantu

Agar kedua-dua pakej di atas berfungsi (kita bercakap tentang Phyton "telanjang"), anda perlu melakukan beberapa langkah awal.

SciPy

Untuk melancarkan Scikit-Learn dan Theano, seperti yang telah jelas dari yang di atas, anda perlu "menari dengan rebana." Perkara pertama yang Yandex berikan kepada kami ialah gudang kebijaksanaan, walaupun dalam bahasa Inggeris, sumber stackoverflow.com, di mana kami menemui pautan ke arkib yang sangat baik bagi hampir semua pakej Python sedia ada yang disusun untuk Windows - lfd.uci.edu

Di sini terdapat himpunan sedia untuk dipasang bagi pakej yang anda minati, disusun untuknya versi berbeza Ular sawa. Dalam kes kami, versi fail diperlukan, mengandungi baris "-cp35-win_amd64" dalam namanya kerana ini sebenarnya Pakej Python telah digunakan untuk pemasangan. Pada stakowerflow, jika anda mencari, anda juga boleh mendapatkan "arahan" untuk memasang pakej khusus kami.

pemasangan pip --upgrade --ignore-installed http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/numpy-1.12.1+mkl-cp35-cp35m-win_amd64.whl
pemasangan pip --upgrade --ignore-insalled http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/scipy-0.19.0-cp35-cp35m-win_amd64.whl
pip --upgrade --ignore-installed panda
pip install --upgrade --ignore-installed matplotlib

Dua pakej terakhir muncul dalam rantai saya kerana "menari dengan tamborin" orang lain. Saya tidak menyedarinya dalam kebergantungan pakej yang dipasang, tetapi nampaknya beberapa komponennya diperlukan untuk proses pemasangan biasa.

Lapack/Blas

Kedua-dua perpustakaan peringkat rendah yang berkaitan ini, yang ditulis dalam Fortran, diperlukan untuk memasang pakej Theano. Scikit-Learn juga boleh berfungsi pada mereka yang telah dipasang "secara tersembunyi" dalam pakej lain (lihat di atas). Sebenarnya, jika Theano versi 0.17 dipasang dari fail exe, ia juga akan berfungsi. Sekurang-kurangnya di Anaconda. Walau bagaimanapun, perpustakaan ini juga boleh didapati di Internet. Sebagai contoh . Binaan yang lebih baru. Untuk pakej siap berfungsi versi terdahulu Memang sesuai. Membina pakej baharu memerlukan versi baharu.

Perlu juga diperhatikan bahawa dalam binaan Anaconda yang benar-benar segar, pakej Theano dipasang dengan lebih mudah - dengan satu arahan, tetapi jujur, saya tidak peduli di fasa ini(sifar) menguasai rangkaian saraf, saya lebih suka TensorFlow, tetapi ia belum lagi mesra dengan versi baharu Python.

Pengaturcaraan

Terjemahan

Artikel berkenaan tentang apa?

Secara peribadi, saya belajar terbaik dengan kod kerja kecil yang boleh saya mainkan. Dalam tutorial ini, kita akan mempelajari algoritma perambatan balik menggunakan rangkaian saraf kecil yang dilaksanakan dalam Python sebagai contoh.

Beri saya kod!

X = np.array([ ,,, ]) y = np.array([]).T syn0 = 2*np.random.random((3,4)) - 1 syn1 = 2*np.random.random ((4,1)) - 1 untuk j dalam julat x(60000): l1 = 1/(1+np.exp(-(np.dot(X,syn0)))) l2 = 1/(1+np. exp(-(np.dot(l1,syn1)))) l2_delta = (y - l2)*(l2*(1-l2)) l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1 )) syn1 += l1.T.dot(l2_delta) syn0 += X.T.dot(l1_delta)

Terlalu mampat? Mari kita pecahkan kepada bahagian yang lebih mudah.

Bahagian 1: Rangkaian saraf mainan kecil

Rangkaian saraf yang dilatih melalui perambatan belakang cuba menggunakan data input untuk meramal data output.

Katakan kita perlu meramalkan rupa lajur output berdasarkan data input. Masalah ini boleh diselesaikan dengan mengira korespondensi statistik antara mereka. Dan kita akan melihat bahawa lajur kiri adalah 100% berkorelasi dengan output.

Backpropagation, dalam kes paling mudah, mengira statistik yang serupa untuk mencipta model. Mari kita cuba.

Rangkaian saraf dalam dua lapisan

import numpy sebagai np # Sigmoid def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x) )) # set data input X = np.array([ , , , ]) # data output y = np.array([]).T # do nombor rawak np.random.seed(1) yang lebih khusus # mulakan pemberat secara rawak dengan purata 0 syn0 = 2*np.random.random((3,1)) - 1 untuk iter dalam julat x(10000): # perambatan hadapan l0 = X l1 = nonlin(np.dot(l0,syn0)) # betapa silapnya kita? l1_error = y - l1 # darab ini dengan kecerunan sigmoid # berdasarkan nilai dalam l1 l1_delta = l1_error * nonlin(l1,True) # !!! # kemas kini pemberat syn0 += np.dot(l0.T,l1_delta) # !!! cetak "Output selepas latihan:" cetak l1

Output selepas latihan: [[ 0.00966449] [ 0.00786506] [ 0.99358898] [ 0.99211957]]

Pembolehubah dan penerangannya.

"*" - pendaraban mengikut unsur - dua vektor dengan saiz yang sama mendarabkan nilai yang sepadan, dan output adalah vektor dengan saiz yang sama
"-" – penolakan vektor mengikut unsur
x.dot(y) – jika x dan y ialah vektor, maka output akan menjadi hasil darab skalar. Jika ini adalah matriks, maka hasilnya ialah pendaraban matriks. Jika matriks hanya salah satu daripadanya, ia adalah pendaraban vektor dan matriks.

bandingkan l1 selepas lelaran pertama dan selepas yang terakhir
lihat pada fungsi nonlin.
lihat bagaimana l1_error berubah
parse baris 36 - bahan rahsia utama dikumpulkan di sini (ditanda!!!)
parse baris 39 - keseluruhan rangkaian sedang bersiap dengan tepat untuk operasi ini (ditanda!!!)

Mari kita pecahkan baris demi baris

import numpy sebagai np

Mengimport numpy, perpustakaan algebra linear. Satu-satunya ketagihan kami.

Def nonlin(x,deriv=False):

Ketaklinieran kami. Fungsi khusus ini mencipta "sigmoid". Ia memadankan sebarang nombor dengan nilai dari 0 hingga 1 dan menukar nombor kepada kebarangkalian, dan juga mempunyai beberapa sifat lain yang berguna untuk melatih rangkaian saraf.

Jika(deriv==Benar):

Fungsi ini juga boleh menghasilkan terbitan sigmoid (deriv=True). Ini adalah salah satu sifat bermanfaatnya. Jika keluaran fungsi ialah pembolehubah keluar, maka terbitan akan keluar * (1-keluar). Berkesan.

X = np.array([ , …

Memulakan tatasusunan data input sebagai matriks numpy. Setiap baris adalah contoh latihan. Lajur ialah nod input. Kami berakhir dengan 3 nod input dalam rangkaian dan 4 contoh latihan.

Y = np.array([]).T

Memulakan data output. ".T" – fungsi pemindahan. Selepas terjemahan, matriks y mempunyai 4 baris dengan satu lajur. Seperti data input, setiap baris ialah contoh latihan, dan setiap lajur (satu dalam kes kami) ialah nod keluaran. Ternyata rangkaian mempunyai 3 input dan 1 output.

Np.random.seed(1)

Terima kasih kepada ini, pengedaran rawak akan sama setiap kali. Ini akan membolehkan kami memantau rangkaian dengan lebih mudah selepas kami membuat perubahan pada kod.

Syn0 = 2*np.random.random((3,1)) – 1

Matriks berat rangkaian. syn0 bermaksud "sifar sinaps". Oleh kerana kita hanya mempunyai dua lapisan, input dan output, kita memerlukan satu matriks berat yang akan menyambungkannya. Dimensinya ialah (3, 1), kerana kita mempunyai 3 input dan 1 output. Dalam erti kata lain, l0 mempunyai saiz 3 dan l1 mempunyai saiz 1. Oleh kerana kita menyambung semua nod dalam l0 kepada semua nod dalam l1, kita memerlukan matriks dimensi (3, 1).

Ambil perhatian bahawa ia dimulakan secara rawak dan min ialah sifar. Terdapat teori yang agak kompleks di sebalik ini. Buat masa ini kami hanya akan mengambil ini sebagai cadangan. Juga ambil perhatian bahawa rangkaian saraf kami adalah matriks ini. Kami mempunyai "lapisan" l0 dan l1, tetapi ini adalah nilai sementara berdasarkan set data. Kami tidak menyimpannya. Semua latihan disimpan dalam syn0.

Untuk iter dalam xrange(10000):

Di sinilah kod latihan rangkaian utama bermula. Gelung kod diulang berkali-kali dan mengoptimumkan rangkaian untuk set data.

Lapisan pertama, l0, hanyalah data. X mengandungi 4 contoh latihan. Kami akan memproses semuanya sekaligus - ini dipanggil latihan kumpulan. Secara keseluruhan kami mempunyai 4 garisan yang berbeza l0, tetapi anda boleh menganggapnya sebagai satu contoh latihan - pada peringkat ini tidak mengapa (anda boleh memuatkan 1000 atau 10000 daripadanya tanpa sebarang perubahan pada kod).

L1 = nonlin(np.dot(l0,syn0))

Ini adalah langkah ramalan. Kami membiarkan rangkaian cuba meramalkan output berdasarkan input. Kemudian kita akan melihat bagaimana dia melakukannya supaya kita boleh mengubahnya untuk penambahbaikan.

Terdapat dua langkah setiap baris. Yang pertama melakukan pendaraban matriks bagi l0 dan syn0. Yang kedua melepasi output melalui sigmoid. Dimensi mereka adalah seperti berikut:

(4 x 3) titik (3 x 1) = (4 x 1)

Pendaraban matriks memerlukan dimensi yang sama di tengah-tengah persamaan. Matriks akhir mempunyai bilangan baris yang sama dengan yang pertama, dan bilangan lajur yang sama dengan yang kedua.

Kami memuatkan 4 contoh latihan dan mendapat 4 tekaan (matriks 4x1). Setiap output sepadan dengan tekaan rangkaian untuk input yang diberikan.

L1_ralat = y - l1

Oleh kerana l1 mengandungi tekaan, kita boleh membandingkan perbezaannya dengan realiti dengan menolak l1 daripada jawapan yang betul y. l1_error ialah vektor nombor positif dan negatif yang mencirikan rangkaian "rindu".

Dan inilah ramuan rahsianya. Baris ini perlu dihuraikan sekeping demi sekeping.

Bahagian pertama: terbitan

Nonlin(l1,Benar)

L1 mewakili tiga titik ini, dan kod menghasilkan cerun garisan yang ditunjukkan di bawah. Ambil perhatian bahawa untuk nilai besar seperti x=2.0 (titik hijau) dan nilai yang sangat kecil seperti x=-1.0 (ungu) garisan mempunyai cerun sedikit. Sudut terbesar pada titik x=0 (biru). Ini membuat perbezaan yang besar. Juga ambil perhatian bahawa semua derivatif berjulat dari 0 hingga 1.

Ungkapan penuh: terbitan berwajaran ralat

L1_delta = l1_error * nonlin(l1,True)

Secara matematik, terdapat kaedah yang lebih tepat, tetapi dalam kes kami, kaedah ini juga sesuai. l1_error ialah matriks (4,1). nonlin(l1,True) mengembalikan matriks (4,1). Di sini kita mendarabkannya dengan elemen, dan pada output kita juga mendapat matriks (4,1), l1_delta.

Dengan mendarab derivatif dengan ralat, kami mengurangkan ralat ramalan yang dibuat dengan keyakinan yang tinggi. Jika cerun garisan itu kecil, maka rangkaian itu mengandungi nilai yang sangat besar atau sangat kecil. Jika tekaan rangkaian hampir kepada sifar (x=0, y=0.5), maka ia tidak begitu yakin. Kami mengemas kini ramalan yang tidak pasti ini dan meninggalkan ramalan berkeyakinan tinggi sahaja dengan mendarabkannya dengan nilai yang hampir kepada sifar.

Syn0 += np.dot(l0.T,l1_delta)

Kami bersedia untuk mengemas kini rangkaian. Mari kita lihat satu contoh latihan. Di dalamnya kami akan mengemas kini berat. Kemas kini berat paling kiri (9.5)

Kemas kini_berat = nilai_input * l1_delta

Untuk berat paling kiri ialah 1.0 * l1_delta. Mungkin ini hanya akan meningkatkan 9.5 sedikit. kenapa? Kerana ramalan itu sudah agak yakin, dan ramalan itu boleh dikatakan betul. Ralat kecil dan sedikit cerun garisan bermakna kemas kini yang sangat kecil.

Tetapi memandangkan kami sedang melakukan latihan kumpulan, kami mengulangi langkah di atas untuk keempat-empat contoh latihan. Jadi ia kelihatan sangat serupa dengan imej di atas. Jadi apa yang baris kami lakukan? Ia mengira kemas kini berat untuk setiap berat, untuk setiap contoh latihan, menjumlahkannya dan mengemas kini semua pemberat - semuanya dalam satu baris.

Selepas memerhatikan kemas kini rangkaian, mari kembali ke data latihan kami. Apabila kedua-dua input dan output adalah 1, kami meningkatkan berat antara mereka. Apabila input adalah 1 dan output adalah 0, kami mengurangkan berat.

Input Output 0 0 1 0 1 1 1 1 1 0 1 1 0 1 1 0

Oleh itu, dalam empat kami contoh latihan di bawah, berat input pertama berbanding output akan sama ada meningkat atau kekal malar, dan dua pemberat yang lain akan meningkat dan berkurangan bergantung pada contoh. Kesan ini menyumbang kepada pembelajaran rangkaian berdasarkan korelasi data input dan output.

Bahagian 2: tugas yang lebih sukar

Input Output 0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 0

Mari cuba meramalkan data output berdasarkan tiga lajur data input. Tiada lajur input yang 100% berkorelasi dengan output. Lajur ketiga tidak disambungkan kepada apa-apa sama sekali, kerana ia mengandungi semua itu. Walau bagaimanapun, di sini anda boleh melihat corak - jika salah satu daripada dua lajur pertama (tetapi bukan kedua-duanya sekali) mengandungi 1, maka hasilnya juga akan sama dengan 1.

Ini ialah reka bentuk bukan linear kerana tiada surat-menyurat langsung satu-satu antara lajur. Padanan adalah berdasarkan gabungan input, lajur 1 dan 2.

Menariknya, pengecaman corak adalah tugas yang hampir sama. Jika anda mempunyai 100 gambar basikal dan paip dengan saiz yang sama, kehadiran piksel tertentu di tempat tertentu tidak berkait langsung dengan kehadiran basikal atau paip dalam imej. Secara statistik, warna mereka mungkin kelihatan rawak. Tetapi beberapa kombinasi piksel tidak rawak - yang membentuk imej basikal (atau tiub).

Strategi

Untuk menggabungkan piksel menjadi sesuatu yang boleh mempunyai korespondensi satu sama satu dengan output, anda perlu menambah lapisan lain. Lapisan pertama menggabungkan input, yang kedua memberikan padanan kepada output menggunakan output lapisan pertama sebagai input. Beri perhatian kepada meja.

Input (l0) Berat tersembunyi (l1) Output (l2) 0 0 1 0.1 0.2 0.5 0.2 0 0 1 1 0.2 0.6 0.7 0.1 1 1 0 1 0.3 0.2 0.3 0.9 1 1 0.3 0.9 1 0.3 0.9 1 1 1

Dengan memberikan pemberat secara rawak, kami mendapat nilai tersembunyi untuk lapisan No. 1. Menariknya, lajur pemberat tersembunyi kedua sudah mempunyai korelasi kecil dengan output. Tidak ideal, tetapi ada. Dan ini juga merupakan bahagian penting dalam proses latihan rangkaian. Latihan hanya akan mengukuhkan korelasi ini. Ia akan mengemas kini syn1 untuk menetapkan pemetaannya kepada data output, dan syn0 untuk mendapatkan data input dengan lebih baik.

Rangkaian saraf dalam tiga lapisan

import numpy sebagai np def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x)) X = np.array([, , , ]) y = np.array([, , , ]) np.random.seed(1) # mulakan pemberat secara rawak, secara purata - 0 syn0 = 2*np.random. rawak ((3,4)) - 1 syn1 = 2*np.random.random((4,1)) - 1 untuk j dalam julat x(60000): # pergi ke hadapan melalui lapisan 0, 1 dan 2 l0 = X l1 = nonlin(np.dot(l0,syn0)) l2 = nonlin(np.dot(l1,syn1)) # berapa banyak silap kita tentang nilai yang diperlukan? l2_error = y - l2 if (j% 10000) == 0: cetak "Ralat:" + str(np.mean(np.abs(l2_error))) # ke arah manakah anda harus bergerak? # jika kami yakin dengan ramalan itu, maka kami tidak perlu banyak mengubahnya l2_delta = l2_error*nonlin(l2,deriv=True) # berapakah nilai l1 mempengaruhi ralat dalam l2? l1_error = l2_delta.dot(syn1.T) # ke arah manakah kita harus bergerak untuk sampai ke l1? # jika kami yakin dengan ramalan itu, maka kami tidak perlu banyak mengubahnya l1_delta = l1_error * nonlin(l1,deriv=True) syn1 += l1.T.dot(l2_delta) syn0 += l0.T.dot (l1_delta)

Ralat:0.496410031903 Ralat:0.00858452565325 Ralat:0.00578945986251 Ralat:0.00462917677677 Ralat:0.00395876528020 Ralat:506.

Pembolehubah dan penerangannya

X ialah matriks set data input; rentetan - contoh latihan
y – matriks set data keluaran; rentetan - contoh latihan
l0 – lapisan rangkaian pertama yang ditakrifkan oleh data input
l1 – lapisan kedua rangkaian, atau lapisan tersembunyi
l2 ialah lapisan terakhir, ini adalah hipotesis kami. Semasa anda berlatih, anda harus mendekati jawapan yang betul.
syn0 – lapisan pertama pemberat, Sinaps 0, menggabungkan l0 dengan l1.
syn1 – Lapisan kedua pemberat, Sinaps 1, menggabungkan l1 dengan l2.
l2_error – ralat rangkaian dari segi kuantitatif
l2_delta – ralat rangkaian, bergantung pada keyakinan ramalan. Hampir sama dengan ralat, kecuali ramalan yang yakin
l1_error - dengan menimbang l2_delta dengan pemberat dari syn1, kami mengira ralat di lapisan tengah/tersembunyi
l1_delta – ralat rangkaian dari l1, berskala dengan keyakinan ramalan. Hampir sama dengan l1_error, kecuali ramalan yang yakin

Kod itu harus agak jelas - ia hanya pelaksanaan rangkaian sebelumnya, disusun dalam dua lapisan, satu di atas yang lain. Keluaran lapisan pertama l1 ialah input lapisan kedua. Terdapat sesuatu yang baru hanya dalam baris seterusnya.

L1_error = l2_delta.dot(syn1.T)

Menggunakan ralat yang ditimbang dengan keyakinan ramalan daripada l2 untuk mengira ralat untuk l1. Kita dapat, boleh dikatakan, ralat yang ditimbang oleh sumbangan - kita mengira berapa banyak nilai pada nod l1 menyumbang kepada ralat dalam l2. Langkah ini dipanggil perambatan balik kesilapan. Kami kemudian mengemas kini syn0 menggunakan algoritma yang sama seperti rangkaian neural dua lapisan.

Keras- perpustakaan popular pembelajaran yang mendalam, yang telah memberikan sumbangan besar kepada pengkomersilan pembelajaran mendalam. Keras mudah digunakan dan membolehkan anda mencipta rangkaian saraf dengan hanya beberapa baris kod Python.

Dalam artikel ini, anda akan belajar cara menggunakan Keras untuk mencipta rangkaian saraf yang meramalkan cara pengguna akan menilai produk berdasarkan ulasan mereka, mengklasifikasikannya kepada dua kategori: positif atau negatif. Tugas ini dipanggil analisis sentimen (analisis sentimen), dan kami akan menyelesaikannya dengan bantuan tapak ulasan filem IMDb. Model yang akan kami bina juga boleh digunakan untuk menyelesaikan masalah lain selepas pengubahsuaian kecil.

Sila ambil perhatian bahawa kami tidak akan menerangkan secara terperinci tentang Keras dan pembelajaran mendalam. Siaran ini bertujuan untuk menyediakan skema dalam Keras dan memperkenalkan pelaksanaannya.

Apakah Keras?
Apakah analisis sentimen?
Set Data IMDB
Penerokaan Data
Penyediaan data
Penciptaan model dan latihan

Apakah Keras?

Keras ialah perpustakaan Python sumber terbuka kod sumber, yang memudahkan untuk mencipta rangkaian saraf. Pustaka ini serasi dengan , Microsoft Cognitive Toolkit, Theano dan MXNet. Tensorflow dan Theano ialah rangka kerja berangka Python yang paling biasa digunakan untuk membangunkan algoritma pembelajaran mendalam, tetapi ia agak sukar untuk digunakan.

Menilai populariti rangka kerja pembelajaran mesin dalam 7 kategori

Keras, sebaliknya, menyediakan cara yang mudah dan mudah untuk mencipta model pembelajaran mendalam. Penciptanya, François Chollet, membangunkannya untuk mempercepat dan memudahkan proses mencipta rangkaian saraf sebanyak mungkin. Dia memberi tumpuan kepada kebolehlanjutan, modulariti, minimalism, dan sokongan Python. Keras boleh digunakan dengan GPU dan CPU; ia menyokong kedua-dua Python 2 dan Python 3. Keras Google telah memberikan sumbangan besar kepada pengkomersilan pembelajaran mendalam dan kerana ia mengandungi algoritma pembelajaran mendalam terkini yang sebelum ini bukan sahaja tidak boleh diakses, tetapi juga tidak boleh digunakan.

Apakah analisis sentimen (analisis sentimen)?

Analisis sentimen boleh digunakan untuk menentukan sikap seseorang (iaitu, mood) terhadap teks, interaksi atau peristiwa. Oleh itu, analisis sentimen tergolong dalam bidang pemprosesan bahasa semula jadi, di mana makna teks mesti ditafsirkan untuk mengeluarkan nada dan sentimen daripadanya.

Contoh skala analisis sentimen

Spektrum mood biasanya dibahagikan kepada positif, negatif dan neutral kategori. Menggunakan analisis sentimen, anda boleh, sebagai contoh, meramalkan pendapat pelanggan dan sikap mereka terhadap produk berdasarkan ulasan yang mereka tulis. Oleh itu, analisis sentimen digunakan secara meluas pada ulasan, tinjauan, teks dan banyak lagi.

Set Data IMDb

Ulasan tentang IMDb

Set data IMDb terdiri daripada 50,000 ulasan filem daripada pengguna, dilabelkan sebagai positif (1) dan negatif (0).

Ulasan dipraproses dan setiap satu dikodkan dengan urutan indeks perkataan sebagai integer.
Perkataan dalam ulasan diindeks mengikut kekerapan keseluruhan kejadian dalam set data. Sebagai contoh, integer "2" mengekod perkataan kedua yang paling kerap digunakan.
50,000 ulasan dibahagikan kepada dua set: 25,000 untuk latihan dan 25,000 untuk ujian.

Dataset telah dicipta oleh penyelidik di Universiti Stanford dan dibentangkan dalam kertas 2011, di mana ketepatan ramalan yang dicapai ialah 88.89%. Dataset juga digunakan sebagai sebahagian daripada pertandingan komuniti Keggle "Beg Kata Bertemu Beg Popcorn" pada 2011.

Mengimport Ketergantungan dan Mendapatkan Data

Mari mulakan dengan mengimport kebergantungan yang diperlukan untuk mempraproses data dan membina model.

%matplotlib import sebaris matplotlib import matplotlib.pyplot sebagai plt import numpy sebagai np daripada keras.utils import to_categorical daripada model import keras daripada lapisan import keras

Mari muatkan set data IMDb, yang sudah terbina dalam Keras. Memandangkan kami tidak mahu mempunyai 50/50 data latihan dan ujian, kami akan segera menggabungkan data ini selepas memuatkan untuk pemisahan kemudian dalam nisbah 80/20:

Dari keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate((training_data, testing_data), axis=0) targets = np.concatenate((training_targets , testing_targets), paksi=0)

Penerokaan Data

Mari kaji set data kami:

Print("Kategori:", np.unique(sasaran)) print("Bilangan perkataan unik:", len(np.unique(np.hstack(data)))) Kategori: Bilangan perkataan unik: 9998 panjang = cetak ("Purata Panjang Semakan:", np.min(panjang)) print("Sisihan Piawai:", bulat(np.std(panjang))) Purata Panjang Semakan: 234.75892 Sisihan Piawai: 173.0

Anda boleh melihat bahawa semua data terbahagi kepada dua kategori: 0 atau 1, yang mewakili sentimen semakan. Keseluruhan set data mengandungi 9998 perkataan unik, saiz ulasan purata ialah 234 perkataan dengan sisihan piawai 173.

Mari lihat cara mudah untuk belajar:

Cetak("Label:", sasaran) Label: 1 cetakan(data)

Di sini anda melihat ulasan pertama daripada set data, yang ditandakan sebagai positif (1). Kod berikut menghasilkan penukaran songsang indeks ke dalam perkataan supaya kita boleh membacanya. Di dalamnya, setiap perkataan yang tidak diketahui digantikan dengan "#". Ini dilakukan menggunakan fungsi get_word_index().

Index = imdb.get_word_index() reverse_index = dict([(value, key) for (key, value) in index.items()]) decoded = " ".join() print(decoded) # filem ini hanya lakonan yang cemerlang arah cerita pemandangan lokasi semua orang sangat sesuai dengan bahagian yang mereka mainkan dan anda boleh bayangkan berada di sana robert # ialah seorang pelakon yang hebat dan kini pengarah yang sama # bapa berasal dari pulau scottish yang sama dengan saya jadi saya menyukai hakikat bahawa terdapat seorang kaitan sebenar dengan filem ini kata-kata lucu sepanjang filem itu hebat, ia sangat hebat sehingga saya membeli filem itu sebaik sahaja ia dikeluarkan untuk # dan akan mengesyorkannya kepada semua orang untuk menonton dan memancing terbang sangat mengagumkan benar-benar menangis di penghujungnya ia sangat menyedihkan dan anda tahu apa yang mereka katakan jika anda menangis di sebuah filem ia pasti bagus dan ini pastinya juga # kepada dua budak kecil yang memainkan # Norman dan Paul, mereka hanyalah kanak-kanak yang cemerlang selalunya tertinggal daripada # senarai saya rasa kerana ia bintang-bintang yang memainkan mereka semua dewasa adalah profil besar untuk keseluruhan filem tetapi kanak-kanak ini hebat dan harus dipuji atas apa yang telah mereka lakukan, tidakkah anda fikir keseluruhan cerita itu sangat indah kerana ia adalah benar dan adalah seseorang kehidupan selepas semua yang dikongsi dengan kita semua

Penyediaan data

Sudah tiba masanya untuk menyediakan data. Kita perlu mengvektorkan setiap ulasan dan mengisinya dengan sifar supaya vektor mengandungi tepat 10,000 nombor. Ini bermakna kami mengisi setiap ulasan yang lebih pendek daripada 10,000 perkataan dengan sifar. Ini dilakukan kerana paling banyak ulasan yang hebat adalah saiz yang hampir sama, dan setiap elemen data input ke rangkaian saraf kita hendaklah saiz yang sama. Anda juga perlu menukar pembolehubah kepada menaip terapung.

Def vectorize(jujukan, dimensi = 10000): keputusan = np.sifar((len(jujukan), dimensi)) untuk i, jujukan dalam enumerate(jujukan): hasil = 1 data hasil pulangan = vektorize(data) sasaran = np. tatasusunan(sasaran).astype("float32")

Mari bahagikan set data kepada set latihan dan ujian. Set latihan akan terdiri daripada 40,000 ulasan, set ujian akan terdiri daripada 10,000.

Test_x = data[:10000] test_y = sasaran[:10000] train_x = data train_y = sasaran

Penciptaan model dan latihan

Kini anda boleh mencipta rangkaian neural yang mudah. Mari kita mulakan dengan menentukan jenis model yang ingin kita buat. Terdapat dua jenis model yang tersedia di Keras: API berjujukan dan berfungsi.

Kemudian anda perlu menambah lapisan input, tersembunyi dan output. Untuk mengelakkan overfitting, kami akan menggunakan pengecualian di antara mereka ( "tercicir"). Ambil perhatian bahawa anda harus sentiasa menggunakan kadar pengecualian antara 20% dan 50%. Setiap lapisan menggunakan fungsi "padat" untuk menyambung sepenuhnya lapisan antara satu sama lain. Dalam lapisan tersembunyi kita akan gunakan "relu", kerana ini hampir selalu membawa kepada hasil yang memuaskan. Jangan takut untuk bereksperimen dengan fungsi pengaktifan lain. Pada lapisan output, kami menggunakan fungsi sigmoid yang menormalkan semula nilai dalam julat dari 0 hingga 1. Ambil perhatian bahawa kami menetapkan saiz elemen set data input kepada 10,000 kerana ulasan kami bersaiz sehingga 10,000 integer. Lapisan input menerima elemen dengan saiz 10,000 dan elemen output dengan saiz 50.

Akhir sekali, biarkan Keras mencetak penerangan ringkas tentang model yang baru kami buat.

# Input - Layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add(layers.Dropout(0.3, noise_shape=None, seed=None) ) model.add(layers.Dense(50, activation = "relu") model.add(layers.Dropout(0.2, noise_shape=None, seed=None)) model.add(layers.Dense(50, activation = "relu ")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid"))model.summary() model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ======= =================================================== === ========= tumpat_1 (Padat) (Tiada, 50) 500050 _________________________________________________________________ tercicir_1 (Tiada, 50) 0 _________________________________________________________________ tumpat_2 (Tiada) (Tiada, 50) 2550 _________________________________________________________________ tercicir_2 (Tiada jatuh) , 50) 0 _________________________________________________________________ tumpat_3 (Tumpat) (Tiada, 50) 2550 _________________________________________________________________ tumpat_4 (Tumpat) (Tiada, 1) 51 ============= =========== ============================ Jumlah param: 505,201 Param boleh dilatih: 505,201 Param tidak boleh dilatih : 0 _________________________________________________________________

Sekarang kita perlu menyusun model kita, iaitu, pada asasnya menyediakannya untuk latihan. Kami akan gunakan pengoptimum "adam". Pengoptimum ialah algoritma yang mengubah berat dan berat sebelah semasa latihan. Sebagai fungsi kehilangan Kami menggunakan entropi silang binari (memandangkan kami bekerja dengan pengelasan binari), ketepatan sebagai metrik penilaian.

Model.compile(pengoptimum = "adam", loss = "binary_crossentropy", metrik = ["ketepatan"])

Sekarang kita boleh melatih model kita. Kami akan melakukan ini dengan saiz kumpulan 500 dan hanya dua zaman seperti yang saya ketahui model mula melatih semula, jika anda melatihnya lebih lama. Saiz kelompok menentukan bilangan elemen yang akan diedarkan ke seluruh rangkaian, dan zaman adalah satu laluan melalui semua elemen set data. Biasanya saiz yang lebih besar batch membawa kepada pembelajaran yang lebih pantas, tetapi tidak selalunya kepada penumpuan yang cepat. Saiz kelompok yang lebih kecil berlatih dengan lebih perlahan, tetapi boleh menumpu lebih cepat. Pilihan satu atau yang lain pasti bergantung pada jenis masalah yang diselesaikan, dan lebih baik mencuba setiap daripada mereka. Jika anda baru dalam hal ini, saya cadangkan anda menggunakan dahulu saiz lot 32, yang merupakan sejenis standard.

Keputusan = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) Latih pada 40000 sampel, sahkan pada 10000 sampel Epoch 1/2 40000/40000 [======== =======================] - 5s 129us/step - loss: 0.4051 - acc: 0.8212 - val_loss: 0.2635 - val_acc: 0.8945 Epoch 2/2 40000 /40000 [==========================================] - 4s 90us/step - loss: 0.2122 - acc: 0.9190 - val_loss: 0.2598 - val_acc: 0.8950

Mari kita nilai prestasi model:

Print(np.mean(results.history["val_acc"])) 0.894750000536

Hebat! kami model ringkas telah pun memecahkan rekod ketepatan dalam artikel 2011 disebut di awal post. Jangan ragu untuk mencuba parameter rangkaian dan bilangan lapisan.

Kod model lengkap diberikan di bawah:

Import numpy sebagai np daripada keras.utils import to_categorical daripada model import keras daripada lapisan import keras daripada import imdb keras.datasets (data_latihan, sasaran_latihan), (data_pengujian, sasaran_pengujian) = imdb.load_data(num_words=10000) data = np.concatenate( (data_latihan, data_pengujian), paksi=0) sasaran = np.concatenate((training_targets, testing_targets), axis=0) def vectorize(jujukan, dimensi = 10000): keputusan = np.sifar((len(jujukan), dimensi) ) untuk i, jujukan dalam enumerate(jujukan): keputusan = 1 data hasil pulangan = vektorize(data) sasaran = np.array(sasaran).astype("float32") test_x = data[:10000] test_y = sasaran[:10000 ] train_x = data train_y = model sasaran = model.Sequential() # Input - Layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add( layers.Dropout(0.3, noise_shape=Tiada, seed=None)) model.add(layers.Dense(50, activation = "relu")) model.add(layers.Dropout(0.2, noise_shape=None, seed=None) ) model.add(layers.Dense(50, activation = "relu")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid")) model.summary() # menyusun model model. compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["acuracy"]) results = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) print( "Ujian-Ketepatan:", np.mean(results.history["val_acc"]))

Keputusan

Anda mempelajari apa itu analisis sentimen dan sebab Keras ialah salah satu perpustakaan pembelajaran mendalam yang paling popular.

Kami mencipta rangkaian saraf mudah dengan enam lapisan yang boleh mengira sentimen pengulas filem dengan ketepatan 89%. Kini anda boleh menggunakan model ini untuk menganalisis sentimen binari dalam sumber lain, tetapi untuk melakukan ini anda perlu menjadikan saiznya sama dengan 10,000 atau menukar parameter lapisan input.

Model ini (dengan pengubahsuaian kecil) boleh digunakan untuk masalah pembelajaran mesin yang lain.

Rangkaian saraf tiruan (ANN) adalah model matematik, serta pelaksanaan perisian atau perkakasan mereka, dibina berdasarkan prinsip organisasi dan fungsi rangkaian saraf biologi - rangkaian sel saraf organisma hidup.
ANN ialah sistem yang berhubung dan berinteraksi pemproses mudah(neuron buatan).

Rangkaian saraf tidak diprogramkan dalam erti kata biasa, ia dilatih. Keupayaan untuk belajar adalah salah satu kelebihan utama rangkaian saraf berbanding algoritma tradisional. wikipedia

Rangkaian saraf telah diilhamkan oleh otak kita sendiri. Model neuron standard telah dicipta lebih daripada lima puluh tahun yang lalu dan terdiri daripada tiga bahagian utama:

Pergigian- bertanggungjawab untuk mengumpul isyarat masuk;
Soma- bertanggungjawab untuk pemprosesan utama dan penjumlahan isyarat;
Akson- bertanggungjawab untuk menghantar isyarat kepada dendrit lain.

Kerja neuron boleh digambarkan seperti ini: dendrit mengumpul isyarat yang diterima daripada neuron lain, kemudian somas melakukan penjumlahan dan pengiraan isyarat dan data, dan akhirnya, berdasarkan hasil pemprosesan, mereka boleh "memberitahu" akson untuk menghantar isyarat lebih jauh. Pemindahan selanjutnya bergantung kepada beberapa faktor, tetapi kita boleh memodelkan tingkah laku ini sebagai fungsi pemindahan yang mengambil input, memprosesnya dan menyediakan output jika sifat fungsi pemindahan itu berpuas hati.

Neuron biologi adalah sistem yang kompleks, model matematik yang masih belum dibina sepenuhnya. Banyak model telah diperkenalkan, berbeza dalam kerumitan pengiraan dan persamaan dengan neuron sebenar. Salah satu yang paling penting ialah neuron formal (FN). Walaupun kesederhanaan fungsi fungsi, rangkaian yang dibina daripada neuron tersebut boleh membentuk fungsi multidimensi sewenang-wenangnya pada output (sumber: Zaentsev I.V. Rangkaian Neural: model asas).

Neuron terdiri daripada penambah berwajaran dan unsur tak linear. Fungsi neuron ditentukan oleh formula:

Neuron mempunyai beberapa isyarat input x dan satu isyarat keluaran KELUAR. Parameter neuron yang menentukan operasinya ialah: vektor pemberat w, tahap ambang θ dan jenis fungsi pengaktifan F.

Rangkaian saraf menarik perhatian kerana keupayaan berikut:

mampu menyelesaikan masalah yang sukar untuk diformalkan;
prinsip operasi selari adalah wujud, yang sangat penting apabila memproses jumlah data yang besar;
keupayaan pembelajaran dan keupayaan generalisasi;
toleransi untuk kesilapan;

Ciri-ciri utama rangkaian saraf termasuk:

Keupayaan untuk belajar. Rangkaian saraf tidak diprogramkan, tetapi dilatih melalui contoh. Setelah isyarat input dibentangkan (mungkin bersama-sama dengan output yang diperlukan), rangkaian melaraskan parameternya untuk memberikan respons yang diperlukan.

Generalisasi. Tindak balas rangkaian selepas latihan mungkin agak tidak sensitif kepada perubahan kecil dalam isyarat input. Keupayaan yang wujud untuk "melihat" corak melalui hingar dan herotan adalah sangat penting untuk pengecaman corak Adalah penting untuk ambil perhatian bahawa rangkaian saraf tiruan membuat generalisasi secara automatik kerana reka bentuknya, dan bukannya melalui penggunaan "kecerdasan manusia" dalam. bentuk program komputer yang ditulis khas.

Paralelisme. Maklumat pada rangkaian diproses secara selari, yang memungkinkan untuk melakukan pemprosesan data yang agak kompleks menggunakan sejumlah besar peranti mudah.

Kebolehpercayaan yang tinggi. Rangkaian boleh berfungsi dengan betul walaupun beberapa neuron gagal, disebabkan oleh fakta bahawa pengiraan dilakukan secara tempatan dan selari.

Algoritma untuk menyelesaikan masalah menggunakan perceptron berbilang lapisan(sumber: Zaentsev I.V. Rangkaian saraf: model asas)

Untuk membina perceptron berbilang lapisan, anda perlu memilih parameternya. Selalunya, memilih nilai berat dan ambang memerlukan latihan, i.e. perubahan langkah demi langkah pekali pemberat dan tahap ambang.

Algoritma penyelesaian umum:

Tentukan maksud yang dimasukkan ke dalam komponen vektor input x. Vektor input mesti mengandungi keadaan rasmi masalah, i.e. semua maklumat yang diperlukan untuk mendapatkan jawapan.
Pilih vektor keluaran y sedemikian rupa sehingga komponennya mengandungi jawapan lengkap untuk tugas itu.
Pilih jenis ketaklinearan dalam neuron (fungsi pengaktifan). Dalam kes ini, adalah dinasihatkan untuk mengambil kira spesifik tugas, kerana pilihan yang baik akan mengurangkan masa latihan.
Pilih bilangan lapisan dan neuron dalam satu lapisan.
Tetapkan julat perubahan dalam input, output, berat dan tahap ambang, dengan mengambil kira set nilai fungsi pengaktifan yang dipilih.
Berikan nilai awal kepada pemberat dan tahap ambang dan parameter tambahan(contohnya, kecuraman fungsi pengaktifan jika ia dilaraskan semasa latihan). Nilai awal tidak boleh besar supaya neuron tidak menjadi tepu (di bahagian mendatar fungsi pengaktifan), jika tidak, pembelajaran akan menjadi sangat perlahan. Nilai awal tidak boleh terlalu kecil supaya output kebanyakan neuron tidak sama dengan sifar, jika tidak pembelajaran juga akan menjadi perlahan.
Mengendalikan latihan, i.e. pilih parameter rangkaian supaya masalah diselesaikan cara yang paling baik. Setelah latihan selesai, rangkaian bersedia untuk menyelesaikan masalah dari jenis yang ia telah dilatih.
Hantarkan syarat masalah kepada input rangkaian dalam bentuk vektor x. Kira vektor keluaran y, yang akan memberikan penyelesaian rasmi kepada masalah tersebut.

Masalah yang perlu diselesaikan

Masalah diselesaikan menggunakan rangkaian saraf ().

Klasifikasi imej. Tugasnya adalah untuk menunjukkan keahlian imej input (contohnya, isyarat pertuturan atau aksara tulisan tangan), yang diwakili oleh vektor ciri, kepada satu atau lebih kelas yang dipratentukan. Aplikasi yang ketara termasuk pengecaman huruf, pengecaman pertuturan, klasifikasi isyarat elektrokardiogram dan klasifikasi sel darah.

Pengelompokan/pengkategorian. Apabila menyelesaikan masalah pengelompokan, yang juga dikenali sebagai klasifikasi imej tanpa pengawasan, tiada set latihan dengan label kelas. Algoritma pengelompokan adalah berdasarkan persamaan imej dan meletakkan imej yang serupa ke dalam satu kelompok. Terdapat kes yang diketahui menggunakan pengelompokan untuk mengekstrak pengetahuan, memampatkan data dan mengkaji sifat data.

Penghampiran fungsi. Katakan terdapat sampel latihan ((x1,y1), (x2,y2)..., (xn,yn)) (pasangan data input-output) yang dijana oleh fungsi yang tidak diketahui (x) yang rosak oleh hingar. Masalah penghampiran adalah untuk mencari anggaran untuk fungsi yang tidak diketahui (x). Penghampiran fungsi adalah perlu dalam menyelesaikan banyak masalah pemodelan kejuruteraan dan saintifik.

Ramalan/Ramalan. Biarkan n sampel diskret (y(t1), y(t2)..., y(tn)) diberikan pada momen masa berturut-turut t1, t2,..., tn. Tugasnya ialah untuk meramalkan nilai y(tn+1) pada masa hadapan tn+1. Ramalan/ramalan mempunyai kesan yang besar terhadap pembuatan keputusan dalam perniagaan, sains dan teknologi. Meramalkan harga pasaran saham dan ramalan cuaca adalah aplikasi tipikal teknik ramalan/ramalan.

Pengoptimuman. Banyak masalah dalam matematik, statistik, kejuruteraan, sains, perubatan dan ekonomi boleh dianggap sebagai masalah pengoptimuman. Tugas algoritma pengoptimuman adalah untuk mencari penyelesaian yang memenuhi sistem kekangan dan memaksimumkan atau meminimumkan fungsi sasaran. Masalah jurujual perjalanan, yang tergolong dalam kelas NP-lengkap, adalah contoh klasik masalah pengoptimuman.

Memori yang boleh dialamatkan kandungan. Dalam model pengkomputeran von Neumann, memori hanya diakses melalui alamat, yang tidak bergantung pada kandungan memori. Selain itu, jika ralat dibuat dalam mengira alamat, maklumat yang sama sekali berbeza mungkin ditemui. Ingatan bersekutu, atau memori boleh alamat kandungan, boleh diakses dengan menentukan kandungan tertentu. Kandungan memori boleh dipanggil semula walaupun dengan input separa atau kandungan yang rosak. Memori bersekutu amat diperlukan apabila mencipta pangkalan data maklumat multimedia.

Kawalan. Mari kita pertimbangkan sistem dinamik, ditentukan oleh set (u(t), y(t)), dengan u(t) ialah tindakan kawalan input, dan y(t) ialah output sistem pada masa t. Dalam sistem kawalan dengan model rujukan Matlamat kawalan adalah untuk mengira tindakan input u(t) supaya sistem mengikut trajektori yang dikehendaki yang ditentukan oleh model rujukan. Contohnya ialah kawalan enjin yang optimum.

Jenis seni bina

Seni bina rangkaian saraf- cara organisasi dan komunikasi elemen individu rangkaian saraf (neuron). Perbezaan seni bina antara neuron itu sendiri terletak terutamanya pada penggunaan fungsi pengaktifan (pengujaan) yang berbeza. Berdasarkan seni bina sambungan, rangkaian saraf boleh dibahagikan kepada dua kelas: rangkaian suapan hadapan dan rangkaian berulang.

Klasifikasi rangkaian neural buatan mengikut seni binanya ditunjukkan dalam rajah di bawah.

Pengelasan serupa, tetapi sedikit berkembang

Rangkaian pengedaran isyarat hadapan (rangkaian penghantaran ke hadapan)- rangkaian saraf tanpa maklum balas (gelung). Dalam rangkaian sedemikian, pemprosesan maklumat adalah satu arah: isyarat dihantar dari lapisan ke lapisan dalam arah dari lapisan input rangkaian saraf ke lapisan output. Isyarat keluaran (tindak balas rangkaian) dijamin melalui bilangan langkah yang telah ditetapkan (sama dengan bilangan lapisan). Rangkaian Feedforward mudah dilaksanakan dan dikaji dengan baik. Untuk menyelesaikan masalah kompleks mereka memerlukan sejumlah besar neuron.

jadual perbandingan persepsi berbilang lapisan Dan rangkaian RBF

Perceptron berbilang lapisan	rangkaian RBF
Sempadan keputusan ialah persilangan hyperplanes	Sempadan keputusan ialah persimpangan hipersfera, yang mentakrifkan sempadan bentuk yang lebih kompleks
Topologi kompleks sambungan antara neuron dan lapisan	Rangkaian saraf 2 lapisan mudah
Algoritma pembelajaran kompleks dan penumpuan perlahan	Prosedur pembelajaran pantas: menyelesaikan sistem persamaan + pengelompokan
Bekerja pada sampel latihan kecil	Sejumlah besar data latihan diperlukan untuk hasil yang boleh diterima
Kesejagatan aplikasi: pengelompokan, penghampiran, kawalan, dsb.	Biasanya hanya berfungsi penghampiran dan pengelompokan

Nilai terbitan mudah dinyatakan melalui fungsi itu sendiri. Pengiraan derivatif pantas mempercepatkan pembelajaran.

Keluk Gaussian

Ia digunakan dalam kes di mana tindak balas neuron harus maksimum untuk beberapa nilai BERSIH tertentu.

Modul Python untuk rangkaian saraf

Contoh mudah

Sebagai contoh, saya akan memberikan rangkaian neural ringkas (simple perceptron), yang selepas latihan akan dapat mengenali objek terbang, bukan semua, tetapi sahaja burung camar:), semua imej input lain akan diiktiraf sebagai UFO.

# pengekodan=utf8 import kelas rawak NN: def __init__(self, threshold, size): """ Tetapkan parameter awal. """ self.threshold = threshold self.size = size self.init_weight() def init_weight(self) : """ Mulakan matriks pemberat dengan data rawak. """ self.weights = [ untuk j dalam xrange(self.size)] def check(self, sample): """ Baca isyarat output untuk imej sampel. Jika vsum > self. maka kita boleh mengandaikan bahawa sampel mengandungi imej burung camar """ vsum = 0 untuk i dalam xrange(self.size): untuk j dalam xrange(self.size): vsum += self. .weights[i][j] * sample[i][j] if vsum > self.threshold: return True else: return False def teach(self, sample): """ Melatih rangkaian saraf. """ untuk i dalam xrange(self.size): untuk j dalam xrange(self.size): self.weights[i][j] += sample[i][j] nn = NN(20, 6) # Latih rangkaian saraf. tsample1 = [ , , , , , , ] nn.teach(tsample1) tsample2 = [ , , , , , , ] nn.teach(tsample2) tsample3 = [ , , , , , , ] nn.teach(tsample3) tsample4 = [ , , , , , , ] nn.teach(tsample4) # Mari semak perkara yang boleh dilakukan oleh rangkaian saraf. # Mari hantar imej burung camar, yang hampir serupa dengan imej yang diketahui oleh perceptron. wsample1 = [ , , , , , , ] cetak u"camar" jika nn.check(wsample1) jika tidak u"UFO" # Hantar imej yang tidak diketahui. wsample2 = [ , , , , , , ] print u"seagull" jika nn.check(wsample2) else u"UFO" # Kami akan menghantar imej burung camar, yang hampir serupa dengan imej yang diketahui oleh perceptron. wsample3 = [ , , , , , , ] cetak u"camar" jika nn.check(wsample3) jika tidak u"UFO"