Svært

Blandt de mest effektive og brugervenlige plugins til at bygge deep-learning-algoritmer er en Python-baseret forhøjet kunstig neural framework kaldet Keras, som ville blive konstrueret oven på velkendte deep-learning frameworks som TensorFlow eller CNTK. For at muliggøre hurtigere udforskning ved at bruge dybere neurale netværk, er den designet brugervenlig, kan udvides og tilpasses. Den håndterer både Feedforward og Retractable Networks separat, såvel som i kombination. Den bruger Backend-pakken til at adressere små operationer, fordi den ikke er i stand til at administrere dem. Implementeringen af ​​Keras, grundlæggende principper for dyb læring, Keras-strukturer, Keras-lagdeling, Keras-pakker og realtidsprogrammering vil blive dækket i denne lektion.

Konfigurer Keras på Linux

Trin 01: Opdater systemet

Før vi får den fulde demonstration af brugen af ​​'Keras'-biblioteket i Python, er vi nødt til fuldt ud at opdatere vores Linux-maskine for at gøre det nemt for yderligere installationer. Til dette formål skal vi hurtigt åbne 'konsol'-applikationen fra systemets indbyggede applikationer. Inden for det specifikke forespørgselsområde har vi tilføjet 'opdatering'-forespørgslen til Linux med 'apt'-værktøjet og 'sudo'-privilegiet for hurtigt at opdatere det system, vi har. Det har krævet vores brugeradgangskode for at fortsætte denne proces, så vores system kan opdateres korrekt.

Trin 02: Installer Python og Pip

For brugen af ​​Deep Learning gennem Keras og TensorFlow skal vi have Pythons seneste version konfigureret på vores maskine. Derfor begynder vi at installere Pythons opdaterede pakke sammen med dets nødvendige 'pip'-værktøj på vores system. Til det skal vi igen bruge 'apt'-værktøjet i Ubuntu 20.04 Linux-systemet i 'install'-forespørgslen på skallen efterfulgt af navnene på pakker, der skal installeres, dvs. Python3 og Python3-pip. Ved udførelsen af ​​denne simple forespørgsel på konsolområdet, vil systemet begynde at installere og konfigurere begge pakker i vores system.

På den anden side, hvis dit system har en gammel version af 'pip'-værktøjet til Python installeret, bør du opdatere det, før du går videre.

Efter den vellykkede konfiguration af Python og dets 'pip'-værktøj, er det tid til at opgradere Setuptools for Python for at undgå problemer i nær fremtid. Derfor har vi prøvet installationsforespørgslen med 'pip3'-værktøjet og -upgrade-indstillingen for at installere opgraderingen af ​​Setuptools, det vil sige opsætningsværktøjer. Den beder om den aktuelle adgangskode, vi har til vores system, og vi har tilføjet den.

Trin 03: Installer TensorFlow

Til opbygning af maskinlæring og overvågede neurale modeller er TensorFlow den mest kendte symbolske matematikpakke. Efter at have gennemgået installationerne, har vi udført den samme 'pip3' installationsforespørgsel efterfulgt af 'Tensorflow'-pakkenavnet.

Andre TensorFlow-relaterede hjælpeprogrammer skal være fuldt installeret på systemet. Disse hjælpeprogrammer vil blive installeret sammen med TensorFlow, og det kan tage op til 10 minutter eller mere.

Trin 04: Installer essentielle pakker

Efter den frugtbare konfiguration af TensorFlow i Ubuntu 20.04-systemet, skal vi også konfigurere nogle byggepakker sammen med nogle andre værktøjer som 'git' og 'cmake'. Ved at prøve det samme 'apt' værktøj har vi installeret mange af de nødvendige pakker, som vist nedenfor:

Dette trin tager vores største opmærksomhed ved at bekræfte denne installation. Tryk på 'y' og fortsæt.

Trin 05: Opret virtuelt miljø

