Keras

Antara Pemalam yang paling berkesan dan mesra pengguna untuk membina algoritma pembelajaran mendalam ialah rangka kerja saraf tiruan tinggi berasaskan Python yang dipanggil Keras, yang akan dibina di atas rangka kerja pembelajaran mendalam yang terkenal seperti TensorFlow atau CNTK. Untuk membolehkan penerokaan lebih pantas menggunakan rangkaian saraf yang lebih dalam, ia direka bentuk mesra pengguna, boleh dipanjangkan dan boleh disesuaikan. Ia mengendalikan kedua-dua Rangkaian Feedforward dan Retractable secara berasingan, serta dalam kombo. Ia menggunakan pakej Backend untuk menangani operasi kecil kerana ia tidak dapat mengurusnya. Penggunaan Keras, asas pembelajaran mendalam, struktur Keras, lapisan Keras, pakej Keras dan pengaturcaraan masa nyata akan diliputi dalam pelajaran ini.

Sediakan Keras pada Linux

Langkah 01: Kemas Kini Sistem

Sebelum melakukan demonstrasi penuh penggunaan perpustakaan 'Keras' Python, kami perlu mengemas kini sepenuhnya mesin Linux kami untuk memudahkan pemasangan selanjutnya. Untuk tujuan ini, kita perlu membuka aplikasi 'konsol' dengan cepat daripada aplikasi terbina dalam sistem. Dalam kawasan pertanyaan tertentu, kami telah menambahkan pertanyaan 'kemas kini' Linux dengan utiliti 'apt' dan keistimewaan 'sudo' untuk mengemas kini sistem yang kami ada dengan cepat. Ia memerlukan kata laluan pengguna kami untuk meneruskan proses ini supaya sistem kami boleh dikemas kini dengan betul.

Langkah 02: Pasang Python dan Pip

Untuk penggunaan Pembelajaran Dalam melalui Keras dan TensorFlow, kami mesti mempunyai versi terkini Python yang dikonfigurasikan pada mesin kami. Oleh itu, kami mula memasang pakej kemas kini Python bersama-sama dengan utiliti 'pip' yang diperlukan pada sistem kami. Untuk itu, kita perlu sekali lagi menggunakan utiliti 'apt' sistem Linux Ubuntu 20.04 dalam pertanyaan 'pasang' pada shell diikuti dengan nama pakej yang akan dipasang, iaitu, Python3 dan Python3-pip. Pada pelaksanaan pertanyaan mudah ini pada kawasan konsol, sistem akan mula memasang dan mengkonfigurasi kedua-dua pakej dalam sistem kami.

Sebaliknya, jika sistem anda mempunyai versi lama utiliti 'pip' untuk Python yang dipasang, anda harus mengemas kininya sebelum bergerak ke hadapan.

Selepas konfigurasi Python yang berjaya dan utiliti 'pip', sudah tiba masanya untuk menaik taraf Setuptools untuk Python untuk mengelakkan sebarang masalah dalam masa terdekat. Oleh itu, kami telah mencuba pertanyaan pemasangan dengan utiliti 'pip3' dan pilihan -upgrade untuk memasang naik taraf Setuptools, iaitu, alat persediaan. Ia meminta kata laluan semasa yang kami ada untuk sistem kami, dan kami telah menambahkannya.

Langkah 03: Pasang TensorFlow

Untuk membina pembelajaran mesin dan model saraf yang diselia, TensorFlow ialah pakej matematik simbolik yang paling terkenal. Selepas melalui pemasangan, kami telah melaksanakan pertanyaan pemasangan 'pip3' yang sama diikuti dengan nama pakej 'Tensorflow'.

Utiliti lain yang berkaitan dengan TensorFlow diperlukan untuk dipasang sepenuhnya pada sistem. Utiliti tersebut akan dipasang bersama dengan TensorFlow, dan ia mungkin mengambil masa sehingga 10 minit atau lebih.

Langkah 04: Pasang Pakej Penting

Selepas konfigurasi TensorFlow yang berjaya dalam sistem Ubuntu 20.04, kami juga perlu mengkonfigurasi beberapa pakej binaan bersama beberapa utiliti lain seperti 'git' dan 'cmake'. Dengan mencuba alat 'apt' yang sama, kami telah memasang banyak pakej yang diperlukan, seperti yang ditunjukkan di bawah:

Langkah ini mengambil perhatian kami sepenuhnya dengan mengesahkan pemasangan ini. Ketik 'y' dan teruskan.

Langkah 05: Cipta Persekitaran Maya

