Mahirap

Kabilang sa mga pinaka-epektibo at madaling gamitin na Plugin para sa pagbuo ng mga algorithm sa malalim na pagkatuto ay isang Python-based na nakataas na artificial neural framework na tinatawag na Keras, na gagawin sa ibabaw ng mga kilalang deep-learning frameworks tulad ng TensorFlow o CNTK. Upang paganahin ang mas mabilis na paggalugad gamit ang mas malalalim na neural network, ito ay idinisenyo na madaling gamitin, napapalawak, at madaling ibagay. Pinangangasiwaan nito ang parehong Feedforward at Retractable Networks nang hiwalay, pati na rin sa combo. Ginagamit nito ang Backend package para tugunan ang maliliit na operasyon dahil hindi nito kayang pamahalaan ang mga ito. Ang deployment ng Keras, mga batayan ng malalim na pag-aaral, mga istruktura ng Keras, layering ng Keras, mga pakete ng Keras, at real-time na programming ay tatalakayin sa araling ito.

I-set Up ang Keras sa Linux

Hakbang 01: I-update ang System

Bago magkaroon ng buong demonstrasyon ng paggamit ng 'Keras' library ng Python, kailangan naming ganap na i-update ang aming Linux machine para maging madali para sa karagdagang pag-install. Para sa layuning ito, kailangan nating mabilis na buksan ang 'console' na application mula sa mga built-in na application ng system. Sa loob ng partikular na lugar ng query, idinagdag namin ang query na 'update' ng Linux na may 'apt' utility at pribilehiyong 'sudo' upang mabilis na i-update ang system na mayroon kami. Kinakailangan nitong ipagpatuloy ng aming user password ang prosesong ito upang maayos na ma-update ang aming system.

Hakbang 02: I-install ang Python at Pip

Para sa paggamit ng Deep Learning sa pamamagitan ng Keras at TensorFlow, dapat na naka-configure ang pinakabagong bersyon ng Python sa aming makina. Samakatuwid, sinimulan naming i-install ang na-update na package ng Python kasama ang kinakailangang 'pip' na utility nito sa aming system. Para diyan, kailangan nating gamitin muli ang 'apt' utility ng Ubuntu 20.04 Linux system sa query na 'install' sa shell na sinusundan ng mga pangalan ng mga package na mai-install, ibig sabihin, Python3 at Python3-pip. Sa pagpapatupad ng simpleng query na ito sa console area, magsisimula ang system na i-install at i-configure ang parehong mga package sa aming system.

Sa kabilang banda, kung ang iyong system ay may lumang bersyon ng 'pip' na utility para sa Python na naka-install, dapat mong i-update ito bago sumulong.

Matapos ang matagumpay na pagsasaayos ng Python at ang 'pip' na utility nito, oras na upang i-upgrade ang Setuptools para sa Python upang maiwasan ang anumang mga isyu sa malapit na hinaharap. Samakatuwid, sinubukan namin ang pag-install ng query gamit ang 'pip3' na utility at -upgrade na opsyon upang i-install ang pag-upgrade ng Setuptools, ibig sabihin, mga tool sa pag-setup. Hinihingi nito ang kasalukuyang password na mayroon kami para sa aming system, at idinagdag namin ito.

Hakbang 03: I-install ang TensorFlow

Para sa pagbuo ng machine learning at mga pinangangasiwaang neural na modelo, ang TensorFlow ay ang pinakakilalang symbolic math package. Pagkatapos dumaan sa mga pag-install, isinasagawa namin ang parehong query sa pag-install ng 'pip3' na sinusundan ng pangalan ng package na 'Tensorflow'.

Ang iba pang mga utility na nauugnay sa TensorFlow ay kinakailangang ganap na mai-install sa system. Ang mga utility na iyon ay mai-install kasama ng TensorFlow, at maaaring tumagal ng hanggang 10 o higit pang minuto.

Hakbang 04: I-install ang Mahahalagang Package

Matapos ang mabungang pagsasaayos ng TensorFlow sa Ubuntu 20.04 system, kailangan din nating i-configure ang ilang build package kasama ang ilang iba pang mga utility tulad ng 'git' at 'cmake'. Sa pamamagitan ng pagsubok sa parehong 'apt' na tool, na-install namin ang marami sa mga kinakailangang pakete, tulad ng ipinapakita sa ibaba:

Ang hakbang na ito ay kumukuha ng aming pinaka-pansin sa pamamagitan ng pagkumpirma sa pag-install na ito. I-tap ang 'y' at magpatuloy.

Hakbang 05: Lumikha ng Virtual na Kapaligiran

Pagkatapos ng mga kinakailangang pag-install, oras na upang lumikha ng isang virtual na kapaligiran. Samakatuwid, kailangan nating gamitin ang Python3 na utility na may opsyon na '-m' upang lumikha ng virtual na kapaligiran na 'kerasenv' sa pamamagitan ng variable na 'venv'. Ang query na 'ls' ay nagpapakita na ang kapaligiran ay nilikha.