Efter de nødvendige installationer er det tid til at skabe et virtuelt miljø. Derfor er vi nødt til at bruge Python3-værktøjet med '-m'-indstillingen for at skabe det virtuelle miljø 'kerasenv' via 'venv'-variablen. 'ls'-forespørgslen viser, at miljøet er oprettet.

Nu skal vi bevæge os inden for det virtuelle miljø i Keras-mappen. Så vi har brugt 'cd' instruktionen sammen med navnet på en virtuel miljømappe. Derefter har vi bevæget os i 'bin'-mappen i dette virtuelle miljø og angivet dets under. For at aktivere dette Python-miljø prøvede vi 'kilde'-instruktionen i dets forespørgselsområde sammen med 'aktiver'-filen. Det virtuelle miljø bliver aktiveret med navnet 'kerasenv'.

Trin 06: Installer Python Libraries

Efter at have indstillet det virtuelle Python-miljø med succes, skal du installere alle de nødvendige Python-biblioteker før installationen af ​​Keras. Derfor har vi installeret pandaens bibliotek først i det samme virtuelle miljø ved hjælp af 'pip'-pakken fra Python.

Systemet vil begynde at konfigurere det i Pythons virtuelle miljø, som vist på billedet:

Efter at have installeret pandaernes bibliotek, prøv at installere NumPy-biblioteket ved hjælp af følgende metode:

På en meget lignende måde skal du installere Pythons scipy-bibliotek i det samme miljø.

Installer nu matplotlib-biblioteket i Python i miljøet.

Python bruger clustering og regressionsalgoritmer i maskinlæring til at udføre neurale netværksmodeller. Til dette har det sci-kit learning-biblioteket, som vi er ved at installere med 'pip'-værktøjet sammen med '-u'-muligheden for også at konfigurere de nødvendige pakker.

Behandlingen af ​​scikit-biblioteksinstallationen er vist nedenfor:

For visualisering i dyb læring skal vi have Pythons søfødte bibliotek installeret. Derfor har vi installeret det i det samme miljø med 'install'-forespørgslen.

Trin 07: Installer Keras Library

Efter installationen af ​​alle de nødvendige forudsætningsbiblioteker i Python, kan vi endelig installere Keras i Pythons virtuelle miljø. 'pip'-værktøjet vil blive brugt til dette formål i vores 'install'-forespørgsel med modulnavnet, dvs. 'Keras'. Hvis systemet viser, at dets krav allerede er opfyldt, betyder det, at det allerede er installeret og konfigureret.

Hvis den ikke allerede er installeret, vil denne forespørgsel begynde at downloade og konfigurere den i det virtuelle miljø uden en forsinkelse på et sekund, og behandlingen vil blive vist som nedenfor:

Efter den fulde konfiguration og installation af 'Keras'-biblioteket på det virtuelle miljø, er det tid til at vise den fulde information om det på skallen via 'pip show'-forespørgslen. Udførelsen af ​​denne 'vis'-forespørgsel har præsenteret versionen af ​​Keras installeret i vores virtuelle miljø Python, dens navn, dens resumé, dens hjemmeside, forfatteren, forfatterens e-mail, licensen, den placering, den tager på vores system, og mange mere som præsenteret nedenfor:

Efter de fineste installationer af Python-bibliotekerne Keras og TensorFlow, er vi nødt til at forlade det virtuelle miljø. For det, prøv 'deaktiver' forespørgslen på skallen og luk.

Trin 08: Installer Anaconda Cloud

Python har en sky ved navn 'Anaconda', der er nødvendig for at bygge neurale netværkseksempler i Python. Derfor har vi downloadet dens udførelsesfil til vores system.

Denne fil har ligget i den aktuelle hjemmemappe på Linux-maskinen i henhold til 'ls'-forespørgslen. Du skal sikre dig, at det er checksum først, dvs. om det er helt korrekt eller ej via sha256sum-forespørgslen.

Derefter skal vi installere den downloadede Bash-fil af anaconda i vores system ved hjælp af 'Bash'-instruktionen og filnavnet på den samme konsol. Den har bedt os om at gennemgå licensaftalen før installationen. Så vi trykkede på 'Enter' for at fortsætte.