Selepas pemasangan yang diperlukan, sudah tiba masanya untuk mencipta persekitaran maya. Oleh itu, kita perlu menggunakan utiliti Python3 dengan pilihan '-m' untuk mencipta persekitaran maya 'kerasenv' melalui pembolehubah 'venv'. Pertanyaan 'ls' menunjukkan bahawa persekitaran dicipta.

Sekarang, kita perlu bergerak dalam persekitaran maya folder Keras. Jadi, kami telah menggunakan arahan 'cd' bersama-sama dengan nama folder persekitaran maya. Selepas itu, kami telah bergerak dalam folder 'bin' persekitaran maya ini dan menyenaraikan subnya. Untuk mengaktifkan persekitaran Python ini, kami mencuba arahan 'sumber' di kawasan pertanyaannya bersama-sama dengan fail 'aktifkan'. Persekitaran Maya diaktifkan dengan nama 'kerasenv'.

Langkah 06: Pasang Perpustakaan Python

Selepas menetapkan persekitaran maya Python dengan jayanya, anda perlu memasang semua perpustakaan Python yang diperlukan sebelum pemasangan Keras. Oleh itu, kami telah memasang perpustakaan panda terlebih dahulu dalam persekitaran maya yang sama menggunakan pakej 'pip' Python.

Sistem akan mula mengkonfigurasinya dalam persekitaran maya Python, seperti yang ditunjukkan dalam imej:

Selepas memasang perpustakaan panda, cuba pasang perpustakaan NumPy menggunakan kaedah berikut:

Dengan cara yang hampir sama, pasang perpustakaan scipy Python dalam persekitaran yang sama.

Sekarang, pasang perpustakaan matplotlib Python dalam persekitaran.

Python menggunakan algoritma pengelompokan dan regresi dalam pembelajaran mesin untuk melaksanakan model rangkaian saraf. Untuk ini, ia mempunyai perpustakaan pembelajaran sci-kit yang kami pasang dengan utiliti 'pip' bersama-sama dengan pilihan '-u' untuk mengkonfigurasi pakej yang diperlukan juga.

Pemprosesan pemasangan perpustakaan scikit telah ditunjukkan di bawah:

Untuk visualisasi dalam pembelajaran mendalam, kami memerlukan perpustakaan Python yang dilahirkan di laut untuk dipasang. Oleh itu, kami telah memasangnya dalam persekitaran yang sama dengan pertanyaan 'pasang'.

Langkah 07: Pasang Perpustakaan Keras

Selepas pemasangan semua perpustakaan prasyarat Python yang diperlukan, kami akhirnya boleh memasang Keras dalam persekitaran Maya Python. Utiliti 'pip' akan digunakan untuk tujuan ini dalam pertanyaan 'pasang' kami dengan nama modul, iaitu, 'Keras'. Jika sistem menunjukkan bahawa keperluannya sudah dipenuhi, ini bermakna ia sudah dipasang dan dikonfigurasikan.

Jika ia belum dipasang, pertanyaan ini akan mula memuat turun dan mengkonfigurasinya dalam persekitaran maya tanpa berlengah satu saat dan pemprosesan akan dipaparkan, seperti di bawah:

Selepas konfigurasi penuh dan pemasangan perpustakaan 'Keras' pada Persekitaran Maya, tiba masanya untuk menunjukkan maklumat penuh mengenainya pada shell melalui pertanyaan 'pertunjukan pip'. Pelaksanaan pertanyaan 'tunjukkan' ini telah mempersembahkan versi Keras yang dipasang dalam persekitaran maya Python kami, namanya, ringkasannya, halaman utama webnya, pengarang, e-mel pengarang, lesen, lokasi yang digunakan pada sistem kami dan banyak lagi. lebih lanjut seperti yang dibentangkan di bawah:

Selepas pemasangan terbaik perpustakaan Keras dan TensorFlow Python, kita perlu keluar dari persekitaran maya. Untuk itu, cuba pertanyaan 'nyahaktifkan' pada shell dan berhenti.

Langkah 08: Pasang Awan Anaconda

Python mempunyai awan bernama 'Anaconda' yang diperlukan untuk membina contoh rangkaian saraf dalam Python. Oleh itu, kami telah memuat turun fail pelaksanaannya ke sistem kami.

Fail ini telah berada dalam folder utama semasa mesin Linux mengikut pertanyaan 'ls'. Anda perlu memastikan ia adalah checksum terlebih dahulu, iaitu, jika ia betul sepenuhnya atau tidak melalui pertanyaan sha256sum.

Selepas itu, kami perlu memasang fail Bash anaconda yang dimuat turun dalam sistem kami menggunakan arahan 'Bash' dan nama fail pada konsol yang sama. Ia telah meminta kami menyemak perjanjian lesen sebelum pemasangan. Jadi, kami mengetik 'Enter' untuk meneruskan.