Ngayon, kailangan nating lumipat sa loob ng virtual na kapaligiran ng folder ng Keras. Kaya, ginagamit namin ang pagtuturo na 'cd' kasama ang pangalan ng isang virtual na folder ng kapaligiran. Pagkatapos nito, lumipat kami sa loob ng folder na 'bin' ng virtual na kapaligirang ito at inilista ang sub nito. Upang i-activate ang Python environment na ito, sinubukan namin ang 'source' na pagtuturo sa query area nito kasama ang 'activate' na file. Ang Virtual na kapaligiran ay magiging aktibo sa pangalang 'kerasenv'.

Hakbang 06: I-install ang Python Libraries

Pagkatapos na matagumpay na maitakda ang Python virtual environment, kailangan mong i-install ang lahat ng kinakailangang Python library bago ang pag-install ng Keras. Samakatuwid, ini-install muna namin ang library ng panda sa parehong virtual na kapaligiran gamit ang 'pip' na pakete ng Python.

Sisimulan ng system ang pag-configure nito sa loob ng virtual na kapaligiran ng Python, tulad ng ipinapakita sa larawan:

Pagkatapos i-install ang library ng mga pandas, subukang i-install ang NumPy library gamit ang sumusunod na paraan:

Sa katulad na paraan, i-install ang scipy library ng Python sa parehong kapaligiran.

Ngayon, i-install ang matplotlib library ng Python sa kapaligiran.

Gumagamit ang Python ng clustering at regression algorithm sa machine learning para magsagawa ng mga modelo ng neural network. Para dito, mayroon itong sci-kit learn library na ini-install namin gamit ang 'pip' utility kasama ang '-u' na opsyon upang i-configure ang mga kinakailangang pakete, pati na rin.

Ang pagproseso ng pag-install ng scikit library ay ipinakita sa ibaba:

Para sa visualization sa malalim na pag-aaral, kailangan namin ang seaborn library ng Python upang mai-install. Samakatuwid, ini-install namin ito sa parehong kapaligiran na may query na 'i-install'.

Hakbang 07: I-install ang Keras Library

Pagkatapos ng pag-install ng lahat ng kinakailangang mga kinakailangang aklatan ng Python, maaari na nating i-install ang Keras sa wakas sa loob ng Virtual na kapaligiran ng Python. Ang 'pip' na utility ay gagamitin para sa layuning ito sa loob ng aming 'i-install' na query na may pangalan ng module, ibig sabihin, 'Keras'. Kung ipinapakita ng system na nasiyahan na ang pangangailangan nito, nangangahulugan ito na naka-install at naka-configure na ito.

Kung hindi pa ito naka-install, magsisimula ang query na ito sa pag-download at pag-configure nito sa virtual na kapaligiran nang walang pagkaantala ng isang segundo at ang pagpoproseso ay ipapakita, tulad ng sa ibaba:

Pagkatapos ng buong configuration at pag-install ng 'Keras' library sa Virtual Environment, oras na para ipakita ang buong impormasyon tungkol dito sa shell sa pamamagitan ng query na 'pip show'. Ang pagpapatupad ng query na ito na 'palabas' ay nagpapakita ng bersyon ng Keras na naka-install sa aming virtual na kapaligiran ng Python, ang pangalan nito, ang buod nito, ang web homepage nito, may-akda, ang email ng may-akda, lisensya, ang lokasyon na kinukuha nito sa aming system, at marami pa. higit pa tulad ng ipinakita sa ibaba:

Pagkatapos ng pinakamahusay na mga pag-install ng Keras at TensorFlow library ng Python, kailangan nating umalis sa virtual na kapaligiran. Para diyan, subukan ang 'i-deactivate' na query sa shell at huminto.

Hakbang 08: I-install ang Anaconda Cloud

Ang Python ay may cloud na pinangalanang 'Anaconda' na kinakailangan upang bumuo ng mga halimbawa ng neural network sa Python. Samakatuwid, na-download namin ang execution file nito sa aming system.

Ang file na ito ay naninirahan sa kasalukuyang home folder ng Linux machine ayon sa query na 'ls'. Kailangan mong tiyakin na ito ay checksum muna, ibig sabihin, kung ito ay ganap na tama o hindi sa pamamagitan ng sha256sum query.

Pagkatapos nito, kailangan naming i-install ang na-download na Bash file ng anaconda sa aming system gamit ang 'Bash' na pagtuturo at ang pangalan ng file sa parehong console. Hinihiling nito sa amin na suriin ang kasunduan sa lisensya bago ang pag-install. Kaya, tinapik namin ang 'Enter' upang magpatuloy.