Efter at have gennemgået sin licensaftale, beder den os om at trykke på 'ja', hvis vi er enige i vilkårene. Du skal trykke på Enter for at fortsætte med at installere det samme sted eller skrive stien til det bibliotek, hvor du vil installere det. Ellers skal du bruge 'Ctrl-c' for at annullere installationen.

Det vil vise den lange liste over pakker, der vil blive installeret i denne proces. Efter nogen transaktionsudførelse vil den begynde at installere pakkerne.

Efter et stykke tid blev anaconda installeret med sine ekstra pakker.

Du skal køre 'aktiver'-filen fra anaconda-mappen via 'kilde'-forespørgslen som en rod.

Prøv at starte anaconda-navigatoren ved at bruge følgende forespørgsel.

For at oprette og arbejde på det nye conda-miljø, prøv 'conda create'-instruktionen med navneindstillingen efterfulgt af det nye miljønavn, dvs. PyCPU.

Denne proces kræver vores bekræftelse på skabelsen af ​​det nye miljø. Tryk på 'y'.

For at aktivere og køre det nylavede conda-miljø skal du bruge 'conda activate'-forespørgslen med navnet på dit nye miljø, dvs. PyCPU-miljøet er nu aktiveret.

Trin 09: Installer Spyder IDE

Spyder IDE skal installeres i dette miljø for at udføre Python-programmer. Til dette har vi prøvet conda-installationsforespørgslen på PyCPU-miljøskallen med nøgleordet 'spyder'.

Tryk på 'y' for at fortsætte med at installere Spyder.

Trin 10: Installer Pandas and Keras Library

Efter installationen af ​​Spyder skal du installere pandaens bibliotek af Python i et anaconda-miljø ved hjælp af conda-installationsforespørgslen med -c-indstillingen.

Igen, tryk på 'y'-knappen for at fortsætte.

Efter den vellykkede konfiguration af pandaer skal du installere Keras-biblioteket med den samme forespørgsel.

Fortsæt efter at have klikket på knappen 'y'.

Du kan starte Spyder IDE i anaconda nuværende miljøkonsol som følger:

Spyder IDE har forberedt sig på at blive lanceret.

Den skjulte mappe '.keras' er blevet placeret i hjemmemappen. Vis den og åbn dens 'keras.json' fil for at tilføje følgende konfigurationer i den.

Konfigurer Keras og TensorFlow på Windows

For at konfigurere Keras og TensorFlow i et Windows-miljø skal du sørge for, at Python-sproget sammen med dets 'pip'-bibliotek og Anaconda Navigator allerede er sat op på det. Når du har konfigureret det, bør du åbne det fra dit søgeområde og bevæge dig inden for fanen 'miljøer'. På denne fane finder du det miljønavn, du i øjeblikket arbejder i, dvs. base. I området nedenfor finder du følgende faneblad. Tryk på 'opret' muligheden.

Her skal du oprette et nyt miljønavn 'TensorFlow', dvs. er i øjeblikket inde i basismiljøet. Vælg Pythons seneste version, der skal bruges, og tryk på knappen 'Opret' for at fortsætte.

Du vil se, at miljøet er begyndt at indlæse.

Efter et stykke tid bliver TensorFlow-miljøet fuldt installeret.

Fra området længst til venstre kan du se alle de installerede og tilgængelige biblioteker og moduler til Python, som præsenteret nedenfor:

Nu skal vi installere TensorFlow backend-biblioteket i Python ved hjælp af dette område. Skriv 'TensorFlow' i søgefeltet, og marker den samme sagspakke fra den viste liste for at installere den. Tryk på knappen 'Anvend' for at fortsætte med installationen af ​​TensorFlow sammen med dets undermoduler som 'Keras'.

Det er begyndt at virke og konfigurere TensorFlow på vores Anaconda-miljø.

Under installationen vil den vise listen over underpakker, der skal installeres i Anaconda-miljøet. Klap på 'Anvend'-knappen og vent et stykke tid, indtil det er færdigt.

