Hard

Blant de mest effektive og brukervennlige pluginene for å bygge dyplæringsalgoritmer er et Python-basert forhøyet kunstig nevralt rammeverk kalt Keras, som ville bli konstruert på toppen av velkjente dyplæringsrammeverk som TensorFlow eller CNTK. For å muliggjøre raskere utforskning ved å bruke dypere nevrale nettverk, er den designet brukervennlig, utvidbar og tilpasningsdyktig. Den håndterer både feedforward og uttrekkbare nettverk separat, så vel som i kombinasjon. Den bruker Backend-pakken for å adressere små operasjoner fordi den ikke er i stand til å administrere dem. Utrullingen av Keras, grunnleggende om dyp læring, Keras-strukturer, Keras-lagdeling, Keras-pakker og sanntidsprogrammering vil bli dekket i denne leksjonen.

Sett opp Keras på Linux

Trinn 01: Oppdater systemet

Før vi har full demonstrasjon av bruken av 'Keras'-biblioteket til Python, må vi oppdatere Linux-maskinen vår fullstendig for å gjøre det enkelt for videre installasjoner. For dette formålet må vi raskt åpne 'konsollen'-applikasjonen fra de innebygde applikasjonene i systemet. Innenfor det bestemte søkeområdet har vi lagt til 'oppdatering'-spørsmålet til Linux med 'apt'-verktøyet og 'sudo'-privilegiet for raskt å oppdatere systemet vi har. Det har krevd vårt brukerpassord for å fortsette denne prosessen slik at systemet vårt kan oppdateres riktig.

Trinn 02: Installer Python og Pip

For bruk av Deep Learning gjennom Keras og TensorFlow, må vi ha Pythons nyeste versjon konfigurert på maskinen vår. Derfor begynner vi å installere Pythons oppdaterte pakke sammen med det nødvendige 'pip'-verktøyet på systemet vårt. For det må vi igjen bruke 'apt'-verktøyet til Ubuntu 20.04 Linux-systemet i 'install'-spørringen på skallet etterfulgt av navnene på pakkene som skal installeres, det vil si Python3 og Python3-pip. Når denne enkle spørringen utføres på konsollområdet, vil systemet begynne å installere og konfigurere begge pakkene i systemet vårt.

På den annen side, hvis systemet ditt har en gammel versjon av 'pip'-verktøyet for Python installert, bør du oppdatere det før du går videre.

Etter vellykket konfigurasjon av Python og dets 'pip'-verktøy, er det på tide å oppgradere Setuptools for Python for å unngå problemer i nær fremtid. Derfor har vi prøvd installasjonsspørringen med 'pip3'-verktøyet og -upgrade-alternativet for å installere oppgraderingen av Setuptools, det vil si oppsettverktøy. Den ber om det gjeldende passordet vi har for systemet vårt, og vi har lagt det til.

Trinn 03: Installer TensorFlow

For å bygge maskinlæring og overvåkede nevrale modeller, er TensorFlow den mest kjente symbolske matematikkpakken. Etter å ha gått gjennom installasjonene, har vi kjørt den samme 'pip3'-installasjonsspørringen etterfulgt av 'Tensorflow'-pakkenavnet.

Andre TensorFlow-relaterte verktøy må være fullstendig installert på systemet. Disse verktøyene vil bli installert sammen med TensorFlow, og det kan ta opptil 10 minutter eller mer.

Trinn 04: Installer essensielle pakker

Etter den fruktbare konfigurasjonen av TensorFlow i Ubuntu 20.04-systemet, må vi også konfigurere noen byggepakker sammen med noen andre verktøy som 'git' og 'cmake'. Ved å prøve det samme 'apt'-verktøyet har vi installert mange av de nødvendige pakkene, som vist nedenfor:

Dette trinnet tar vår største oppmerksomhet ved å bekrefte denne installasjonen. Trykk på 'y' og fortsett.

Trinn 05: Lag et virtuelt miljø