Pagkatapos dumaan sa kasunduan sa lisensya nito, hinihiling nito sa amin na i-tap ang 'oo' kung sumasang-ayon kami sa mga tuntunin. Kailangan mong pindutin ang Enter upang ipagpatuloy ang pag-install nito sa parehong lugar o isulat ang path sa direktoryo kung saan mo gustong i-install ito. Kung hindi, gamitin ang 'Ctrl-c' upang kanselahin ang pag-install.

Ipapakita nito ang mahabang listahan ng mga pakete na mai-install sa prosesong ito. Pagkatapos ng ilang pagpapatupad ng transaksyon, magsisimula itong i-install ang mga pakete.

Pagkaraan ng ilang sandali, matagumpay na na-install ang anaconda kasama ang mga karagdagang pakete nito.

Kailangan mong patakbuhin ang 'i-activate' na file mula sa folder ng anaconda sa pamamagitan ng query na 'pinagmulan' bilang isang ugat.

Subukang ilunsad ang anaconda navigator gamit ang sumusunod na query.

Upang gumawa at magtrabaho sa bagong conda environment, subukan ang 'conda create' na pagtuturo na may opsyon sa pangalan na sinusundan ng bagong pangalan ng environment, ibig sabihin, PyCPU.

Ang prosesong ito ay nangangailangan ng aming kumpirmasyon sa paglikha ng bagong kapaligiran. I-tap ang 'y'.

Upang i-activate at patakbuhin ang bagong ginawang conda environment, gamitin ang query na 'conda activate' na may pangalan ng iyong bagong environment, ibig sabihin, ang PyCPU environment ay naka-activate na ngayon.

Hakbang 09: I-install ang Spyder IDE

Ang Spyder IDE ay dapat na naka-install sa loob ng kapaligirang ito para sa pagpapatupad ng mga programang Python. Para dito, sinubukan namin ang conda install query sa PyCPU environment shell na may keyword na 'spyder'.

I-tap ang “y” para magpatuloy sa pag-install ng Spyder.

Hakbang 10: I-install ang Pandas at Keras Library

Pagkatapos ng pag-install ng Spyder, i-install ang library ng Python ng panda sa isang anaconda na kapaligiran gamit ang conda install query na may –c na opsyon.

Muli, pindutin ang 'y' na buton upang magpatuloy.

Pagkatapos ng matagumpay na pagsasaayos ng mga panda, i-install ang Keras library na may parehong query.

Magpatuloy pagkatapos i-click ang 'y' na buton.

Maaari mong ilunsad ang Spyder IDE sa loob ng kasalukuyang environment console ng anaconda tulad ng sumusunod:

Ang Spyder IDE ay naghahanda upang ilunsad.

Ang nakatagong folder na '.keras' ay matatagpuan sa home directory. I-unhide ito at buksan ang 'keras.json' file nito upang idagdag ang mga sumusunod na configuration dito.

I-set Up ang Keras at TensorFlow sa Windows

Upang i-set up ang Keras at TensorFlow sa isang Windows environment, kailangan mong tiyakin na ang wikang Python kasama ang 'pip' library nito at Anaconda Navigator ay naka-set up na dito. Pagkatapos i-set up ito, dapat mong buksan ito mula sa iyong lugar ng paghahanap at lumipat sa loob ng tab na 'mga kapaligiran'. Sa tab na ito, makikita mo ang pangalan ng kapaligiran kung saan ka kasalukuyang nagtatrabaho i.e., base. Sa lugar sa ibaba, makikita mo ang sumusunod na tab. I-tap ang opsyong 'lumikha'.

Dito, kailangan mong lumikha ng bagong pangalan ng kapaligiran na 'TensorFlow', ibig sabihin, ay kasalukuyang nasa loob ng base na kapaligiran. Piliin ang pinakabagong bersyon ng Python na gagamitin at i-tap ang button na 'Gumawa' upang magpatuloy.

Makikita mo na ang kapaligiran ay nagsimulang mag-load.

Pagkaraan ng ilang sandali, ganap na mai-install ang kapaligiran ng TensorFlow.

Mula sa pinakakaliwang bahagi nito, makikita mo ang lahat ng naka-install at magagamit na mga library at module para sa Python, tulad ng ipinakita sa ibaba:

Ngayon, kailangan nating i-install ang TensorFlow backend library ng Python gamit ang lugar na ito. Sa search bar, isulat ang 'TensorFlow' at markahan ang parehong case package mula sa ipinapakitang listahan upang mai-install ito. I-tap ang button na 'Ilapat' upang magpatuloy sa pag-install ng TensorFlow kasama ang mga sub-modules nito tulad ng 'Keras'.

Nagsimula na itong gumana at i-configure ang TensorFlow sa aming Anaconda environment.

Habang ang pag-install ay ipapakita nito ang listahan ng mga sub-package na mai-install sa kapaligiran ng Anaconda. I-tap ang 'Apply' na buton at maghintay ng ilang sandali hanggang matapos ito.