Selepas melalui perjanjian lesennya, ia meminta kami mengetik 'ya' jika kami bersetuju dengan syarat tersebut. Anda perlu menekan Enter untuk terus memasangnya di tempat yang sama atau menulis laluan ke direktori tempat anda ingin memasangnya. Jika tidak, gunakan 'Ctrl-c' untuk membatalkan pemasangan.

Ia akan memaparkan senarai panjang pakej yang akan dipasang dalam proses ini. Selepas beberapa pelaksanaan transaksi, ia akan mula memasang pakej.

Selepas beberapa ketika, anaconda berjaya dipasang dengan pakej tambahannya.

Anda perlu menjalankan fail 'aktifkan' dari folder anaconda melalui pertanyaan 'sumber' sebagai akar.

Cuba lancarkan navigator anaconda menggunakan pertanyaan berikut.

Untuk mencipta dan mengusahakan persekitaran konda baharu, cuba arahan 'buat konda' dengan pilihan nama diikuti dengan nama persekitaran baharu, iaitu, PyCPU.

Proses ini memerlukan pengesahan kami tentang penciptaan persekitaran baharu. Ketik “y”.

Untuk mengaktifkan dan menjalankan persekitaran conda yang baru dibuat, gunakan pertanyaan 'conda activate' dengan nama persekitaran baharu anda, iaitu, persekitaran PyCPU kini diaktifkan.

Langkah 09: Pasang Spyder IDE

IDE Spyder mesti dipasang dalam persekitaran ini untuk pelaksanaan program Python. Untuk ini, kami telah mencuba pertanyaan pemasangan conda pada shell persekitaran PyCPU dengan kata kunci 'spyder'.

Ketik 'y' untuk terus memasang Spyder.

Langkah 10: Pasang Perpustakaan Pandas dan Keras

Selepas pemasangan Spyder, pasang perpustakaan Python panda dalam persekitaran anaconda menggunakan pertanyaan pemasangan conda dengan pilihan –c.

Sekali lagi, tekan butang 'y' untuk meneruskan.

Selepas konfigurasi panda berjaya, pasang pustaka Keras dengan pertanyaan yang sama.

Teruskan selepas mengklik butang 'y'.

Anda boleh melancarkan IDE Spyder dalam konsol persekitaran semasa anaconda seperti berikut:

IDE Spyder telah bersedia untuk dilancarkan.

Folder tersembunyi '.keras' telah terletak dalam direktori rumah. Nyahsembunyikannya dan buka fail 'keras.json' untuk menambah konfigurasi berikut di dalamnya.

Sediakan Keras dan TensorFlow pada Windows

Untuk menyediakan Keras dan TensorFlow dalam persekitaran Windows, anda perlu memastikan bahawa bahasa Python bersama-sama dengan perpustakaan 'pip' dan Anaconda Navigator telah disediakan padanya. Selepas menyediakannya, anda sepatutnya membukanya dari kawasan carian anda dan bergerak dalam tab 'persekitaran'. Dalam tab ini, anda akan menemui nama persekitaran yang sedang anda kerjakan iaitu pangkalan. Di kawasan di bawah, anda akan menemui tab berikut. Ketik pilihan 'buat'.

Di sini, anda perlu mencipta nama persekitaran baharu 'TensorFlow', iaitu, kini berada di dalam persekitaran asas. Pilih versi terkini Python untuk digunakan dan ketik butang 'Buat' untuk meneruskan.

Anda akan melihat bahawa persekitaran telah mula dimuatkan.

Selepas beberapa ketika, persekitaran TensorFlow akan dipasang sepenuhnya.

Dari kawasan paling kirinya, anda boleh melihat semua perpustakaan dan modul yang dipasang dan tersedia untuk Python, seperti yang dibentangkan di bawah:

Sekarang, kita perlu memasang perpustakaan belakang TensorFlow Python menggunakan kawasan ini. Dalam bar carian, tulis 'TensorFlow' dan tandai pakej kes yang sama daripada senarai yang ditunjukkan untuk memasangnya. Ketik pada butang 'Guna' untuk meneruskan pemasangan TensorFlow bersama-sama dengan sub-modulnya seperti 'Keras'.

Ia telah mula berfungsi dan mengkonfigurasi TensorFlow pada persekitaran Anaconda kami.

Semasa pemasangan, ia akan memaparkan senarai sub-pakej yang akan dipasang pada persekitaran Anaconda. Tepuk butang 'Guna' dan tunggu sebentar sehingga ia selesai.

Selepas beberapa ketika, anda akan menemui semua pakej yang dipasang di kawasan modul yang sama. Anda boleh melihat bahawa perpustakaan Keras telah dipasang dengan pakej lain dan kami tidak perlu memasangnya sekarang.