Etter de nødvendige installasjonene er det på tide å lage et virtuelt miljø. Derfor må vi bruke Python3-verktøyet med '-m'-alternativet for å lage det virtuelle miljøet 'kerasenv' via 'venv'-variabelen. «ls»-spørringen viser at miljøet er opprettet.

Nå må vi bevege oss innenfor det virtuelle miljøet til Keras-mappen. Så vi har brukt 'cd'-instruksjonen sammen med navnet på en virtuell miljømappe. Etter det har vi beveget oss i 'bin'-mappen i dette virtuelle miljøet og listet opp underdelen. For å aktivere dette Python-miljøet, prøvde vi 'kilde'-instruksjonen i søkeområdet sammen med 'aktiver'-filen. Det virtuelle miljøet blir aktivert med navnet 'kerasenv'.

Trinn 06: Installer Python Libraries

Etter å ha satt det virtuelle Python-miljøet vellykket, må du installere alle de nødvendige Python-bibliotekene før installasjonen av Keras. Derfor har vi installert pandaens bibliotek først i det samme virtuelle miljøet ved å bruke 'pip'-pakken til Python.

Systemet vil begynne å konfigurere det i Pythons virtuelle miljø, som vist på bildet:

Etter å ha installert pandaenes bibliotek, prøv å installere NumPy-biblioteket ved å bruke følgende metode:

På en veldig lik måte, installer scipy-biblioteket til Python i samme miljø.

Installer nå matplotlib-biblioteket til Python i miljøet.

Python bruker clustering og regresjonsalgoritmer i maskinlæring for å utføre nevrale nettverksmodeller. For dette har den sci-kit learning-biblioteket som vi har installert med 'pip'-verktøyet sammen med '-u'-alternativet for å konfigurere de nødvendige pakkene også.

Behandlingen av scikit-bibliotekinstallasjonen er vist nedenfor:

For visualisering i dyp læring trenger vi at det sjøfødte biblioteket til Python installeres. Derfor har vi installert det i det samme miljøet med 'install'-spørringen.

Trinn 07: Installer Keras Library

Etter installasjonen av alle de nødvendige forutsetningsbibliotekene til Python, kan vi endelig installere Keras i det virtuelle miljøet til Python. 'Pip'-verktøyet vil bli brukt til dette formålet i 'installerings'-søket vårt med modulnavnet, det vil si 'Keras'. Hvis systemet viser at kravet allerede er oppfylt, betyr dette at det allerede er installert og konfigurert.

Hvis den ikke allerede er installert, vil denne spørringen begynne å laste ned og konfigurere den i det virtuelle miljøet uten en forsinkelse på ett sekund, og behandlingen vil bli vist, som nedenfor:

Etter full konfigurasjon og installasjon av 'Keras'-biblioteket på det virtuelle miljøet, er det på tide å vise all informasjon om det på skallet via 'pip show'-spørringen. Utførelsen av denne 'vis'-spørringen har presentert versjonen av Keras installert i vårt virtuelle miljø av Python, navnet, sammendraget, nettsiden, forfatteren, forfatterens e-post, lisensen, plasseringen den tar på systemet vårt, og mange mer som presentert nedenfor:

Etter de fineste installasjonene av Keras- og TensorFlow-bibliotekene til Python, må vi avslutte det virtuelle miljøet. For det, prøv 'deaktiver' spørringen på skallet og avslutt.

Trinn 08: Installer Anaconda Cloud

Python har en sky kalt 'Anaconda' som er nødvendig for å bygge nevrale nettverkseksempler i Python. Derfor har vi lastet ned utførelsesfilen til systemet vårt.

Denne filen har ligget i den gjeldende hjemmemappen til Linux-maskinen i henhold til 'ls'-spørringen. Du må sørge for at det er sjekksum først, dvs. om den er helt korrekt eller ikke via sha256sum-spørringen.

Etter det må vi installere den nedlastede Bash-filen til anaconda i systemet vårt ved å bruke 'Bash'-instruksjonen og filnavnet på samme konsoll. Den har bedt oss om å gjennomgå lisensavtalen før installasjonen. Så vi trykket 'Enter' for å fortsette.