Pagkaraan ng ilang sandali, makikita mo ang lahat ng naka-install na mga pakete sa parehong lugar ng mga module. Maaari mong makita na ang Keras library ay na-install kasama ng iba pang mga pakete at hindi na namin ito kailangang i-install ngayon.

Mula sa Windows Search bar, hanapin ang keyword na 'Jupyter'. Ang application na pinangalanang 'Jupyter Notebook (TensorFlow)' ay ipapakita kasama ng iba. I-tap ito para ilunsad ang jupyter Notebook na pinagana ang backend na TensorFlow. Gumawa ng bagong Python file at magsimulang magtrabaho.

Deep Learning Via Hard

Kasama sa malalim na pag-aaral ang layer-by-layer na pagsusuri ng intake, na ang bawat layer ay unti-unting kumukuha ng mga advanced na detalye sa antas mula sa input. Ang isang buong balangkas ay ibinigay ng Keras upang bumuo ng anumang uri ng neural network. Parehong malikhain at hindi kapani-paniwalang simpleng maunawaan, Keras. Nagbibigay-daan ito sa mga modelo ng neural network mula sa pinakawalang muwang hanggang sa pinakamalaki at pinakamataas na kumplikado.

Artificial Neural Network (ANN)

Ang pamamaraang 'Artificial Neural Network' (ANN) ay tila ang pinakamalawak na ginagamit at pangunahing paraan ng malalim na pag-aaral. Inalis nila ang kanilang mga pahiwatig mula sa isip ng tao, ang natural na pinakakomplikadong sangkap ng ating katawan, na nagsisilbing kanilang modelo. Mahigit 90 bilyong mikroskopiko na mga cell na tinatawag na 'neuron' ang bumubuo sa utak ng isang indibidwal. Ang mga axon at dendrite ay mga uri ng nerve fibers na nag-uugnay sa mga neuron. Ang pangunahing tungkulin ng isang axon ay ang magpadala ng data mula sa isang naka-link na neuron patungo sa susunod. Para sa karagdagang impormasyon, mangyaring maghanap mula sa Google Search Engine.

Arkitektura ng Keras

Ang arkitektura ng Keras API ay inuri sa tatlong pangunahing bahagi na nakalista sa ibaba. Gumawa tayo ng isang pagkukunwari sa bawat isa nang malinaw.

• Modelo
• Layer
• Mga Pangunahing Module

Matigas na Modelo

Ang modelo ng Keras ay binubuo ng eksaktong dalawang uri, i.e., sequential at functional na API.

Sequential Model

Sa panimula, ang isang sequential na modelo ay isang kronolohikal na compilation ng Keras Layers. Maaaring ilarawan ng simple, simplistic sequential model ang halos lahat ng neural network na kasalukuyang ginagamit. Maaaring gumawa ng customized na modelo gamit ang klase ng Modelo na ipinapakita ng sequential model. Maaaring gamitin ang diskarte sa sub-classing upang makabuo ng isang sopistikadong modelo ng sarili nating sarili. Ang pagpapakita ng sunud-sunod na modelo ay ipinakita sa ibaba.

Magdagdag ng mga Layer

Sinimulan ang script mula sa pag-import ng sequential mode sa pamamagitan ng keras.models at ang kabilang linya ay gumagawa ng sequential model. Pagkatapos nito, ang pag-import ng siksik na layer ay lumilikha ng input layer at nagdaragdag ng input layer sa isang modelo. Ang nakatagong siksik na layer ay nilikha at idinagdag sa modelo at ang parehong ay ginawa para sa output siksik na layer.

I-access ang Modelo

Makakakuha ka ng impormasyon tungkol sa iyong mga layer ng modelo, ang input data na ginagamit nito, at ang output data nito. Ang model.layers function ay nagbibigay-daan sa iyo upang ma-access ang lahat ng mga layer. Ang model.inputs ay magpapakita ng mga input tensor, at ang model.output ay magpapakita ng mga output tensor.

I-serye ang Modelo

Madaling ibalik ang modelong ginamit sa script bilang object o JSON. Halimbawa, ang get_config() function ay nagbubunga ng modelo bilang isang entity/object. Ang from_config() function ay lumilikha ng bagong modelo gamit ang object bilang parametric value.

Maaari mo ring baguhin ang iyong modelo sa JSON gamit ang to_json() function.

Buod ng Modelo

Upang makuha ang buong buod tungkol sa mga layer na ginamit sa loob ng modelo kasama ang ilang karagdagang impormasyon, tawagan ang buod() function.

Sanayin at Hulaan ang Modelo

Upang sanayin at hulaan, dapat nating gamitin ang compile function, fit function, suriin ang function, at hulaan ang function sa bagay na ito.

Mga Matigas na Layer