Dari bar Carian Windows, cari kata kunci 'Jupyter'. Aplikasi bernama 'Jupyter Notebook (TensorFlow)' akan ditunjukkan bersama-sama dengan yang lain. Ketik padanya untuk melancarkan Buku Nota jupyter dengan TensorFlow bahagian belakang didayakan. Buat fail Python baharu dan mula bekerja.

Pembelajaran Mendalam Melalui Keras

Pembelajaran mendalam termasuk analisis lapisan demi lapisan pengambilan, dengan setiap lapisan secara beransur-ansur mengekstrak butiran peringkat lanjutan daripada input. Rangka kerja penuh disediakan oleh Keras untuk membentuk sebarang jenis rangkaian saraf. Kedua-duanya kreatif dan sangat mudah untuk difahami, Keras. Ia membolehkan model rangkaian saraf daripada yang paling naif kepada kompleks terbesar dan tertinggi.

Rangkaian Neural Buatan (ANN)

Metodologi 'Rangkaian Neural Buatan' (ANN) nampaknya merupakan kaedah pembelajaran mendalam yang paling banyak digunakan dan asas. Mereka mengambil isyarat mereka daripada minda manusia, komponen semula jadi yang paling rumit badan kita, yang berfungsi sebagai model mereka. Lebih 90 bilion sel mikroskopik yang dipanggil 'neuron' membentuk otak individu. Akson dan dendrit adalah jenis gentian saraf yang menghubungkan neuron bersama. Fungsi utama akson adalah untuk menghantar data dari satu neuron yang dipautkan ke yang seterusnya. Untuk maklumat lanjut, sila cari dari Enjin Carian Google.

Seni Bina Keras

Seni bina API Keras telah dikelaskan kepada tiga bahagian utama yang disenaraikan di bawah. Mari kita ambil samaran pada setiap satu dengan jelas.

• Model
• Lapisan
• Modul Teras

Model Keras

Model Keras terdiri daripada dua jenis, iaitu API berurutan dan berfungsi.

Model Berjujukan

Pada asasnya, model berjujukan ialah kompilasi kronologi Lapisan Keras. Model jujukan ringkas dan ringkas boleh menerangkan hampir semua rangkaian saraf yang sedang digunakan. Model tersuai boleh dibuat menggunakan kelas Model yang ditunjukkan oleh model berjujukan. Pendekatan subkelas boleh digunakan untuk membina model canggih kita sendiri. Demonstrasi model berjujukan telah dibentangkan di bawah.

Tambah Lapisan

Skrip telah dimulakan daripada import mod jujukan melalui keras.models dan baris lain telah mencipta model berjujukan. Selepas itu, mengimport lapisan padat mencipta lapisan input dan menambah lapisan input kepada model. Lapisan tumpat tersembunyi telah dibuat dan ditambah pada model dan perkara yang sama telah dilakukan untuk lapisan tumpat keluaran.

Akses Model

Anda boleh mendapatkan maklumat mengenai lapisan model anda, data input yang telah digunakan dan data outputnya. Fungsi model.layers membolehkan anda mengakses semua lapisan. Model.inputs akan menunjukkan tensor input, dan model.output akan memaparkan tensor output.

Sirikan Model

Adalah mudah untuk mengembalikan model yang digunakan dalam skrip sebagai objek atau JSON. Sebagai contoh, fungsi get_config() menghasilkan model sebagai entiti/objek. Fungsi from_config() mencipta model baharu menggunakan objek sebagai nilai parametrik.

Anda juga boleh menukar model anda kepada JSON menggunakan fungsi to_json().

Ringkasan Model

Untuk mendapatkan keseluruhan ringkasan mengenai lapisan yang digunakan dalam model bersama-sama dengan beberapa maklumat tambahan, panggil fungsi summary().

Latih dan Ramalkan Model

Untuk melatih dan meramal, kita harus menggunakan fungsi penyusunan, fungsi muat, menilai fungsi, dan fungsi ramalan dalam hal ini.

Lapisan Keras

Setiap lapisan input, tersembunyi dan hasil dalam model rangkaian saraf yang dicadangkan sepadan dengan lapisan Keras yang berbeza dalam model sebenar. Mana-mana rangkaian saraf yang canggih boleh dibangunkan dengan cepat menggunakan banyak lapisan pra-bina perpustakaan Keras. Terdapat pelbagai lapisan Keras yang kami ada, iaitu, lapisan teras, lapisan gabungan, lapisan berulang dan lapisan lilitan. Anda boleh mempelajarinya dengan mencari di web. Dua baris pertama telah mengimport mod Sequential, padat, pengaktifan dan lapisan Dropout.

