Keras tutorial
Keras
Blant de mest effektive og brukervennlige pluginsene for å bygge dyp-læringsalgoritmer er et pythonbasert forhøyet kunstige nevrale rammer kalt Keras, som vil bli konstruert på toppen av kjente dypt læringsrammer som Tensorflow eller CNTK. For å aktivere raskere utforskning ved å bruke dypere nevrale nettverk, er det designet brukervennlig, utvidbar og tilpasningsdyktig. Den håndterer både fremadgående og uttrekkbare nettverk hver for seg, så vel som i kombinasjonsboksen. Den bruker backend -pakken for å adressere små operasjoner fordi den ikke klarer å administrere dem. Distribusjonen av Keras, Fundamentals of Deep Learning, Keras Structures, Keras Laying, Keras Packages og sanntidsprogrammering vil bli dekket i denne leksjonen.
Sett opp Keras på Linux
Trinn 01: Oppdateringssystem
Før vi har full demonstrasjon av bruken av "Keras" -biblioteket i Python, må vi oppdatere Linux -maskinen vår for å gjøre det enkelt for videre installasjoner. For dette formålet må vi raskt åpne "konsoll" -applikasjonen fra de innebygde applikasjonene til systemet. Innenfor det aktuelle spørringsområ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 at brukerpassordet vårt fortsetter denne prosessen slik at systemet vårt kan oppdateres riktig.
Trinn 02: Installer Python og Pip
For bruk av dyp læring gjennom Keras og Tensorflow, må vi ha Pythons siste versjon konfigurert på maskinen vår. Derfor begynner vi å installere Pythons oppdaterte pakke sammen med den nødvendige "PIP" -verktøyet på systemet vårt. For det må vi igjen bruke den "passende" verktøyet til Ubuntu 20.04 Linux -systemet i "Installer" -spørsmålet på skallet etterfulgt av navnene på pakker som skal installeres, i.e., Python3 og Python3-Pip. Ved utførelsen av denne enkle spørringen 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 den vellykkede konfigurasjonen 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ørsmålet med alternativet “Pip3” og -uPGRADE for å installere oppgraderingen av Setuptools, i.e., Oppsettverktøy. Det ber om det nåværende passordet vi har for systemet vårt, og vi har lagt det til.
Trinn 03: Installer TensorFlow
For å bygge maskinlæring og overvåket nevrale modeller er TensorFlow den mest kjente symbolske matematikkpakken. Etter å ha gått gjennom installasjonene, har vi utført den samme “PIP3” installasjonsspørsmålet etterfulgt av “TensorFlow” -pakkenavnet.
Andre tensorflow-relaterte verktøy må være installert fullt ut på systemet. Disse verktøyene vil bli installert sammen med TensorFlow, og det kan ta opptil 10 eller flere minutter.
Trinn 04: Installer viktige pakker
Etter den fruktbare konfigurasjonen av TensorFlow i Ubuntu 20.04 System, vi må også konfigurere noen byggepakker sammen med noen andre verktøy som "Git" og "CMake". Ved å prøve det samme "passende" verktøyet, har vi installert mange av de nødvendige pakkene, som vist nedenfor:
Dette trinnet tar vår mest oppmerksomhet ved å bekrefte denne installasjonen. Trykk på “Y” og fortsett.
Trinn 05: Lag virtuelt miljø
Etter de nødvendige installasjonene er det på tide å skape et virtuelt miljø. Derfor må vi bruke Python3-verktøyet med alternativet “-m” for å lage det virtuelle miljøet “Kerasenv” via “Venv” -variabelen. "LS" -spørsmålet viser at miljøet er opprettet.
Nå må vi bevege oss innenfor det virtuelle miljøet i Keras -mappen. Så vi har brukt “CD” -instruksjonen sammen med navnet på en virtuell miljømappe. Etter det har vi beveget oss innenfor "bin" -mappen i dette virtuelle miljøet og listet opp suben. For å aktivere dette Python -miljøet prøvde vi “kilden” -instruksjonen på spørringsområdet sammen med "Aktiver" -filen. Det virtuelle miljøet blir aktivert med navnet “Kerasenv”.
Trinn 06: Installer Python -biblioteker
Etter å ha satt det virtuelle miljøet Python, må du installere alle nødvendige Python -biblioteker før installasjonen av Keras. Derfor har vi installert Pandas bibliotek først i det samme virtuelle miljøet ved å bruke "Pip" -pakken til Python.
Systemet vil begynne å konfigurere det innenfor Pythons virtuelle miljø, som vist på bildet:
Etter å ha installert Pandas 'bibliotek, kan du prøve å installere Numpy -biblioteket ved hjelp av følgende metode:
På en veldig lik måte, installer Scipy Library of Python i samme miljø.
Nå, installer Matplotlib -biblioteket til Python i miljøet.
Python bruker gruppering og regresjonsalgoritmer i maskinlæring for å utføre nevrale nettverksmodeller. For dette har det Sci-Kit Learn Library som vi installerer 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 Seaborn Library of Python skal installeres. Derfor har vi installert det i samme miljø med "install" -spørsmålet.
Trinn 07: Installer Keras Library
Etter installasjonen av alle nødvendige forutsetningsbiblioteker av Python, kan vi endelig installere Keras i det virtuelle miljøet til Python. "PIP" -verktøyet vil bli brukt til dette formålet i vår "install" -spørsmål med modulnavnet, i.e., “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 vises, som nedenfor:
Etter full konfigurasjon og installasjon av "Keras" -biblioteket om det virtuelle miljøet, er det på tide å vise full informasjon om det på skallet via "Pip Show" -spørsmålet. Utførelsen av dette "show" -spørsmålet har presentert versjonen av Keras installert i vårt virtuelle miljø av Python, navnet, dets sammendrag, hjemmesiden, forfatteren, forfatterens e -post, lisens, stedet det tar på systemet vårt og mange mer som presentert nedenfor:
Etter de fineste installasjonene av Keras- og TensorFlow -bibliotekene til Python, må vi slutte med det virtuelle miljøet. For det, prøv "Deaktiver" -spørsmålet på skallet og avslutt.
Trinn 08: Installer Anaconda Cloud
Python har en sky som heter “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 bodd i den nåværende hjemmemappen til Linux -maskinen i henhold til "LS" -spørsmålet. Du må sørge for at det er sjekksum først, jeg.e., Hvis det er helt riktig 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. Det har bedt oss om å gjennomgå lisensavtalen før installasjonen. Så vi tappet "Enter" for å fortsette.
Etter å ha gått gjennom lisensavtalen, ber den oss om å trykke på "ja" hvis vi er enige i vilkårene. Du må trykke Enter for å fortsette å installere den på samme sted eller skrive banen til katalogen der du vil installere den. Ellers, bruk "CTRL-C" for å avbryte installasjonen.
Det vil vise den lange listen over pakker som vil bli installert i denne prosessen. Etter litt transaksjonsutførelse vil den begynne å installere pakkene.
Etter en stund ble Anaconda vellykket installert med sine ekstra pakker.
Du må kjøre "Aktiver" -filen fra Anaconda -mappen via "Source" -spørsmålet som en rot.
Prøv å starte Anaconda Navigator ved å bruke følgende spørsmål.
For å opprette og jobbe med det nye Conda -miljøet, kan du prøve "Conda Create" -instruksjonen med Navnalternativet etterfulgt av det nye miljølavnet, i.e., Pycpu.
Denne prosessen krever vår bekreftelse på opprettelsen av det nye miljøet. Trykk på “Y”.
For å aktivere og kjøre det nyopplagte Conda -miljøet, bruk "Conda Active" -spørsmålet med navnet på det nye miljøet ditt, i.e., Pycpu -miljøet er nå aktivert.
Trinn 09: Installer Spyder IDE
Spyder IDE må installeres i dette miljøet for utførelse av Python -programmer. For dette har vi prøvd Conda Install -spørringen på Pycpu Environment Shell med nøkkelordet “Spyder”.
Trykk på “Y” for å fortsette å installere Spyder.
Trinn 10: Installer Pandas og Keras Library
Etter installasjonen av Spyder, installer Panda's Library of Python i et Anaconda -miljø ved hjelp av Conda Install -spørringen med -c -alternativet.
Igjen, trykk på "Y" -knappen for å fortsette.
Etter den vellykkede konfigurasjonen av Pandas, installer Keras -biblioteket med samme spørring.
Fortsett etter å ha klikket på "Y" -knappen.
Du kan lansere Spyder IDE i Anaconda Current Environment Console som følger:
Spyder IDE har forberedt seg på å lansere.
Den skjulte mappen ".Keras ”har vært lokalisert i hjemmekatalogen. Unhide det og åpne “Keras.JSON ”-fil 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 sitt "Pip" -bibliotek og Anaconda Navigator allerede er satt opp på det. Etter å ha satt den opp, bør du åpne det fra søkeområdet ditt og flytte innenfor fanen "Miljøer". I denne fanen finner du miljønavnet du jobber for øyeblikket i i.e., utgangspunkt. I området nedenfor finner du følgende faner. Trykk på alternativet "Opprett".
Her må du opprette et nytt miljølavn “Tensorflow”, jeg.e., er for tiden inne i basismiljøet. Velg Pythons siste 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 installert fullt ut.
Fra det venstre området kan du se alle installerte og tilgjengelige biblioteker og moduler for Python, som presentert nedenfor:
Nå må vi installere TensorFlow Backend Library of Python ved å bruke dette området. I søkefeltet, skriv “Tensorflow” og merk 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ø.
Mens installasjonen vil den vise listen over underpakker som skal installeres på Anaconda-miljøet. Klapp "påfør" -knappen og vent en stund til den er ferdig.
Etter en stund finner du alle de installerte pakkene i samme modulområde. Du kan se at Keras -biblioteket er installert med andre pakker, og vi trenger ikke å installere det nå.
Fra Windows søkefeltet, søk på nøkkelordet “Jupyter”. Applikasjonen som heter “Jupyter Notebook (TensorFlow)” ville bli vist sammen med andre. Trykk på den for å starte Jupyter Notebook med backend TensorFlow aktivert. Lag en ny Python -fil og begynn å jobbe.
Dyp læring via keras
Dyp læring inkluderer lag-for-lags analyse av inntaket, med hvert lag gradvis å trekke ut detaljer på avansert nivå fra inngangen. Et komplett rammeverk leveres av Keras for å danne alle slags nevrale nettverk. Både kreative og utrolig enkle å forstå, Keras. Det muliggjør nevrale nettverksmodeller som spenner fra det mest naive til det største og øverste komplekset.
Kunstig nevralt nettverk (ANN)
Metodikken "kunstig nevralt nettverk" (ANN) ser ut til å være den mest brukte og grunnleggende metoden for dyp læring. De tar signalene sine ut fra det menneskelige sinn, kroppens naturlige mest kompliserte komponent, som fungerer som deres modell. Over 90 milliarder mikroskopiske celler kalt "nevroner" utgjør et individs hjerne. Axoner 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 info, vennligst søk fra Googles søkemotor.
Keras arkitektur
Keras API -arkitekturen er klassifisert i tre hoveddeler oppført nedenfor. La oss ta en form for hver enkelt.
- Modell
- Lag
- Kjernemoduler
Keras -modell
Keras -modellen består av nøyaktig to typer, i.e., sekvensiell og funksjonell API.
Sekvensiell modell
Fundamentalt er en sekvensiell modell en kronologisk samling av keraslag. Den enkle, forenklede sekvensielle modellen kan beskrive nesten alle nevrale nettverk som for tiden er i bruk. En tilpasset modell kan lages ved hjelp av modellklassen som den sekvensielle modellen avslører. Underklassingsmetoden kan brukes til å bygge en sofistikert modell av vår helt egen. Demonstrasjonen av den sekvensielle modellen er presentert nedenfor.
Legg til lag
Skriptet er startet fra importen av sekvensiell modus via KERAS.Modeller og den andre linjen har laget en sekvensiell modell. Etter det skaper import av det tette laget et inngangslag og legger et inngangslag til en modell. Det skjulte tette laget er opprettet og lagt til modellen, og det samme er blitt utført for utgangspunktet.
Få tilgang til modellen
Du kan få informasjon om modelllagene dine, inndataene den har brukt og utdata -dataene. Modellen.Lagfunksjonen lar deg få tilgang til alle lagene. Modellen.Innganger vil vise inngangstensorer og modell.Utgangen vil vise utgangstensorer.
Serialiser modellen
Det er lett å returnere modellen som brukes i skriptet som et objekt eller JSON. For eksempel gir get_config () -funksjonen modellen som en enhet/objekt. Frome_config () -funksjonen oppretter en ny modell som bruker objektet som en parametrisk verdi.
Du kan også endre modellen din til JSON ved hjelp av TO_JSON () -funksjonen.
Modellsammendrag
For å få hele sammendraget angående lagene som brukes i modellen sammen med litt tilleggsinfo, ring sammendraget () -funksjonen.
Tren og forutsi modellen
For å trene og forutsi, bør vi bruke kompileringsfunksjonen, passe funksjonen, evaluere funksjonen og forutsi funksjon i denne forbindelse.
Keras lag
Hver inngang, 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 hjelp av mange forhåndsbygde lag på Keras-biblioteket. Det er forskjellige keraslag vi har, jeg.e., Kjernelag, bassenglag, tilbakevendende lag og konvolusjonslag. Du kan studere dem ved å søke på nettet. De to første linjene har importert sekvensiell modus, tette, aktivering og frafallslag.
Vi har prøvd Sequential () API for å lage en frafallssekvensiell modell. Ved å kaste av aktiveringsmodellen "RELU" har vi laget et tett lag via "tette" API. For å imøtekomme overmontering av det tette laget, har vi brukt frafallet () API, i.e., Frafalls lagdeling via frafall () -funksjonen. Etter dette har vi brukt et mer tett lag her med "Relu" aktiveringsmodellen. For å håndtere de tette lagene fra overmontering, må vi benytte oss av frafallslag. Til slutt har vi kastet av de endelige tette lagene våre ved hjelp av "softmax" -typen aktiveringsmodell.
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 fungere som inngangsdata for det påfølgende laget. Her er de grunnleggende tingene som kreves for å bygge et helt nytt lag:
- Inngangsdataform
- Totale nevroner/enheter i et lag
- Initializers
- Regularisatorer
- Begrensninger
- Aktiveringer
Inngangsdataform
Innen Python -språk er alle slags innganger blitt konvertert til en rekke heltall og deretter lagt til algoritmodellen. Innen Python må vi spesifisere inngangsformen for å få utdataene i henhold til vårt krav. I de følgende eksemplene har vi spesifisert inngangsformen (3,3), i.e., 3 rader og 3 kolonner. Utgangen har vist matrisen.
Initializers
Initialiseringsmodulen til Keras Layers gir oss mange funksjoner for å spesifisere en spesifikk vekt for inndata. For eksempel vil Zeros () -funksjonen spesifiserer 0 for alle, de () vil spesifisere for alle, og den konstante () -funksjonen vil spesifisere en spesifisert konstant verdiøkning av en bruker for alle og mer. For en bedre forståelse har vi brukt identitet () -funksjonen for å generere en identitetsmatrise. Resten av funksjonene kan søkes også fra søkemotoren.
Begrensninger
Det er forskjellige begrensningsfunksjoner tilgjengelig for å bruke begrensninger på "vekt" -parameteren til laget, i.e., Ikke-negativ, enhetsnorm, maks norme, minmaxnorm og mange flere. Innenfor følgende illustrasjon har vi brukt begrensningsnormen mindre enn eller lik vekten. Parameteren "Max_Value" er den øvre grensen for begrensningen som skal brukes, og aksen er dimensjonen som begrensningen vil bli brukt på, i.e., Dimensjon 1.
Regularisatorer
Gjennom optimalisering pålegger den forskjellige gebyrer på lagegenskapen. Det kom også med noen funksjoner for å gjøre det, jeg.e., L1 Regularizer, L2 Regularizer og “Li og L2” Regularizer. Her er den enkleste illustrasjonen av L1 -reguleringsfunksjonen:
Aktiveringer
En unik funksjon som kalles aktiveringsfunksjonen brukes for å avgjøre om en bestemt nevron er aktiv eller ikke. Aktiveringsfunksjonen transformerer de innkommende dataene på en kompleks måte, som hjelper nevronene med å studere mer effektivt. Her er flere aktiveringsmetoder presentert i eksemplene gitt nedenfor:
Keras -moduler
Som vi vet at programmeringsmoduler vanligvis inneholder funksjoner, klasser og variabler som skal brukes til forskjellige og spesifikke formål. Akkurat slik 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 hjelp av backend -modulen kan vi bruke så mange backend -funksjoner som mulig fra TensorFlow og Theano Library. For å bruke Backend Library -modulen, må vi spesifisere Backend -biblioteket som skal brukes i konfigurasjonsfilen “KERAS.Json, som vi har skapt i det skjulte .Keras -mappen. Som standard har backenden blitt spesifisert som "tensorflow", men du kan endre den til noen andre også, i.e., Theano, eller CNTK.
Innenfor vårt eksempel vil vi bruke TensorFlow -biblioteket som backend. For å laste konfigurasjonene til backend fra Keras.JSON -filen til roten “Keras” -mappe, bruk:
- fra Keras import backend som k
Etter å ha importert backend fra Keras.JSON -fil, det er på tide å få informasjon om backend 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 hjelp av "backend ()" -funksjonen. Den returnerer "tensorflow" som backend -verdien. For å få flytverdien til backend, har vi kalt FloatX () -funksjonen via Keras 'K ”-variable objekt. Det viser at vi har brukt float32 -verdien.
For å få formatet på bildedata, bruk Image_Data_Format () -funksjonen med "K" -variabelen. Ved bruk av den viser det at backenden vår har brukt "Channels_last" -dataformatet. For å få eksponentkraften for backend, ring Epsilon () -funksjonen med variabelen “K”. Det returnerer at backend vil bruke den eksponentielle kraften til “07”. Det handler om å hente informasjon om backend.
Get_uid () funksjon
Det er på tide å se på noen backend -funksjoner av Tensorflow for å forstå dens funksjonalitet. En av de mest brukte backend -funksjonene “get_uid () -funksjonen som brukes til å identifisere standardgrafen vi har brukt. Bruke det med prefikset = "Parameter ville returnere“ 1 ”, i.e., I henhold til bruken. Igjen, bruk av det ville returnere “2” slik vi har kalt det igjen, og verdien av grafen er økt. Etter å ha brukt "Reset_uids" -funksjonen, vil grafbruker -ID -verdien bli tilbakestilt til 0. Derfor vil bruk av get_uid () -funksjonen nok en gang øke den med 1.
Placeholder () -funksjon
Tensoren har brukt Placeholder () -funksjonen for å holde forskjellige dimensjonsformer i den. Innenfor følgende illustrasjon har vi for eksempel brukt det til å holde 3D-bildet i tensor via Keras-variabelen “K” og lagre det i en annen variabel “D”. Utgangen fra variabel “D” viser egenskapene til en form som brukes i plassholderen.
"Int_shape ()" -funksjonen brukes til å vise formen på en verdi som er 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 med "prikk" -funksjonen. For det første, for å holde de to forskjellige formene, har vi brukt formverdiene i plassholderen () -funksjonen i de første to linjene for å lage to innehavere “x” og “y”. Dot () -funksjonen har tatt “X” og “Y” -holderne for å multiplisere både tensorene og lagre resultatet til en annen variabel “Z”. Ved bruk av "z" -spensoren for utskrift, viste den den multipliserte resulterende tensorformen (1, 5) på skjermen.
De () -funksjonen
The Ones () -funksjonen til backend -modulen har vært kjent for å initialisere alle verdiene av en bestemt form til 1. For eksempel har vi brukt funksjonene () -funksjonen på tensorformen (3,3) og lagret resultatet til variabelen “V”. Eval () -funksjonen blir støpt 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 -matrise av alle med float32 -datatypen.
Batch_dot () funksjon
Tensor -batch vil spesifisere de totale prøvene som skal sorteres før du oppdaterer en modell. Batch_dot () -funksjonen til TensorFlow Backend brukes hovedsakelig for å 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”. Når vi skriver ut variabelen V3, fant vi den resulterende formen (2,2) til gjengjeld.
Variabel funksjon
Hvis du noen gang har jobbet på noe annet språk, kan du ha initialisert mange variabler med nøkkelordet “var” eller uten det. Mange ganger kan du ha initialisert variablene med datatypene deres som heltall, streng eller karakter. Innen Python Keras -biblioteket kan vi opprette hvilken som helst variabel ved hjelp av variabelen () -funksjonen på noen tensormata i form av prøver.
Innenfor følgende bilde har vi laget en variabel "D" ved å legge til eksemplet to -listedata i en variabel () -funksjon med Keras -objektet “k”. Etter å ha lagt til denne variabelen, har vi ringt Transpose () -funksjonen på denne variabelen “D” for å finne ut transponeringen av en prøvedata i den via Keras -objektet “K”. Den resulterende transponering vil bli lagret i en variabel “val”. Utskriftserklæringen om Python -språk har blitt brukt her for å skrive ut verdien av "val" resulterende variabel. Utskriftserklæringen har vist valg av funksjon vi har brukt på variabelen “D” og det totale antall elementer i hver liste.
Etter dette prøvde vi "eval" -funksjonen på "val" -variabelen for å få transponering av prøvene lagt til variabelen "D", og utskriftsfunksjonen viste den. Du kan se transponering av to lister i utdataene.
Den forrige kodeillustrasjonen ble oppnådd ved bruk av enkle Python -funksjoner uten å importere noe bestemt Python -bibliotek. "Transponer" av to datasett kan finne ved hjelp av Numpy -matriser. For dette må vi importere Numpy -biblioteket som "N" i starten. Grunnformatet er det samme, men vi må initialisere formdatasettet med "Array" nøkkelordet i stedet for å bruke nøkkelordet "variabel". Prøven numpy matrisen bør holdes tilbake til variabelen "D". Det samme numpy objektet "n" brukes til å kalle transpose () -funksjonen på "D" -variabelen og lagre resultatet til variabelen "val".
Utskriftserklæringen har kalt "val" -variabelen i den for å vise sin transponert tensor. Du kan se, for å vise den resulterende transponerte verdien av "val" -variabelen, vi trenger ikke "eval" -funksjonen her. Nå har vi brukt variabelfunksjonen med argumentet “D” og lagret resultatet til variabelen “Z”. Etter å ha prøvd utskriftserklæringen ved å legge til argumentverdien “z” i den, viste den utgangen i samme tidligere format vi har prøvd i ovennevnte variabelt eksempel.
Is_sparse () funksjon
Ordet "sparsom" i tensor brukes til en sparsom tensor som inneholder oppføringer med nuller for det meste. Innenfor dette eksemplet vil vi bruke Is_sparse () -funksjonen til backend -modulen for å sjekke om tensoren har de fleste nuller eller ikke.
Først har vi kalt Placeholder () -funksjonen for å holde tensorformen (3,3) sammen med argumentet sparsom satt til True. Denne plassholderverdien vil bli holdt til den mutable “x” og vises. Utgangen har vist informasjonen om plassholdervariabelen “x”.
For eksempel brukes datatype, form og funksjon. Etter dette prøvde vi utskriftserklæringen igjen og kalte IS_sparse () -funksjonen i den. Denne funksjonen har tatt den variable “x” som argument for å vise om “x” tensoren er sparsom eller ikke. Utgangen viser "sant".
To_tense () -funksjon
Den tette tensoren sies å være den som brukte den kronologiske minneblokken for å lagre informasjonen på en tilstøtende måte og representere informasjonsverdiene også. "To_Dense ()" -funksjonen til backend -modulen La oss konvertere den sparsomme tensoren til en tett tensor. Derfor tar vi den samme plassholderfunksjonen for å legge tensoren til variabel “x”, og denne tensoren er satt til “sparsom”.
"To_tense ()" -funksjonen brukes på den tette tensorvariabelen "x", i.e., 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 er avgitt for å skrive ut "Res" -variabelen. Bruken av utskriftsuttalelser for "Res" -variabelen viste informasjonen om "res" -konverterte variabelen, i.e., 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, jeg.e., Som 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 tar totalt tre argumenter. Det aller første argumentet "form" brukes til å definere formens rader og kolonner i tupleformen. Hvis du har gjort matematikk, kan du ha lært begrepet middel- og standardavvik.
I metoden random_uniform_variable () er de to neste argumentene det gjennomsnittlige og typiske avviket fra en enhetlig fordeling. Innenfor denne illustrasjonen har vi initialisert to tensorer “X” og “Y” ved hjelp av standarden Uniform Distribution via Random_Uniform_Variable () -funksjonen. Begge tensorene inneholder forskjellige formformater, jeg.e., rader og kolonner med samme middel og standardavvik, i.e., lav = 0, og høy = 1.
Etter dette kaster vi "Dot" -funksjonen som tar "X" og "Y" -spensorene i den for multiplikasjon. Resultatet av denne multiplikasjonen vil bli lagret i variabelen “z”. Til slutt er int_shape () et must å bruke for å vise formen til en resulterende tensor “z”. Utgangen viser tensoren (2,2).
Benyttede
Hvis du vil bruke noen av de veldig nyttige funksjonene fra Deep Learning -konseptet med Python, må du bruke utils -modulen til Keras -biblioteket i skriptene dine. For eksempel, hvis du 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 i en matrise, i.e., Binærklasse matrise. La oss si, vi har importert TO_Categorical () -funksjonen fra Utils -modulen og initialisert en vektor “A”. Vektoren “A” er overført til TO_Categorical () -funksjonen. Den binære matrisen for denne klassevektoren “A” er vist.
print_summary () funksjon
For å skrive ut sammendraget av en modell vi har kastet av i miljøet vårt, ble Print_Summary -funksjonen brukt.
plot_model () funksjon
PLOT_MODEL () -funksjonen betegner modellen i et prikkformat 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 tid, ettersom alt blir raskt og teknologien har utviklet seg så galskap raskt. Gjennom denne læringsretningslinjen har vi vært opp til 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 operativsystem. Etter dette har vi grundig diskutert Keras-modellene, lagene og moduler en etter en sammen med deres mest brukte funksjoner. For demonstrasjon av funksjon API -modellen, sjekk for den offisielle dokumentasjonen.