Ang bawat input, nakatago, at yield na layer sa iminungkahing modelo ng mga neural network ay tumutugma sa ibang Keras layer sa totoong modelo. Ang anumang sopistikadong neural network ay maaaring mabilis na mabuo gamit ang maraming pre-built na layer ng Keras library. Mayroong iba't ibang mga layer ng Keras na mayroon kami, ibig sabihin, mga core layer, pooling layer, paulit-ulit na layer, at convolution layer. Maaari mong pag-aralan ang mga ito sa pamamagitan ng paghahanap sa web. Ini-import ng unang dalawang linya ang Sequential mode, dense, activation, at Dropout layer.

Sinusubukan namin ang Sequential() API para sa paggawa ng dropout sequential model. Sa pamamagitan ng pag-cast off sa activation model na 'relu' nakagawa kami ng siksik na layer sa pamamagitan ng 'Dense' API. Upang matugunan ang sobrang pag-aayos ng siksik na layer, ginagamit namin ang Dropout() API, ibig sabihin, dropout layering sa pamamagitan ng dropout() function. Pagkatapos nito, gumagamit kami ng mas siksik na layer dito kasama ang 'relu' activation model. Upang mahawakan ang mga siksik na layer mula sa sobrang pag-aayos, kailangan nating gamitin ang mga Dropout na layer. Sa huli, na-cast na namin ang aming mga huling siksik na layer gamit ang 'softmax' type activation model.

Nakapagsagawa ka na ba ng layering habang nagluluto? Kung gayon, hindi magiging mahirap para sa iyo na maunawaan ang konseptong ito. Ang resulta ng isang antas ay magsisilbing input data para sa kasunod na layer. Narito ang mga pangunahing bagay na kinakailangan upang bumuo ng isang buong bagong layer:

• Hugis ng Data ng Input
• Kabuuang mga neuron/unit sa isang layer
• Mga Initializer
• Mga regularizer
• Mga hadlang
• Mga pag-activate

Hugis ng Data ng Input

Sa loob ng wikang Python, ang bawat uri ng input ay na-convert sa isang hanay ng mga integer at pagkatapos ay idinagdag sa modelo ng algorithm. Sa loob ng Python, kailangan nating tukuyin ang hugis ng input upang makuha ang output ayon sa ating kinakailangan. Sa mga sumusunod na halimbawa, tinukoy namin ang hugis ng input (3,3), ibig sabihin, 3 row at 3 column. Ipinapakita ng output ang matrix.

Mga Initializer

Ang initializers module ng Keras Layers ay nagbibigay sa amin ng maraming function upang tukuyin ang isang partikular na timbang para sa input data. Halimbawa, ang function na zeros() ay tumutukoy sa 0 para sa lahat, ang mga () ay tutukuyin para sa lahat, at ang constant() function ay tutukuyin ang isang tinukoy na constant value na idinagdag ng isang user para sa lahat at higit pa. Para sa isang mas mahusay na pag-unawa, ginamit namin ang identity() function upang bumuo ng isang identity matrix. Ang iba pang mga function ay maaaring hanapin din mula sa search engine.

Mga hadlang

Mayroong iba't ibang mga function ng pagpilit na magagamit upang maglapat ng mga hadlang sa parameter na 'timbang' ng Layer, ibig sabihin, hindi negatibo, pamantayan ng yunit, max na pamantayan, minmaxnorm, at marami pa. Sa loob ng sumusunod na paglalarawan, inilapat namin ang pamantayan ng pagpilit na mas mababa sa o katumbas ng timbang. Ang parameter na “max_value” ay ang upper bound ng constraint na ilalapat at ang axis ay ang dimensyon kung saan ilalapat ang constraint, ibig sabihin, dimensyon 1.

Mga regularizer

Sa buong pag-optimize, nagpapataw ito ng iba't ibang singil sa layer property. Nakabuo din ito ng ilang function para gawin ito, ibig sabihin, L1 regularizer, L2 regularizer, at 'LI at L2' Regularizer. Narito ang pinakasimpleng paglalarawan ng L1 regularizer function:

Mga pag-activate

Ang isang natatanging function na tinatawag na activation function ay ginagamit upang matukoy kung ang isang partikular na neuron ay aktibo o hindi. Binabago ng activation function ang papasok na data sa isang kumplikadong paraan, na tumutulong sa mga neuron na mag-aral nang mas epektibo. Narito ang ilang paraan ng pag-activate na ipinakita sa mga halimbawang ibinigay sa ibaba:

Mahirap na Module

Tulad ng alam natin na ang mga module ng programming ay karaniwang naglalaman ng mga function, klase, at mga variable na gagamitin para sa iba't ibang at tiyak na layunin. Katulad nito, ang Python's Keras library ay naglalaman ng maraming mga module sa loob nito. Makukuha mo ang lahat ng kinakailangang kaalaman tungkol sa mga module ng Keras mula sa web.

Backend