Etter å ha gått gjennom lisensavtalen, ber den oss om å trykke 'ja' hvis vi godtar vilkårene. Du må trykke Enter for å fortsette å installere den på samme sted eller skrive banen til katalogen der du vil installere den. Ellers bruker du 'Ctrl-c' for å avbryte installasjonen.

Den vil vise den lange listen over pakker som vil bli installert i denne prosessen. Etter en del transaksjonsutførelse vil den begynne å installere pakkene.

Etter en stund ble anaconda installert med tilleggspakkene.

Du må kjøre 'aktiver'-filen fra anaconda-mappen via 'kilde'-spørringen som en rot.

Prøv å starte anaconda-navigatoren ved å bruke følgende spørring.

For å lage og jobbe med det nye conda-miljøet, prøv 'conda create'-instruksjonen med navnealternativet etterfulgt av det nye miljønavnet, dvs. PyCPU.

Denne prosessen krever vår bekreftelse på etableringen av det nye miljøet. Trykk på 'y'.

For å aktivere og kjøre det nyopprettede conda-miljøet, bruk 'conda activate'-spørringen med navnet på det nye miljøet, dvs. PyCPU-miljøet er nå aktivert.

Trinn 09: Installer Spyder IDE

Spyder IDE må installeres i dette miljøet for kjøring av Python-programmer. For dette har vi prøvd conda-installasjonsspørringen i PyCPU-miljøskallet med nøkkelordet 'spyder'.

Trykk på 'y' for å fortsette å installere Spyder.

Trinn 10: Installer Pandas and Keras Library

Etter installasjonen av Spyder, installer pandaens Python-bibliotek i et anaconda-miljø ved å bruke conda-installasjonsspørringen med -c-alternativet.

Igjen, trykk på 'y'-knappen for å fortsette.

Etter vellykket konfigurasjon av pandaer, installer Keras-biblioteket med samme spørring.

Fortsett etter å ha klikket på 'y'-knappen.

Du kan starte Spyder IDE i anaconda gjeldende miljøkonsoll som følger:

Spyder IDE har forberedt lansering.

Den skjulte mappen '.keras' har blitt plassert i hjemmekatalogen. Vis den og åpne 'keras.json'-filen for å legge til følgende konfigurasjoner i den.

Sett opp Keras og TensorFlow på Windows

For å sette opp Keras og TensorFlow i et Windows-miljø, må du sørge for at Python-språket sammen med 'pip'-biblioteket og Anaconda Navigator allerede er satt opp på det. Etter at du har konfigurert den, bør du åpne den fra søkeområdet og bevege deg innenfor kategorien 'miljøer'. I denne fanen finner du miljønavnet du jobber i, dvs. base. I området nedenfor finner du følgende fane. Trykk på 'opprett'-alternativet.

Her må du opprette et nytt miljønavn 'TensorFlow', dvs. er for øyeblikket inne i basismiljøet. Velg Pythons nyeste versjon som skal brukes, og trykk på 'Opprett'-knappen for å fortsette.

Du vil se at miljøet har begynt å laste.

Etter en stund blir TensorFlow-miljøet ferdig installert.

Fra området lengst til venstre kan du se alle installerte og tilgjengelige biblioteker og moduler for Python, som presentert nedenfor:

Nå må vi installere TensorFlow-backend-biblioteket til Python ved å bruke dette området. I søkefeltet skriver du 'TensorFlow' og merker den samme sakspakken fra den viste listen for å installere den. Trykk på 'Bruk'-knappen for å fortsette med installasjonen av TensorFlow sammen med undermodulene som 'Keras'.

Det har begynt å fungere og konfigurere TensorFlow på vårt Anaconda-miljø.

Under installasjonen vil den vise listen over underpakker som skal installeres i Anaconda-miljøet. Klapp på 'Bruk'-knappen og vent en stund til den er ferdig.

Etter en stund vil du finne alle de installerte pakkene i samme modulområde. Du kan se at Keras-biblioteket har blitt installert med andre pakker, og vi trenger ikke å installere det nå.