Efter et stykke tid vil du finde alle de installerede pakker i det samme modulområde. Du kan se, at Keras-biblioteket er blevet installeret med andre pakker, og vi behøver ikke at installere det nu.

Søg på søgeordet 'Jupyter' fra søgefeltet i Windows. Applikationen med navnet 'Jupyter Notebook (TensorFlow)' vil blive vist sammen med andre. Tryk på den for at starte jupyter Notebook med backend TensorFlow aktiveret. Opret en ny Python-fil og begynd at arbejde.

Dyb læring via hårdt

Dyb læring inkluderer lag-for-lag-analyse af indtaget, hvor hvert lag gradvist uddrager detaljer på avanceret niveau fra inputtet. En fuld ramme er leveret af Keras til at danne enhver form for neuralt netværk. Både kreativ og utrolig enkel at forstå, Keras. Det muliggør neurale netværksmodeller lige fra de mest naive til de største og suveræne komplekser.

Artificial Neural Network (ANN)

Metoden 'Artificial Neural Network' (ANN) ser ud til at være den mest udbredte og grundlæggende metode til dyb læring. De tager deres signaler ud af det menneskelige sind, vores krops naturlige mest komplicerede komponent, som fungerer som deres model. Over 90 milliarder mikroskopiske celler kaldet 'neuroner' udgør en persons hjerne. Axoner og dendritter er typer af nervefibre, der forbinder neuroner sammen. Den primære funktion af et axon er at sende data fra en forbundet neuron til den næste. For mere information, søg venligst fra Googles søgemaskine.

Keras arkitektur

Keras API-arkitekturen er blevet klassificeret i tre hoveddele anført nedenfor. Lad os tage en forklædning på hver enkelt.

• Model
• Lag
• Kernemoduler

Hård model

Keras-modellen består af præcis to typer, dvs. sekventiel og funktionel API.

Sekventiel model

Grundlæggende er en sekventiel model en kronologisk kompilering af Keras-lag. Den simple, forsimplede sekventielle model kan beskrive næsten alle de neurale netværk, der er i brug i øjeblikket. En tilpasset model kan laves ved at bruge den modelklasse, som den sekventielle model afslører. Underklassificeringstilgangen kan bruges til at bygge vores helt egen sofistikerede model. Demonstrationen af ​​den sekventielle model er blevet præsenteret nedenfor.

Tilføj lag

Scriptet er startet fra import af sekventiel tilstand via keras.models, og den anden linje har lavet en sekventiel model. Derefter opretter import af det tætte lag et inputlag og tilføjer et inputlag til en model. Det skjulte tætte lag er blevet oprettet og tilføjet til modellen, og det samme er blevet udført for det tætte outputlag.

Få adgang til modellen

Du kan få information om dine modellag, de inputdata, den har brugt, og dens outputdata. Model.layers-funktionen giver dig adgang til alle lagene. Model.inputs ville vise inputtensorer, og model.output vil vise outputtensorer.

Serialiser modellen

Det er nemt at returnere modellen brugt i scriptet som et objekt eller JSON. For eksempel giver funktionen get_config() modellen som en enhed/objekt. Funktionen from_config() opretter en ny model ved hjælp af objektet som en parametrisk værdi.

Du kan også ændre din model til JSON ved hjælp af to_json()-funktionen.

Modeloversigt

For at få hele resuméet vedrørende lagene, der bruges i modellen sammen med nogle yderligere oplysninger, skal du kalde summary()-funktionen.

Træn og forudsige modellen

For at træne og forudsige bør vi bruge kompileringsfunktionen, tilpasningsfunktionen, evaluere funktionen og forudsige funktionen i denne henseende.

Hårde lag

Hvert input-, skjult- og udbyttelag i den foreslåede model af neurale netværk svarer til et andet Keras-lag i den rigtige model. Ethvert sofistikeret neuralt netværk kan hurtigt udvikles ved hjælp af masser af forudbyggede lag af Keras-biblioteket. Der er forskellige Keras-lag, vi har, dvs. kernelag, poolinglag, tilbagevendende lag og foldningslag. Du kan studere dem ved at søge på nettet. De første to linjer har importeret laget Sekventiel tilstand, tæt, aktivering og Dropout.