Isa sa pinakakilala at ginagamit na mga module nito ay ang 'Backend' na module na idinisenyo upang gamitin ang mga backend na library ng Python tulad ng TensorFlow at Theano. Gamit ang backend module, maaari naming gamitin ang pinakamaraming backend function hangga't maaari mula sa TensorFlow at Theano library. Upang magamit ang module ng backend library, kailangan naming tukuyin ang backend library na gagamitin sa configuration file na “keras.json, na aming ginawa sa nakatagong .keras na folder. Bilang default, ang backend ay tinukoy bilang 'TensorFlow', ngunit maaari mo rin itong baguhin sa iba, ibig sabihin, Theano, o CNTK.

Sa loob ng aming halimbawa, gagamitin namin ang TensorFlow library bilang backend. Upang i-load ang mga configuration ng backend mula sa keras.json file ng root na 'keras' na folder, gamitin ang:

• mula sa hard import backend bilang k

Pagkatapos ng matagumpay na pag-import ng backend mula sa keras.json file, oras na para makuha ang impormasyon ng backend gamit ang variable na 'k' na may variable na kukunin. Una, kinukuha namin ang pangalan ng backend na ginagamit namin at na-import na gamit ang function na 'backend()'. Ibinabalik nito ang 'Tensorflow' bilang backend value nito. Upang makuha ang float value ng backend, tinatawagan namin ang floatx() function sa pamamagitan ng 'k' variable object ng Keras. Ipinapakita nito na ginagamit namin ang halaga ng float32.

Upang makuha ang format ng data ng imahe, gamitin ang function na image_Data_format() na may variable na “k”. Sa paggamit nito, ipinapakita nito na ang aming backend ay gumagamit ng 'channels_last' na format ng data ng imahe. Upang makuha ang exponent power para sa backend, tawagan ang epsilon() function na may variable na “k”. Ibinabalik nito na ang backend ay gagamit ng exponential power na '07'. Iyon lang ang tungkol sa pagkuha ng impormasyon sa backend.

Get_uid() Function

Oras na para tingnan ang ilang backend function ng TensorFlow para maunawaan ang functionality nito. Isa sa mga pinakaginagamit nitong backend na function na “get_uid() function na ginagamit upang matukoy ang default na graph na aming ginagamit. Ang paggamit nito na may prefix='' na parameter ay magbabalik ng '1', ibig sabihin, ayon sa paggamit. Muli, ang paggamit nito ay magbabalik ng '2' habang tinatawag natin itong muli at ang halaga ng graph ay nadagdagan. Pagkatapos gamitin ang function na 'reset_uids', ang value ng user ID ng graph ay ire-reset sa 0. Samakatuwid, ang paggamit ng get_uid() function ay muling madaragdagan ito ng 1.

Placeholder() Function

Ginagamit ng tensor ang function na placeholder() upang hawakan ang iba't ibang mga dimensional na hugis sa loob nito. Halimbawa, sa loob ng sumusunod na ilustrasyon, ginagamit namin ito upang hawakan ang 3-D na imahe sa tensor sa pamamagitan ng Keras variable na 'k' at i-save ito sa isa pang variable na 'd'. Ang output ng variable na 'd' ay nagpapakita ng mga katangian ng isang hugis na ginamit sa loob ng placeholder.

Ang function na 'int_shape()' ay ginagamit upang ipakita ang hugis ng isang value na naka-save sa placeholder na 'd'.

Dot() Function

Nakapag-multiply ka na ba ng dalawang vectors? Kung gayon, hindi magiging mahirap para sa iyo na magparami ng dalawang tensor. Para dito, lumabas ang backend library ng function na 'tuldok'. Una, para hawakan ang dalawang magkaibang hugis, ginagamit namin ang mga value ng hugis sa placeholder() function sa unang 2 linya upang lumikha ng dalawang may hawak na 'x' at 'y'. Ang dot() function ay kumukuha ng 'x' at 'y' holder upang i-multiply ang parehong mga tensor at i-save ang resulta sa isa pang variable na 'z'. Sa paggamit ng “z” tensor para sa pag-print, ipinakita nito ang pinarami na resultang tensor na hugis(1, 5) sa screen.

Ones() Function

Ang ones() function ng backend module ay kilala sa pagsisimula ng lahat ng value ng isang partikular na hugis sa 1. Halimbawa, ginagamit namin ang ones() function sa tensor shape (3,3) at i-save ang resulta sa ang variable na 'v'. Ang eval() function ay pinaalis dito upang suriin ang halaga ng isang variable na 'v' at ipinapakita sa sa kapaligiran ng Python. Bilang kapalit, na-convert nito ang hugis (3,3) sa array matrix ng lahat ng may float32 na uri ng data.

Batch_dot() Function