Søk etter søkeordet 'Jupyter' fra søkefeltet i Windows. Applikasjonen kalt 'Jupyter Notebook (TensorFlow)' vil bli vist sammen med andre. Trykk på den for å starte jupyter Notebook med backend TensorFlow aktivert. Opprett en ny Python-fil og begynn å jobbe.

Deep Learning Via Hard

Dyplæring inkluderer lag-for-lag-analyse av inntaket, hvor hvert lag gradvis trekker ut avanserte detaljer fra inndataene. Et fullstendig rammeverk er levert av Keras for å danne alle slags nevrale nettverk. Både kreativ og utrolig enkel å forstå, Keras. Det muliggjør nevrale nettverksmodeller som spenner fra de mest naive til de største og suverene komplekset.

Artificial Neural Network (ANN)

Metodikken for «Artificial Neural Network» (ANN) ser ut til å være den mest brukte og grunnleggende metoden for dyp læring. De tar signalene ut fra menneskesinnet, kroppens naturlige mest kompliserte komponent, som fungerer som deres modell. Over 90 milliarder mikroskopiske celler kalt 'nevroner' utgjør en persons hjerne. Aksoner og dendritter er typer nervefibre som kobler nevroner sammen. Den primære funksjonen til et akson er å sende data fra en koblet nevron til den neste. For mer informasjon, vennligst søk fra Googles søkemotor.

Keras arkitektur

Keras API-arkitekturen er klassifisert i tre hoveddeler som er oppført nedenfor. La oss ta en distinkt forkledning av hver enkelt.

• Modell
• Lag
• Kjernemoduler

Hard modell

Keras-modellen består av nøyaktig to typer, dvs. sekvensiell og funksjonell API.

Sekvensiell modell

I utgangspunktet er en sekvensiell modell en kronologisk samling av Keras-lag. Den enkle, forenklede sekvensielle modellen kan beskrive nesten alle de nevrale nettverkene som for tiden er i bruk. En tilpasset modell kan lages ved å bruke modellklassen som den sekvensielle modellen avslører. Underklassifiseringstilnærmingen kan brukes til å bygge en sofistikert modell av vår egen. Demonstrasjonen av den sekvensielle modellen er presentert nedenfor.

Legg til lag

Skriptet er startet fra import av sekvensiell modus via keras.models og den andre linjen har laget en sekvensiell modell. Etter det oppretter import av det tette laget et inputlag og legger til et inputlag til en modell. Det skjulte tette laget er opprettet og lagt til modellen, og det samme har blitt utført for utgangstettlaget.

Få tilgang til modellen

Du kan få informasjon om modelllagene dine, inngangsdataene den har brukt og utdataene. Model.layers-funksjonen lar deg få tilgang til alle lagene. Model.inputs vil vise inngangstensorer, og model.output vil vise utgangstensorer.

Serialiser modellen

Det er enkelt å returnere modellen som brukes i skriptet som et objekt eller JSON. For eksempel gir funksjonen get_config() modellen som en enhet/objekt. from_config()-funksjonen oppretter en ny modell ved å bruke objektet som en parametrisk verdi.

Du kan også endre modellen til JSON ved å bruke to_json()-funksjonen.

Modellsammendrag

For å få hele sammendraget angående lagene som brukes i modellen sammen med litt tilleggsinformasjon, kall oppsummering()-funksjonen.

Tren og forutsi modellen

For å trene og forutsi, bør vi bruke kompileringsfunksjonen, tilpasningsfunksjonen, evaluere funksjonen og forutsi funksjonen i denne forbindelse.

Harde lag

Hvert input-, skjult- og avkastningslag i den foreslåtte modellen av nevrale nettverk tilsvarer et annet Keras-lag i den virkelige modellen. Ethvert sofistikert nevralt nettverk kan raskt utvikles ved å bruke mange forhåndsbygde lag av Keras-biblioteket. Det er forskjellige Keras-lag vi har, det vil si kjernelag, sammenslåingslag, tilbakevendende lag og konvolusjonslag. Du kan studere dem ved å søke på nettet. De to første linjene har importert sekvensiell modus, tetthet, aktivering og utfallslag.