Vi har prøvet Sequential() API til at skabe en sekventiel dropout-model. Ved at fjerne aktiveringsmodellen 'relu' har vi skabt et tæt lag via 'Dense' API. For at imødekomme overtilpasningen af ​​det tætte lag, har vi brugt Dropout() API, dvs. dropout layering via dropout() funktion. Efter dette har vi brugt et mere tæt lag her med 'relu' aktiveringsmodellen. For at håndtere de tætte lag fra overpasning, er vi nødt til at gøre brug af Dropout-lag. Til sidst har vi kastet vores sidste tætte lag af ved hjælp af aktiveringsmodellen af ​​typen 'softmax'.

Har du nogensinde lavet lagdeling, mens du laver mad? Hvis ja, så ville dette koncept ikke være svært for dig at forstå. Resultatet af et niveau vil tjene som inputdata for det efterfølgende lag. Her er de grundlæggende ting, der kræves for at bygge et helt nyt lag:

• Input data Shape
• Totale neuroner/enheder i et lag
• Initialisatorer
• Regulatorer
• Begrænsninger
• Aktiveringer

Input data Shape

Inden for Python-sproget er enhver form for input blevet konverteret til en række heltal og derefter tilføjet til algoritmemodellen. Inden for Python skal vi angive inputformen for at få output i henhold til vores krav. I de følgende eksempler har vi specificeret inputformen (3,3), dvs. 3 rækker og 3 kolonner. Outputtet har vist matrixen.

Initialisatorer

Initialiseringsmodulet i Keras Layers giver os mange funktioner til at specificere en specifik vægt for inputdata. For eksempel angiver nuller()-funktionen 0 for alle, ones() angiver for alle, og konstant()-funktionen vil angive en specificeret konstant værdi tilføjet af en bruger for alle og mere. For en bedre forståelse har vi brugt funktionen identity() til at generere en identitetsmatrix. Resten af ​​funktionerne kan også søges fra søgemaskinen.

Begrænsninger

Der er forskellige begrænsningsfunktioner tilgængelige for at anvende begrænsninger på 'vægt'-parameteren for laget, dvs. ikke-negativ, enhedsnorm, max norm, minmaxnorm og mange flere. I den følgende illustration har vi anvendt begrænsningsnormen mindre end eller lig med vægten. Parameteren 'max_value' er den øvre grænse for den begrænsning, der skal anvendes, og aksen er den dimension, som begrænsningen ville blive anvendt på, dvs. dimension 1.

Regulatorer

Under hele optimeringen pålægger det forskellige afgifter på lagegenskaben. Det kom også med nogle funktioner til at gøre det, dvs. L1 regularizer, L2 regularizer og 'LI og L2' Regularizer. Her er den enkleste illustration af L1 regularizer-funktionen:

Aktiveringer

En unik funktion kaldet aktiveringsfunktionen bruges til at bestemme, om en bestemt neuron er aktiv eller ej. Aktiveringsfunktionen transformerer de indkommende data på en kompleks måde, hvilket hjælper neuronerne med at studere mere effektivt. Her er flere aktiveringsmetoder præsenteret i eksemplerne nedenfor:

Hårde moduler

Som vi ved, indeholder programmeringsmoduler normalt funktioner, klasser og variabler, der skal bruges til forskellige og specifikke formål. Ligesom det indeholder Pythons Keras-bibliotek mange moduler i det. Du kan få al den nødvendige viden om Keras-modulerne fra nettet.

Bagende

Et af dets mest kendte og brugte moduler er 'Backend'-modulet, der er designet til at bruge backend-bibliotekerne i Python som TensorFlow og Theano. Ved at bruge backend-modulet kan vi bruge så mange backend-funktioner som muligt fra TensorFlow og Theano-biblioteket. For at bruge backend-biblioteksmodulet skal vi angive det backend-bibliotek, der skal bruges i konfigurationsfilen 'keras.json, som vi har oprettet i den skjulte .keras-mappe. Som standard er backend blevet angivet som 'TensorFlow', men du kan også ændre den til en anden, dvs. Theano eller CNTK.