Kami telah mencuba Sequential() API untuk mencipta model sequential dropout. Dengan membuang model pengaktifan 'relu' kami telah mencipta lapisan padat melalui API 'Padat'. Untuk memenuhi kesesuaian lapisan padat yang berlebihan, kami telah menggunakan API Dropout(), iaitu, lapisan dropout melalui fungsi dropout(). Selepas ini, kami telah menggunakan lapisan yang lebih padat di sini dengan model pengaktifan 'relu'. Untuk mengendalikan lapisan padat daripada pemasangan berlebihan, kita perlu menggunakan lapisan Tercicir. Pada akhirnya, kami telah membuang lapisan padat terakhir kami menggunakan model pengaktifan jenis 'softmax'.

Pernahkah anda melakukan pelapisan semasa memasak? Jika ya, maka konsep ini tidak sukar untuk anda fahami. Hasil daripada satu tahap akan berfungsi sebagai data input untuk lapisan seterusnya. Berikut ialah perkara asas yang diperlukan untuk membina lapisan baharu:

• Bentuk Data Input
• Jumlah neuron/unit dalam satu lapisan
• Pemula
• Regularizers
• Kekangan
• Pengaktifan

Bentuk Data Input

Dalam bahasa Python, setiap jenis input telah ditukar kepada tatasusunan integer dan kemudian ditambahkan pada model algoritma. Dalam Python, kita perlu menentukan bentuk input untuk mendapatkan output mengikut keperluan kita. Dalam contoh berikut, kami telah menentukan bentuk input (3,3), iaitu, 3 baris dan 3 lajur. Output telah memaparkan matriks.

Pemula

Modul pemula bagi Lapisan Keras menyediakan kita dengan banyak fungsi untuk menentukan berat khusus untuk data input. Sebagai contoh, fungsi sifar() menentukan 0 untuk semua, yang () akan menentukan untuk semua, dan fungsi pemalar() akan menentukan nilai pemalar tertentu yang ditambah oleh pengguna untuk semua dan banyak lagi. Untuk pemahaman yang lebih baik, kami telah menggunakan fungsi identiti() untuk menjana matriks identiti. Selebihnya fungsi boleh dicari juga dari enjin carian.

Kekangan

Terdapat fungsi kekangan berbeza yang tersedia untuk menggunakan kekangan pada parameter 'berat' Lapisan, iaitu, bukan negatif, norma unit, norma maks, minmaxnorm dan banyak lagi. Dalam ilustrasi berikut, kami telah menggunakan norma kekangan kurang daripada atau sama dengan berat. Parameter 'nilai_maks' ialah sempadan atas kekangan yang akan digunakan dan paksi ialah dimensi di mana kekangan akan digunakan, iaitu, dimensi 1.

Regularizers

Sepanjang pengoptimuman, ia mengenakan pelbagai caj pada harta lapisan. Ia juga menghasilkan beberapa fungsi untuk berbuat demikian, iaitu, L1 regularizer, L2 regularizer dan 'LI dan L2' Regularizer. Berikut ialah ilustrasi paling mudah bagi fungsi regularizer L1:

Pengaktifan

Fungsi unik yang dipanggil fungsi pengaktifan digunakan untuk menentukan sama ada neuron tertentu aktif atau tidak. Fungsi pengaktifan mengubah data masuk dengan cara yang kompleks, yang membantu neuron belajar dengan lebih berkesan. Berikut adalah beberapa kaedah pengaktifan yang dibentangkan dalam contoh yang disediakan di bawah:

Modul Keras

Seperti yang kita ketahui bahawa modul pengaturcaraan biasanya mengandungi fungsi, kelas, dan pembolehubah untuk digunakan untuk tujuan yang berbeza dan khusus. Sama seperti itu, perpustakaan Keras Python mengandungi banyak modul di dalamnya. Anda boleh mendapatkan semua pengetahuan yang diperlukan tentang modul Keras dari web.

Bahagian belakang

Salah satu modulnya yang paling terkenal dan digunakan ialah modul 'Backend' yang telah direka bentuk untuk menggunakan perpustakaan bahagian belakang Python seperti TensorFlow dan Theano. Menggunakan modul hujung belakang, kami boleh menggunakan sebanyak mungkin fungsi hujung belakang daripada perpustakaan TensorFlow dan Theano. Untuk menggunakan modul perpustakaan bahagian belakang, kita perlu menentukan pustaka bahagian belakang untuk digunakan dalam fail konfigurasi “keras.json, yang telah kami cipta dalam folder .keras tersembunyi. Secara lalai, bahagian belakang telah ditentukan sebagai 'TensorFlow', tetapi anda boleh menukarnya kepada yang lain juga, iaitu, Theano atau CNTK.