Vi har prøvd Sequential() API for å lage en frafallssekvensiell modell. Ved å kaste av aktiveringsmodellen 'relu' har vi laget et tett lag via 'Dense' API. For å imøtekomme overtilpasningen av det tette laget, har vi brukt Dropout() API, dvs. dropout-laging via dropout()-funksjonen. Etter dette har vi brukt et tettere lag her med 'relu'-aktiveringsmodellen. For å håndtere de tette lagene fra overtilpasning, må vi benytte oss av Dropout-lag. Til slutt har vi kastet av de siste tette lagene ved å bruke aktiveringsmodellen av typen 'softmax'.

Har du noen gang utført lagdeling mens du lager mat? I så fall ville ikke dette konseptet være vanskelig for deg å forstå. Resultatet av ett nivå vil tjene som inngangsdata for det etterfølgende laget. Her er de grunnleggende tingene som kreves for å bygge et helt nytt lag:

• Input Data Shape
• Totale nevroner/enheter i et lag
• Initialisatorer
• Regularizers
• Begrensninger
• Aktiveringer

Input Data Shape

Innenfor Python-språket har alle slags inndata blitt konvertert til en rekke heltall og deretter lagt til algoritmemodellen. Innenfor Python må vi spesifisere inngangsformen for å få utdata i henhold til vårt krav. I de følgende eksemplene har vi spesifisert inngangsformen (3,3), dvs. 3 rader og 3 kolonner. Utgangen har vist matrisen.

Initialisatorer

Initialiseringsmodulen til Keras Layers gir oss mange funksjoner for å spesifisere en spesifikk vekt for inndata. For eksempel spesifiserer zeros()-funksjonen 0 for alle, ones() spesifiserer for alle, og konstant()-funksjonen vil spesifisere en spesifisert konstant verdi lagt til av en bruker for alle og flere. For en bedre forståelse har vi brukt funksjonen identity() for å generere en identitetsmatrise. Resten av funksjonene kan også søkes fra søkemotoren.

Begrensninger

Det er forskjellige begrensningsfunksjoner tilgjengelig for å bruke begrensninger på 'vekt'-parameteren til laget, dvs. ikke-negativ, enhetsnorm, maksnorm, minmaksnorm og mange flere. I den følgende illustrasjonen har vi brukt begrensningsnormen mindre enn eller lik vekten. 'max_value'-parameteren er den øvre grensen for begrensningen som skal brukes, og aksen er dimensjonen som begrensningen skal brukes på, dvs. dimensjon 1.

Regularizers

Gjennom optimaliseringen pålegger den ulike kostnader på lagegenskapen. Den kom også opp med noen funksjoner for å gjøre det, det vil si L1-regularizer, L2-regularizer og 'LI and L2' Regularizer. Her er den enkleste illustrasjonen av L1-regularizer-funksjonen:

Aktiveringer

En unik funksjon kalt aktiveringsfunksjonen brukes for å bestemme om en bestemt nevron er aktiv eller ikke. Aktiveringsfunksjonen transformerer innkommende data på en kompleks måte, noe som hjelper nevronene å studere mer effektivt. Her er flere aktiveringsmetoder presentert i eksemplene nedenfor:

Harde moduler

Som vi vet at programmeringsmoduler vanligvis inneholder funksjoner, klasser og variabler som skal brukes til forskjellige og spesifikke formål. Akkurat som det inneholder Pythons Keras-bibliotek mange moduler i det. Du kan få all nødvendig kunnskap om Keras-modulene fra nettet.

Baksiden

En av de mest kjente og brukte modulene er 'Backend'-modulen som er designet for å bruke backend-bibliotekene til Python som TensorFlow og Theano. Ved å bruke backend-modulen kan vi bruke så mange backend-funksjoner som mulig fra TensorFlow og Theano-biblioteket. For å bruke backend-biblioteksmodulen, må vi spesifisere backend-biblioteket som skal brukes i konfigurasjonsfilen 'keras.json, som vi har opprettet i den skjulte .keras-mappen. Som standard har backend blitt spesifisert som 'TensorFlow', men du kan endre den til en annen også, for eksempel Theano eller CNTK.