I vores eksempel vil vi bruge TensorFlow-biblioteket som en backend. For at indlæse konfigurationerne af backend fra keras.json-filen i rodmappen 'keras' skal du bruge:

• fra keras importer backend som k

Efter succesfuld import af backend fra keras.json-filen, er det tid til at få backend-oplysningerne ved hjælp af variablen 'k' med den variable, der skal hentes. For det første har vi hentet navnet på en backend, vi har brugt og allerede importeret ved hjælp af 'backend()'-funktionen. Det returnerer 'Tensorflow' som dets backend-værdi. For at få float-værdien af ​​backend'en har vi kaldt floatx()-funktionen via Keras's 'k' variable objekt. Det viser, at vi har brugt float32-værdien.

For at få formatet på billeddata skal du bruge funktionen image_Data_format() med variablen 'k'. Ved at bruge det viser det, at vores backend har brugt billeddataformatet 'channels_last'. For at få eksponentstyrken for backend, kalder du epsilon()-funktionen med variablen 'k'. Det returnerer, at backend vil bruge den eksponentielle potens af '07'. Det handler alt sammen om hentning af backend-information.

Get_uid() Funktion

Det er tid til at tage et kig på nogle backend-funktioner i TensorFlow for at forstå dens funktionalitet. En af dens mest brugte backend-funktioner 'get_uid() funktion, der bruges til at identificere den standardgraf, vi har brugt. Brug af det med præfikset=''-parameteren ville returnere '1', dvs. i henhold til brugen. Igen, at bruge det ville returnere '2', som vi har kaldt det igen, og værdien af ​​grafen er blevet øget. Efter brug af 'reset_uids'-funktionen, vil grafbruger-id-værdien blive nulstillet til 0. Derfor ville brug af get_uid()-funktionen igen øge den med 1.

Placeholder() Funktion

Tensoren har brugt pladsholder()-funktionen til at holde forskellige dimensionelle former i den. For eksempel har vi i den følgende illustration brugt det til at holde 3D-billedet i tensor via Keras-variablen 'k' og gemme det til en anden variabel 'd'. Outputtet af variabel 'd' viser egenskaberne for en form, der bruges i pladsholderen.

Funktionen 'int_shape()' bruges til at vise formen af ​​en værdi, der er gemt i pladsholderen 'd'.

Dot() Funktion

Har du nogensinde ganget to vektorer? Hvis det er tilfældet, vil det ikke være udfordrende for dig at gange to tensorer. Til dette kom backend-biblioteket med 'dot'-funktionen. For det første, for at holde de to forskellige former, har vi brugt formværdierne i pladsholder()-funktionen i de første 2 linjer til at skabe to holdere 'x' og 'y'. Dot()-funktionen har taget 'x'- og 'y'-holderne til at gange begge tensorerne og gemme resultatet til en anden variabel 'z'. Ved at bruge 'z'-tensoren til udskrivning, viste den den multiplicerede resulterende tensorform (1, 5) på skærmen.

Ones() Funktion

Funktionen ones() i backend-modulet har været kendt for at initialisere alle værdierne af en bestemt form til 1. For eksempel har vi brugt funktionen ones() på tensorformen (3,3) og gemt resultatet til variablen 'v'. Funktionen eval() afbrydes her for at evaluere værdien af ​​en variabel 'v' og vises på i Python-miljøet. Til gengæld har den konverteret formen (3,3) til en array-matrix af alle dem med datatypen float32.

Batch_dot() Funktion