Dalam contoh kami, kami akan menggunakan perpustakaan TensorFlow sebagai backend. Untuk memuatkan konfigurasi bahagian belakang daripada fail keras.json folder 'keras' akar, gunakan:

• daripada bahagian belakang import keras sebagai k

Selepas berjaya mengimport bahagian belakang daripada fail keras.json, tiba masanya untuk mendapatkan maklumat bahagian belakang menggunakan pembolehubah 'k' dengan pembolehubah yang akan diambil. Mula-mula, kami telah mengambil nama bahagian belakang yang kami gunakan dan telah diimport menggunakan fungsi 'belakang()'. Ia mengembalikan 'Tensorflow' sebagai nilai backendnya. Untuk mendapatkan nilai apungan bahagian belakang, kami telah memanggil fungsi floatx() melalui objek pembolehubah 'k' Keras. Ia menunjukkan bahawa kita telah menggunakan nilai float32.

Untuk mendapatkan format data imej, gunakan fungsi image_Data_format() dengan pembolehubah 'k'. Apabila menggunakannya, ia menunjukkan bahawa bahagian belakang kami telah menggunakan format data imej 'channels_last'. Untuk mendapatkan kuasa eksponen untuk bahagian belakang, panggil fungsi epsilon() dengan pembolehubah “k”. Ia mengembalikan bahawa bahagian belakang akan menggunakan kuasa eksponen '07'. Itu sahaja tentang pengambilan maklumat bahagian belakang.

Fungsi Get_uid().

Tiba masanya untuk melihat beberapa fungsi bahagian belakang TensorFlow untuk memahami fungsinya. Salah satu fungsi backend yang paling banyak digunakan 'fungsi get_uid() yang digunakan untuk mengenal pasti graf lalai yang telah kami gunakan. Menggunakannya dengan parameter awalan='' akan mengembalikan '1', iaitu, mengikut penggunaan. Sekali lagi, menggunakannya akan mengembalikan '2' kerana kami telah memanggilnya semula dan nilai graf telah dinaikkan. Selepas menggunakan fungsi 'reset_uids', nilai ID pengguna graf akan ditetapkan semula kepada 0. Oleh itu, menggunakan fungsi get_uid() sekali lagi akan menambahnya sebanyak 1.

Fungsi Pemegang tempat().

Tensor telah menggunakan fungsi pemegang tempat() untuk memegang bentuk dimensi yang berbeza di dalamnya. Sebagai contoh, dalam ilustrasi berikut, kami telah menggunakannya untuk menahan imej 3-D dalam tensor melalui pembolehubah Keras 'k' dan menyimpannya ke pembolehubah lain 'd'. Output pembolehubah 'd' menunjukkan sifat bentuk yang digunakan dalam ruang letak.

Fungsi 'int_shape()' digunakan untuk memaparkan bentuk nilai yang disimpan dalam ruang letak 'd'.

Fungsi Titik().

Pernahkah anda mendarab dua vektor? Jika ya, tidaklah sukar bagi anda untuk mendarab dua tensor. Untuk ini, perpustakaan bahagian belakang menghasilkan fungsi 'titik'. Pertama, untuk memegang dua bentuk berbeza, kami telah menggunakan nilai bentuk dalam fungsi pemegang tempat() dalam 2 baris pertama untuk mencipta dua pemegang 'x' dan 'y'. Fungsi dot() telah mengambil pemegang 'x' dan 'y' untuk mendarab kedua-dua tensor dan menyimpan hasilnya kepada pembolehubah lain 'z'. Semasa menggunakan tensor 'z' untuk mencetak, ia memaparkan bentuk tensor terhasil berganda (1, 5) pada skrin.

Fungsi Ones().

Fungsi ones() modul backend telah dikenali kerana memulakan semua nilai bentuk tertentu kepada 1. Sebagai contoh, kami telah menggunakan fungsi ones() pada bentuk tensor (3,3) dan menyimpan hasilnya ke pembolehubah “v”. Fungsi eval() dibuang di sini untuk menilai nilai pembolehubah 'v' dan dipaparkan di dalam persekitaran Python. Sebagai balasan, ia telah menukar bentuk (3,3) kepada matriks tatasusunan semua yang mempunyai jenis data float32.

Fungsi Batch_dot().

Kumpulan tensor akan menentukan jumlah sampel untuk diisih sebelum mengemas kini model. Fungsi batch_dot() bahagian belakang TensorFlow digunakan terutamanya untuk mengetahui hasil pendaraban dua data kelompok berbeza. Oleh itu, kami telah mencipta dua pembolehubah tensor v1 dan v2 dan menggunakan fungsi Input() untuk menyimpannya dalam v1 dan v2 sebagai input. Selepas itu, kami telah mencuba fungsi batch_dot() pada kedua-dua pembolehubah tensor, v1 dan v2, dan nilai paduan akan disimpan ke pembolehubah lain 'v3'. Semasa mencetak pembolehubah v3, kami mendapati bentuk terhasil (2,2) sebagai balasan.