I vårt eksempel vil vi bruke TensorFlow-biblioteket som en backend. For å laste inn konfigurasjonene til backend fra keras.json-filen til rotmappen 'keras', bruk:

• fra keras importer backend som k

Etter vellykket import av backend fra keras.json-filen, er det på tide å få backend-informasjonen ved å bruke variabelen 'k' med variabelen som skal hentes. Først har vi hentet navnet på en backend vi har brukt og allerede importert ved å bruke 'backend()'-funksjonen. Den returnerer 'Tensorflow' som sin backend-verdi. For å få float-verdien til backend, har vi kalt floatx()-funksjonen via Keras sitt 'k' variabelobjekt. Det viser at vi har brukt float32-verdien.

For å få formatet til bildedata, bruk image_Data_format()-funksjonen med 'k'-variabelen. Når du bruker det, viser det at vår backend har brukt bildedataformatet 'channels_last'. For å få eksponentkraften for backend, kall epsilon()-funksjonen med variabelen 'k'. Den returnerer at backend vil bruke eksponentialkraften til '07'. Det handler om henting av backend-informasjon.

Get_uid() funksjon

Det er på tide å ta en titt på noen backend-funksjoner til TensorFlow for å forstå funksjonaliteten. En av de mest brukte backend-funksjonene 'get_uid()-funksjonen som brukes til å identifisere standardgrafen vi har brukt. Å bruke den med prefikset=''-parameteren vil returnere '1', dvs. i henhold til bruken. Igjen, bruk av det ville returnere '2' som vi har kalt det igjen, og verdien av grafen har blitt økt. Etter å ha brukt «reset_uids»-funksjonen, vil grafbruker-ID-verdien tilbakestilles til 0. Derfor vil bruk av get_uid()-funksjonen igjen øke den med 1.

Plassholder() funksjon

Tensoren har brukt plassholder()-funksjonen for å holde forskjellige dimensjonale former i den. I den følgende illustrasjonen har vi for eksempel brukt det til å holde 3D-bildet i tensor via Keras-variabelen 'k' og lagre det til en annen variabel 'd'. Utdataene til variabel 'd' viser egenskapene til en form som brukes i plassholderen.

Funksjonen 'int_shape()' brukes til å vise formen til en verdi lagret i plassholderen 'd'.

Dot() funksjon

Har du noen gang multiplisert to vektorer? I så fall vil det ikke være utfordrende for deg å multiplisere to tensorer. For dette kom backend-biblioteket opp med 'dot'-funksjonen. For det første, for å holde de to forskjellige formene, har vi brukt formverdiene i plassholder()-funksjonen i de to første linjene for å lage to holdere 'x' og 'y'. Dot()-funksjonen har tatt 'x'- og 'y'-holderne for å multiplisere begge tensorene og lagre resultatet til en annen variabel 'z'. Ved bruk av 'z'-tensoren for utskrift, viste den den multipliserte resulterende tensorformen (1, 5) på skjermen.

Ones() funksjon

Ones()-funksjonen til backend-modulen har vært kjent for å initialisere alle verdiene til en bestemt form til 1. Vi har for eksempel brukt funksjonen ones() på tensorformen (3,3) og lagret resultatet til variabelen 'v'. Eval()-funksjonen er kastet av her for å evaluere verdien av en variabel 'v' og vises på i Python-miljøet. Til gjengjeld har den konvertert formen (3,3) til en matrise av alle med datatypen float32.

Batch_dot() funksjon

Tensorbatchen vil spesifisere de totale prøvene som skal sorteres før oppdatering av en modell. Batch_dot()-funksjonen til TensorFlow-backend brukes hovedsakelig til å finne ut multiplikasjonsresultatet av to forskjellige batchdata. Derfor har vi laget to tensorvariabler v1 og v2 og brukt Input()-funksjonen for å lagre dem i v1 og v2 som input. Etter det har vi prøvd batch_dot()-funksjonen på både tensorvariablene, v1 og v2, og den resulterende verdien vil bli lagret til en annen variabel 'v3'. Ved utskrift av variabelen v3 fant vi den resulterende formen (2,2) i retur.