Tensorbatchen angiver det samlede antal prøver, der skal sorteres, før en model opdateres. Batch_dot()-funktionen i TensorFlow-backend'en bruges hovedsageligt til at finde ud af multiplikationsresultatet af to forskellige batchdata. Derfor har vi oprettet to tensorvariable v1 og v2 og brugt funktionen Input() til at gemme dem i v1 og v2 som input. Derefter har vi prøvet funktionen batch_dot() på både tensorvariablerne, v1 og v2, og den resulterende værdi ville blive gemt i en anden variabel 'v3'. Ved udskrivning af variablen v3 fandt vi den resulterende form (2,2) til gengæld.

Variabel funktion

Hvis du nogensinde har arbejdet på et andet sprog, har du muligvis initialiseret mange variabler med søgeordet 'var' eller uden det. Mange gange kan du have initialiseret variablerne med deres datatyper som heltal, streng eller tegn. Indenfor Python Keras-biblioteket kan vi oprette enhver variabel ved hjælp af variabel()-funktionen på nogle tensordata i form af samples.

I det følgende billede har vi oprettet en variabel 'd' ved at tilføje eksempel to listedata til en variabel() funktion med Keras-objektet 'k'. Efter at have tilføjet denne variabel, har vi kaldt transpose()-funktionen på denne variabel 'd' for at finde ud af transponeringen af ​​et eksempeldata i det via Keras-objektet 'k'. Den resulterende transponering vil blive gemt til en variabel 'val'. Print-sætningen af ​​Python-sproget er blevet brugt her til at udskrive værdien af ​​den resulterende 'val'-variabel. Udskriftserklæringen har vist valget af funktion, vi har anvendt på variablen 'd' og det samlede antal elementer i hver liste.

Herefter prøvede vi 'eval'-funktionen på 'val'-variablen for at få transponeringen af ​​prøverne tilføjet til variablen 'd', og printfunktionen viste den. Du kan se transponeringen af ​​to lister i outputtet.

Den tidligere kodeillustration blev opnået ved brug af simple Python-funktioner uden at importere noget bestemt Python-bibliotek. 'Transponeringen' af to datasæt kan findes ved hjælp af NumPy-arrays. Til dette skal vi importere NumPy-biblioteket som 'n' i starten. Det grundlæggende format er det samme, men vi skal initialisere formdatasættet med nøgleordet 'array' i stedet for at bruge nøgleordet 'variabel'. Eksempel NumPy-arrayet skal holdes tilbage til variablen 'd'. Det samme NumPy-objekt 'n' bruges til at kalde transpose()-funktionen på 'd'-variablen og gemme resultatet i variablen 'val'.

Udskriftserklæringen har kaldt 'val'-variablen i den for at vise dens transponerende tensor. Du kan se, for at vise den resulterende transponerede værdi af 'val'-variablen, har vi ikke brug for 'eval'-funktionen her. Nu har vi brugt variabelfunktionen med argumentet 'd' og gemt resultatet i variablen 'z'. Efter at have prøvet print-sætningen ved at tilføje argumentværdien 'z' i den, viste den outputtet i det samme tidligere format, som vi har prøvet i ovenstående variabeleksempel.

Is_sparse() Funktion

Ordet 'sparsom' i tensor bruges til en sparsom tensor, der for det meste indeholder indgange med nuller. I dette eksempel vil vi bruge funktionen is_sparse() i backend-modulet til at kontrollere, om tensoren har de fleste nuller eller ej.

Først har vi kaldt pladsholder()-funktionen til at holde tensorformen (3,3) sammen med argumentet Sparse sat til sand. Denne pladsholderværdi vil blive holdt til det foranderlige 'x' og vist. Outputtet har vist information om pladsholdervariablen 'x'.

For eksempel anvendes dens datatype, form og funktion på den. Efter dette prøvede vi print-sætningen endnu en gang ved at kalde funktionen is_Sparse() i den. Denne funktion har taget variablen 'x' som sit argument for at vise, om 'x'-tensoren er sparsom eller ej. Outputtet viser 'true'.

To_dense() Funktion

Den tætte tensor siges at være den, der brugte den kronologiske hukommelsesblok til at gemme informationen på en tilstødende måde og også repræsentere værdierne af information. Funktionen 'to_dense()' i backend-modulet lader os konvertere den sparse tensor til en tæt tensor. Derfor tager vi den samme pladsholderfunktion for at tilføje tensoren til variabel 'x', og denne tensor er sat til 'sparse'.