Ang batch ng tensor ay tutukuyin ang kabuuang mga sample na pagbubukud-bukurin bago mag-update ng isang modelo. Ang batch_dot() function ng TensorFlow backend ay pangunahing ginagamit upang malaman ang resulta ng multiplikasyon ng dalawang magkaibang batch data. Samakatuwid, gumawa kami ng dalawang tensor variable na v1 at v2 at ginamit ang Input() function para i-save ang mga ito sa v1 at v2 bilang input. Pagkatapos noon, sinubukan namin ang batch_dot() function sa parehong tensor variable, v1 at v2, at ang resultang value ay mase-save sa isa pang variable na 'v3'. Sa pag-print ng variable v3, nakita namin ang resultang hugis (2,2) bilang kapalit.

Variable Function

Kung nakapagtrabaho ka na sa anumang ibang wika, maaaring nakapagsimula ka ng maraming variable gamit ang keyword na 'var' o wala nito. Maraming beses, maaaring nasimulan mo na ang mga variable sa kanilang mga uri ng data tulad ng integer, string, o character. Sa loob ng library ng Python Keras, maaari tayong lumikha ng anumang variable gamit ang variable() function sa ilang data ng tensor sa anyo ng mga sample.

Sa loob ng sumusunod na larawan, gumawa kami ng variable na 'd' sa pamamagitan ng pagdaragdag ng sample na dalawang listahan ng data sa isang variable() function na may Keras object na 'k'. Pagkatapos idagdag ang variable na ito, tinatawagan namin ang transpose() function sa variable na ito na “d” para malaman ang transpose ng isang sample na data sa loob nito sa pamamagitan ng Keras object na “k”. Ang resultang transpose ay ise-save sa isang variable na 'val'. Ang print statement ng wikang Python ay ginamit dito upang i-print ang halaga ng resultang variable na 'val'. Ang print statement ay ipinapakita ang pagpili ng function na inilapat namin sa variable na 'd' at ang kabuuang bilang ng mga elemento sa bawat listahan.

Pagkatapos nito, sinubukan namin ang function na 'eval' sa variable na 'val' upang makuha ang transpose ng mga sample na idinagdag sa variable na 'd' at ipinapakita ito ng print function. Maaari mong makita ang transpose ng dalawang listahan sa output.

Ang nakaraang paglalarawan ng code ay nakamit sa pamamagitan ng paggamit ng mga simpleng function ng Python nang hindi nag-i-import ng anumang partikular na library ng Python. Ang 'transpose' ng dalawang data set ay mahahanap gamit ang NumPy arrays. Para dito, kailangan nating i-import ang NumPy library bilang 'n' sa simula. Ang pangunahing format ay pareho, ngunit kailangan nating simulan ang hanay ng data ng hugis gamit ang 'array' na keyword sa halip na gamitin ang 'variable' na keyword. Ang sample na array ng NumPy ay dapat itago sa variable na 'd'. Ang parehong NumPy object na 'n' ay ginagamit upang tawagan ang transpose() function sa 'd' variable at i-save ang resulta nito sa variable na 'val'.

Ang print statement ay tumatawag sa 'val' na variable dito upang ipakita ang transpose tensor nito. Makikita mo, para ipakita ang resultang transposed value ng variable na 'val', hindi namin kailangan ang function na 'eval' dito. Ngayon, ginamit namin ang variable function na may argumentong 'd' at nai-save ang resulta sa variable na 'z'. Pagkatapos subukan ang print statement sa pamamagitan ng pagdaragdag ng argument value na 'z' dito, ipinakita nito ang output sa parehong nakaraang format na sinubukan namin sa halimbawa ng variable sa itaas.

Is_sparse() Function

Ang salitang 'kalat-kalat' sa tensor ay ginagamit para sa isang kalat-kalat na tensor na naglalaman ng mga entry na kadalasang may mga zero. Sa loob ng halimbawang ito, gagamitin namin ang is_sparse() function ng backend module upang suriin kung ang tensor ay may karamihan sa mga zero o wala.

Una, tinawag namin ang function na placeholder() upang hawakan ang hugis ng tensor (3,3) kasama ang argumentong Sparse na nakatakda sa true. Ang halaga ng placeholder na ito ay pananatilihin sa nababagong 'x' at ipapakita. Ang output ay nagpapakita ng impormasyon tungkol sa placeholder variable na 'x'.

Halimbawa, ang uri ng data, hugis, at function nito ay inilalapat dito. Pagkatapos nito, sinubukan naming muli ang print statement na tinatawag ang is_Sparse() function dito. Kinukuha ng function na ito ang variable na 'x' bilang argument nito upang ipakita kung ang 'x' tensor ay kalat o hindi. Ang output ay nagpapakita ng 'totoo'.

To_dense() Function

Ang siksik na tensor ay sinasabing ang gumamit ng kronolohikal na bloke ng memorya upang mag-imbak ng impormasyon sa isang katabing paraan at kumatawan din sa mga halaga ng impormasyon. Ang function na 'to_dense()' ng backend module ay nagbibigay-daan sa amin na i-convert ang sparse tensor sa isang dense tensor. Samakatuwid, ginagamit namin ang parehong function ng placeholder upang idagdag ang tensor sa variable na 'x' at ang tensor na ito ay itinakda sa 'sparse'.