Variabel funksjon

Hvis du noen gang har jobbet med et annet språk, kan du ha initialisert mange variabler med nøkkelordet 'var' eller uten det. Mange ganger kan du ha initialisert variablene med deres datatyper som heltall, streng eller tegn. Innenfor Python Keras-biblioteket kan vi lage hvilken som helst variabel ved å bruke variabel()-funksjonen på noen tensordata i form av samples.

I det følgende bildet har vi laget en variabel 'd' ved å legge til eksempel to listedata i en variabel()-funksjon med Keras-objektet 'k'. Etter å ha lagt til denne variabelen, har vi kalt transpose()-funksjonen på denne variabelen 'd' for å finne ut transponeringen av et eksempeldata i den via Keras-objektet 'k'. Den resulterende transponeringen vil bli lagret til en variabel 'val'. Utskriftssetningen til Python-språket har blitt brukt her for å skrive ut verdien av den resulterende 'val'-variabelen. Utskriftssetningen har vist valget av funksjon vi har brukt på variabelen 'd' og det totale antallet elementer i hver liste.

Etter dette prøvde vi 'eval'-funksjonen på 'val'-variabelen for å få transponeringen av prøvene lagt til variabelen 'd' og utskriftsfunksjonen viste den. Du kan se transponeringen av to lister i utdataene.

Den forrige kodeillustrasjonen ble oppnådd ved bruk av enkle Python-funksjoner uten å importere noe spesielt Python-bibliotek. 'Transponeringen' av to datasett kan finnes ved å bruke NumPy-matrisene. For dette må vi importere NumPy-biblioteket som 'n' i starten. Grunnformatet er det samme, men vi må initialisere formdatasettet med nøkkelordet 'array' i stedet for å bruke nøkkelordet 'variabel'. Eksempelet NumPy-matrisen skal holdes tilbake til variabelen 'd'. Det samme NumPy-objektet 'n' brukes til å kalle transpose()-funksjonen på 'd'-variabelen og lagre resultatet til variabelen 'val'.

Utskriftssetningen har kalt 'val'-variabelen i den for å vise transponeringstensoren. Du kan se at for å vise den resulterende transponerte verdien av 'val'-variabelen, trenger vi ikke 'eval'-funksjonen her. Nå har vi brukt variabelfunksjonen med argumentet 'd' og lagret resultatet til variabelen 'z'. Etter å ha prøvd print-setningen ved å legge til argumentverdien 'z' i den, viste den utdataene i det samme forrige formatet som vi har prøvd i variabeleksemplet ovenfor.

Is_sparse() funksjon

Ordet 'sparsom' i tensor brukes for en sparsom tensor som inneholder oppføringer med for det meste nuller. I dette eksempelet vil vi bruke funksjonen is_sparse() til backend-modulen for å sjekke om tensoren har de fleste nullene eller ikke.

Først har vi kalt plassholder()-funksjonen for å holde tensorformen (3,3) sammen med argumentet Sparse satt til sann. Denne plassholderverdien holdes til den foranderlige 'x' og vises. Utdataene har vist informasjon om plassholdervariabelen 'x'.

For eksempel brukes datatypen, formen og funksjonen på den. Etter dette prøvde vi print-setningen en gang til ved å kalle is_Sparse()-funksjonen i den. Denne funksjonen har tatt variabelen 'x' som argument for å vise om 'x'-tensoren er sparsom eller ikke. Utgangen viser 'true'.

To_dense() funksjon

Den tette tensoren sies å være den som brukte den kronologiske minneblokken til å lagre informasjonen på en tilstøtende måte og også representere informasjonsverdiene. 'to_dense()'-funksjonen til backend-modulen lar oss konvertere den sparsomme tensoren til en tett tensor. Derfor tar vi den samme plassholderfunksjonen for å legge til tensoren til variabelen 'x', og denne tensoren er satt til 'sparsom'.