Funktionen 'to_dense()' anvendes på den tætte tensor variabel 'x', dvs. at konvertere den til en tæt tensor og gemme den til en anden variabel 'res'. Nu er 'res' selv en tæt tensor. Udskriftserklæringen er blevet fjernet for at udskrive 'res'-variablen. Brugen af ​​udskriftsudsagn for 'res'-variablen viste oplysningerne vedrørende den 'res'-konverterede variabel, dvs. succesfuldt konverteret sparse til tæt og meget mere.

Derefter kaldes en anden printfunktion ved at bruge funktionen is_sparse() i den for at kontrollere, om variablen 'res' er sparse eller ej. Outputtet har vist, at variablen 'res' ikke er sparsom, dvs. da vi allerede har konverteret den til en 'tæt' tensor.

Random_uniform_variable() Funktion

Funktionen random_uniform_variable() i Keras backend-modulet er specifikt designet til initialisering af en tensor via den ensartede fordeling. Det kræver i alt tre argumenter. Det allerførste argument 'form' bruges til at definere figurens rækker og kolonner i tupelformen. Hvis du har lavet matematik, har du måske lært begrebet middelværdi og standardafvigelse.

I metoden random_uniform_variable() er de næste to argumenter middelværdien og den typiske afvigelse fra en ensartet fordeling. Inden for denne illustration har vi initialiseret to tensorer 'x' og 'y' ved hjælp af standarden ensartet fordeling via random_uniform_variable()-funktionen. Begge tensorer indeholder forskellige formformater, dvs. rækker og kolonner med samme middelværdi og standardafvigelse, dvs. lav=0 og høj=1.

Herefter fjerner vi 'punkt'-funktionen og tager 'x' og 'y' tensorerne i den til multiplikation. Resultatet af denne multiplikation vil blive gemt til variablen 'z'. I sidste ende er int_shape() et must at bruge til at vise formen af ​​en resulterende tensor 'z'. Udgangen viser tensoren (2,2).

Udils

Hvis du vil bruge nogle af de meget nyttige funktioner fra deep learning-konceptet i Python, skal du bruge utils-modulet i Keras-biblioteket i dine scripts. For eksempel, hvis du vil vise dine data i HDF5Matrix-format, skal du importere HDF5Matrix-klassen og bruge dens HDF5Matrix-funktion i scriptet.

To_categorical() Funktion

Denne funktion giver dig mulighed for at ændre en klassevektor til en matrix, dvs. binær klassematrix. Lad os sige, at vi har importeret funktionen to_categorical() fra utils-modulet og initialiseret en vektor 'A'. Vektoren 'A' er blevet videregivet til to_categorical()-funktionen. Den binære matrix for denne klassevektor 'A' er blevet vist.

print_summary() Funktion

For at udskrive resuméet af en model, vi har kastet ud i vores miljø, blev funktionen print_summary brugt.

plot_model() Funktion

Funktionen plot_model() angiver modellen i et prikformat og lader dig gemme den i et dokument.

Konklusion

For at opsummere kan vi sige, at Python-sproget er et nødvendigt sprog for nutidens æra, da alting bliver hurtigt, og teknologien har udviklet sig så vanvittigt hurtigt. Gennem hele denne læringsvejledning har vi været op til brugen af ​​Pythons Keras-bibliotek i Deep Learning og Artificial Neurale Networks. Til dette har vi også gennemgået vigtigheden og brugen af ​​dets backend-bibliotek 'TensorFlow' for at få en klar forståelse. Derudover har vi diskuteret og forklaret enhver konfiguration, der kræves for at opsætte Keras og Anaconda-miljøet i Python i Ubuntu 20.04 Linux-operativsystemet. Herefter har vi grundigt diskuteret Keras-modellerne, -lagene og -modulerne én efter én sammen med deres mest brugte funktioner. For demonstration af Function API-modellen, se venligst den officielle dokumentation.