Fungsi Pembolehubah

Jika anda pernah menggunakan mana-mana bahasa lain, anda mungkin telah memulakan banyak pembolehubah dengan kata kunci 'var' atau tanpanya. Banyak kali, anda mungkin telah memulakan pembolehubah dengan jenis datanya seperti integer, rentetan atau aksara. Dalam pustaka Python Keras, kita boleh mencipta sebarang pembolehubah menggunakan fungsi variable() pada beberapa data tensor dalam bentuk sampel.

Dalam imej berikut, kami telah mencipta pembolehubah 'd' dengan menambah sampel dua data senarai ke dalam fungsi pembolehubah() dengan objek Keras 'k'. Selepas menambah pembolehubah ini, kami telah memanggil fungsi transpose() pada pembolehubah ini 'd' untuk mengetahui transpose data sampel di dalamnya melalui objek Keras 'k'. Transpose yang terhasil akan disimpan kepada pembolehubah 'val'. Pernyataan cetakan bahasa Python telah digunakan di sini untuk mencetak nilai pembolehubah paduan 'val'. Pernyataan cetakan telah memaparkan pilihan fungsi yang telah kami gunakan pada pembolehubah 'd' dan jumlah bilangan elemen dalam setiap senarai.

Selepas ini, kami mencuba fungsi 'eval' pada pembolehubah 'val' untuk mendapatkan transpose sampel yang ditambahkan pada pembolehubah 'd' dan fungsi cetakan memaparkannya. Anda boleh melihat transpose dua senarai dalam output.

Ilustrasi kod sebelumnya dicapai dengan menggunakan fungsi Python mudah tanpa mengimport mana-mana perpustakaan Python tertentu. 'Transpose' dua set data boleh dicari menggunakan tatasusunan NumPy. Untuk ini, kita perlu mengimport perpustakaan NumPy sebagai 'n' pada permulaan. Format asas adalah sama, tetapi kita perlu memulakan set data bentuk dengan kata kunci 'tatasusunan' dan bukannya menggunakan kata kunci 'pembolehubah'. Tatasusunan NumPy sampel hendaklah disimpan kembali kepada pembolehubah 'd'. Objek NumPy yang sama 'n' digunakan untuk memanggil fungsi transpose() pada pembolehubah 'd' dan menyimpan hasilnya kepada pembolehubah 'val'.

Pernyataan cetakan telah memanggil pembolehubah 'val' di dalamnya untuk memaparkan tensor transposenya. Anda boleh lihat, untuk memaparkan nilai transpos terhasil bagi pembolehubah 'val', kita tidak memerlukan fungsi 'eval' di sini. Sekarang, kami telah menggunakan fungsi pembolehubah dengan hujah 'd' dan menyimpan hasilnya ke pembolehubah 'z'. Selepas mencuba pernyataan cetak dengan menambah nilai argumen 'z' di dalamnya, ia memaparkan output dalam format sebelumnya yang sama yang telah kami cuba dalam contoh pembolehubah di atas.

Is_sparse() Fungsi

Perkataan 'jarang' dalam tensor digunakan untuk tensor jarang yang mengandungi entri dengan sifar kebanyakannya. Dalam contoh ini, kita akan menggunakan fungsi is_sparse() modul bahagian belakang untuk menyemak sama ada tensor mempunyai kebanyakan sifar atau tidak.

Pertama, kami telah memanggil fungsi pemegang tempat() untuk memegang bentuk tensor (3,3) bersama-sama dengan argumen Jarang ditetapkan kepada benar. Nilai pemegang tempat ini akan disimpan pada 'x' boleh ubah dan dipaparkan. Output telah memaparkan maklumat mengenai pembolehubah pemegang tempat 'x'.

Sebagai contoh, jenis data, bentuk dan fungsinya digunakan padanya. Selepas ini, kami mencuba kenyataan cetakan sekali lagi memanggil fungsi is_Sparse() di dalamnya. Fungsi ini telah mengambil pembolehubah 'x' sebagai hujahnya untuk memaparkan sama ada tensor 'x' jarang atau tidak. Output memaparkan 'benar'.

Fungsi To_dense().