Funksjonen 'to_dense()' brukes på den tette tensorvariabelen 'x', dvs. for å konvertere den til en tett tensor og lagre den til en annen variabel 'res'. Nå er 'res' en tett tensor i seg selv. Utskriftserklæringen har blitt fjernet for å skrive ut 'res'-variabelen. Bruken av utskriftssetninger for 'res'-variabelen viste informasjonen om den 'res'-konverterte variabelen, dvs. vellykket konvertert sparsom til tett og mye mer.

Deretter kalles en annen utskriftsfunksjon ved å bruke is_sparse()-funksjonen i den for å sjekke om variabelen 'res' er sparsom eller ikke. Utgangen har vist at variabelen 'res' ikke er sparsom, det vil si at vi allerede har konvertert den til en 'tett' tensor.

Random_uniform_variable() Funksjon

Random_uniform_variable()-funksjonen i Keras-backend-modulen er spesielt designet for initialisering av en tensor via den enhetlige distribusjonen. Det krever totalt tre argumenter. Det aller første argumentet 'form' brukes til å definere formens rader og kolonner i tuppelformen. Hvis du har gjort matematikk, har du kanskje lært begrepet gjennomsnitt og standardavvik.

I random_uniform_variable()-metoden er de to neste argumentene gjennomsnittet og typisk avvik fra en enhetlig fordeling. Innenfor denne illustrasjonen har vi initialisert to tensorer 'x' og 'y' ved å bruke standard uniform distribusjon via random_uniform_variable() funksjonen. Begge tensorene inneholder forskjellige formformater, dvs. rader og kolonner med samme gjennomsnitt og standardavvik, dvs. lav=0 og høy=1.

Etter dette kaster vi av 'punkt'-funksjonen og tar 'x' og 'y' tensorene i den for multiplikasjon. Resultatet av denne multiplikasjonen vil bli lagret til variabelen 'z'. Til slutt er int_shape() et must å bruke for å vise formen til en resulterende tensor 'z'. Utgangen viser tensoren (2,2).

Utils

Hvis du vil bruke noen av de svært nyttige funksjonene fra dyplæringskonseptet til Python, må du bruke utils-modulen til Keras-biblioteket i skriptene dine. Hvis du for eksempel vil vise dataene dine i HDF5Matrix-format, må du importere HDF5Matrix-klassen og bruke HDF5Matrix-funksjonen i skriptet.

To_categorical() funksjon

Denne funksjonen lar deg endre en klassevektor til en matrise, dvs. binær klassematrise. La oss si at vi har importert to_categorical()-funksjonen fra utils-modulen og initialisert en vektor 'A'. Vektoren 'A' har blitt sendt til to_categorical()-funksjonen. Den binære matrisen for denne klassevektoren 'A' har blitt vist.

print_summary() funksjon

For å skrive ut sammendraget av en modell vi har kastet av i miljøet vårt, ble funksjonen print_summary brukt.

plot_model() Funksjon

Funksjonen plot_model() angir modellen i et punktformat og lar deg lagre den i et dokument.

Konklusjon

For å oppsummere kan vi si at Python-språket er et nødvendig språk for dagens epoke ettersom alt blir raskt og teknologien har utviklet seg så vanvittig raskt. Gjennom denne læringsveiledningen har vi vært oppe i bruken av Pythons Keras-bibliotek i dyp læring og kunstige nevrale nettverk. For dette har vi også gått gjennom viktigheten og bruken av backend-biblioteket 'TensorFlow' for å få en klar forståelse. I tillegg har vi diskutert og forklart hver konfigurasjon som kreves for å sette opp Keras og Anaconda-miljøet i Python i Ubuntu 20.04 Linux-operativsystemet. Etter dette har vi grundig diskutert Keras-modellene, lagene og modulene én etter én sammen med deres mest brukte funksjoner. For demonstrasjon av funksjons-API-modellen, se etter den offisielle dokumentasjonen.