Ang function na 'to_dense()' ay inilapat sa siksik na tensor variable na 'x', ibig sabihin, upang i-convert ito sa isang siksik na tensor at i-save ito sa isa pang variable na 'res'. Ngayon, ang 'res' ay isang siksik na tensor mismo. Na-cast off ang print statement para i-print ang variable na 'res'. Ang paggamit ng mga print statement para sa 'res' na variable ay nagpakita ng impormasyon tungkol sa 'res' na na-convert na variable, ibig sabihin, matagumpay na na-convert ang kalat-kalat sa siksik at marami pang iba.

Pagkatapos, ang isa pang function ng pag-print ay tinatawag sa pamamagitan ng paggamit ng is_sparse() function dito upang suriin kung ang variable na 'res' ay kalat-kalat o hindi. Ang output ay nagpapakita na ang variable na 'res' ay hindi kalat-kalat, ibig sabihin, dahil na-convert na namin ito sa isang 'siksik' na tensor.

Random_uniform_variable() Function

Ang random_uniform_variable() function sa Keras backend module ay partikular na idinisenyo para sa pagsisimula ng isang tensor sa pamamagitan ng pare-parehong pamamahagi. Nangangailangan ito ng kabuuang tatlong argumento. Ang pinakaunang argumentong 'hugis' ay ginagamit upang tukuyin ang mga row at column ng hugis sa loob ng tuple form. Kung nakagawa ka ng matematika, maaaring natutunan mo ang konsepto ng mean at standard deviation.

Sa random_uniform_variable() na pamamaraan, ang susunod na dalawang argumento ay ang mean at tipikal na paglihis mula sa isang pare-parehong pamamahagi. Sa loob ng paglalarawang ito, sinimulan namin ang dalawang tensor na 'x' at 'y' gamit ang karaniwang unipormeng pamamahagi sa pamamagitan ng random_uniform_variable() function. Parehong naglalaman ang mga tensor ng iba't ibang mga format ng hugis, ibig sabihin, mga row at column na may parehong mean at standard deviation, ibig sabihin, low=0, at high=1.

Pagkatapos nito, itinatanggal namin ang function na 'tuldok' na kumukuha ng 'x' at 'y' na mga tensor dito para sa pagpaparami. Ang resulta ng pagpaparami na ito ay ise-save sa variable na 'z'. Sa huli, ang int_shape() ay kailangang gamitin upang ipakita ang hugis ng resultang tensor “z”. Ang output ay nagpapakita ng tensor (2,2).

Mga gamit

Kung gusto mong gumamit ng ilan sa mga napaka-kapaki-pakinabang na function mula sa malalim na pag-aaral ng konsepto ng Python, dapat mong gamitin ang utils module ng Keras library sa iyong mga script. Halimbawa, kung gusto mong ipakita ang iyong data sa HDF5Matrix format, kailangan mong i-import ang HDF5Matrix class at gamitin ang HDF5Matrix function nito sa script.

To_categorical() Function

Binibigyang-daan ka ng function na ito na baguhin ang isang class vector sa isang matrix, ibig sabihin, binary class matrix. Sabihin nating, na-import namin ang to_categorical() function mula sa utils module at nag-initialize ng vector 'A'. Ang vector na 'A' ay naipasa sa to_categorical() function. Ang binary matrix para sa class vector na 'A' ay ipinakita.

print_summary() Function

Upang i-print ang buod ng isang modelo na na-cast off namin sa aming kapaligiran, ginamit ang print_summary function.

plot_model() Function

Ang plot_model() function ay nagpapahiwatig ng modelo sa isang tuldok na format at hinahayaan kang i-save ito sa isang dokumento.

Konklusyon

Sa kabuuan, masasabi nating ang wikang Python ay isang kinakailangang wika para sa panahon ngayon dahil ang lahat ay nagiging mabilis at ang teknolohiya ay mabilis na umuunlad. Sa buong patnubay sa pag-aaral na ito, nakahanda na kami sa paggamit ng Python's Keras library sa Deep Learning at Artificial Neural Networks. Para dito, pinagdaanan din namin ang kahalagahan at paggamit ng backend library nito na “TensorFlow” para makakuha ng malinaw na pag-unawa. Bukod pa rito, napag-usapan at ipinaliwanag namin ang bawat pagsasaayos na kinakailangan upang i-set up ang kapaligiran ng Keras at Anaconda sa Python sa loob ng operating system ng Ubuntu 20.04 Linux. Pagkatapos nito, isa-isa naming tinalakay ang Mga Modelo, Layer, at Module ng Keras kasama ng kanilang mga pinakaginagamit na function. Para sa pagpapakita ng modelo ng Function API, pakitingnan ang opisyal na dokumentasyon.