Tensor padat dikatakan yang menggunakan blok kronologi memori untuk menyimpan maklumat dalam cara yang bersebelahan dan mewakili nilai maklumat, juga. Fungsi 'to_dense()' modul hujung belakang membolehkan kami menukar tensor jarang kepada tensor padat. Oleh itu, kami mengambil fungsi pemegang tempat yang sama untuk menambah tensor kepada pembolehubah 'x' dan tensor ini telah ditetapkan kepada 'jarang'.

Fungsi 'to_dense()' digunakan pada pembolehubah tensor padat 'x', iaitu, untuk menukarnya kepada tensor padat dan menyimpannya kepada 'res' pembolehubah yang lain. Sekarang, 'res' ialah tensor padat itu sendiri. Pernyataan cetakan telah dibuang untuk mencetak pembolehubah 'res'. Penggunaan penyata cetakan untuk pembolehubah 'res' memaparkan maklumat mengenai pembolehubah ditukar 'res', iaitu, berjaya menukar jarang kepada padat dan banyak lagi.

Kemudian, fungsi cetakan lain dipanggil dengan menggunakan fungsi is_sparse() di dalamnya untuk menyemak sama ada pembolehubah 'res' jarang atau tidak. Output telah menunjukkan bahawa pembolehubah 'res' tidak jarang, iaitu, kerana kami telah menukarnya kepada tensor 'padat'.

Random_uniform_variable() Function

Fungsi random_uniform_variable() dalam modul backend Keras direka khusus untuk pemulaan tensor melalui pengedaran seragam. Ia memerlukan sejumlah tiga hujah. Hujah pertama 'bentuk' digunakan untuk menentukan baris dan lajur bentuk dalam bentuk tupel. Jika anda telah melakukan matematik, anda mungkin telah mempelajari konsep min dan sisihan piawai.

Dalam kaedah random_uniform_variable(), dua hujah seterusnya ialah sisihan min dan tipikal daripada taburan seragam. Dalam ilustrasi ini, kami telah memulakan dua tensor 'x' dan 'y' menggunakan taburan seragam piawai melalui fungsi random_uniform_variable(). Kedua-dua tensor mengandungi format bentuk yang berbeza, iaitu, baris dan lajur dengan min dan sisihan piawai yang sama, iaitu, rendah=0, dan tinggi=1.

Selepas ini, kami membuang fungsi 'titik' dengan mengambil tensor 'x' dan 'y' di dalamnya untuk pendaraban. Hasil pendaraban ini akan disimpan ke pembolehubah 'z'. Pada akhirnya, int_shape() adalah satu kemestian untuk digunakan untuk memaparkan bentuk hasil tensor 'z'. Output menunjukkan tensor (2,2).

Util

Jika anda ingin menggunakan beberapa fungsi yang sangat berguna daripada konsep pembelajaran mendalam Python, anda mesti menggunakan modul utils perpustakaan Keras dalam skrip anda. Sebagai contoh, jika anda ingin memaparkan data anda dalam format HDF5Matrix, anda perlu mengimport kelas HDF5Matrix dan menggunakan fungsi HDF5Matrix dalam skrip.

Fungsi To_categorical().

Fungsi ini membolehkan anda mengubah suai vektor kelas menjadi matriks, iaitu, matriks kelas binari. Katakan, kami telah mengimport fungsi to_categorical() daripada modul utils dan memulakan vektor 'A'. Vektor 'A' telah dihantar ke fungsi to_categorical(). Matriks binari untuk vektor kelas 'A' ini telah dipaparkan.

print_summary() Fungsi

Untuk mencetak ringkasan model yang telah kami buang dalam persekitaran kami, fungsi print_summary telah digunakan.

plot_model() Fungsi

Fungsi plot_model() menandakan model dalam format titik dan membolehkan anda menyimpannya ke dokumen.

Kesimpulan

Kesimpulannya, kita boleh mengatakan bahawa bahasa Python adalah bahasa yang diperlukan untuk era hari ini kerana segala-galanya semakin pantas dan teknologi telah berkembang dengan begitu pantas. Sepanjang garis panduan pembelajaran ini, kami telah menggunakan perpustakaan Keras Python dalam Pembelajaran Dalam dan Rangkaian Neural Buatan. Untuk ini, kami juga telah meneliti kepentingan dan penggunaan perpustakaan bahagian belakangnya 'TensorFlow' untuk mendapatkan pemahaman yang jelas. Selain itu, kami telah membincangkan dan menerangkan setiap konfigurasi yang diperlukan untuk menyediakan persekitaran Keras dan Anaconda dalam Python dalam sistem pengendalian Linux Ubuntu 20.04. Selepas ini, kami telah membincangkan secara menyeluruh Model, Lapisan dan Modul Keras satu demi satu bersama-sama dengan fungsi yang paling banyak digunakan. Untuk demonstrasi model API Fungsi, sila semak dokumentasi rasmi.