Hård

Bland de mest effektiva och användarvänliga plugins för att bygga djupinlärningsalgoritmer är ett Python-baserat förhöjt artificiellt neuralt ramverk kallat Keras, som skulle konstrueras ovanpå välkända ramverk för djupinlärning som TensorFlow eller CNTK. För att möjliggöra snabbare utforskning med djupare neurala nätverk är den designad användarvänlig, utbyggbar och anpassningsbar. Den hanterar både Feedforward och Retractable Networks separat, såväl som i kombination. Den använder Backend-paketet för att hantera små operationer eftersom den inte kan hantera dem. Implementeringen av Keras, grunderna för djupinlärning, Keras-strukturer, Keras-skiktning, Keras-paket och realtidsprogrammering kommer att behandlas i den här lektionen.

Ställ in Keras på Linux

Steg 01: Uppdatera systemet

Innan vi har en fullständig demonstration av användningen av Python-biblioteket 'Keras', måste vi helt uppdatera vår Linux-maskin för att göra det enkelt för ytterligare installationer. För detta ändamål måste vi snabbt öppna 'konsol'-applikationen från systemets inbyggda applikationer. Inom det specifika frågeområdet har vi lagt till 'uppdatering'-frågan för Linux med verktyget 'apt' och 'sudo'-privilegiet för att snabbt uppdatera systemet vi har. Det har krävt vårt användarlösenord för att fortsätta denna process så att vårt system kan uppdateras korrekt.

Steg 02: Installera Python och Pip

För användning av Deep Learning genom Keras och TensorFlow måste vi ha Pythons senaste version konfigurerad på vår maskin. Därför börjar vi installera Pythons uppdaterade paket tillsammans med dess nödvändiga 'pip'-verktyg på vårt system. För det måste vi återigen använda 'apt'-verktyget för Ubuntu 20.04 Linux-systemet i 'installera'-frågan på skalet följt av namnen på paket som ska installeras, dvs Python3 och Python3-pip. När denna enkla fråga utförs på konsolområdet kommer systemet att börja installera och konfigurera båda paketen i vårt system.

Å andra sidan, om ditt system har en gammal version av 'pip'-verktyget för Python installerat, bör du uppdatera det innan du går vidare.

Efter den framgångsrika konfigurationen av Python och dess 'pip' -verktyg är det dags att uppgradera Setuptools för Python för att undvika problem inom en snar framtid. Därför har vi provat installationsfrågan med verktyget 'pip3' och -upgrade-alternativet för att installera uppgraderingen av Setuptools, det vill säga installationsverktygen. Den frågar efter det nuvarande lösenordet vi har för vårt system, och vi har lagt till det.

Steg 03: Installera TensorFlow

För att bygga maskininlärning och övervakade neurala modeller är TensorFlow det mest välkända symboliska matematikpaketet. Efter att ha gått igenom installationerna har vi kört samma 'pip3' installationsfråga följt av paketnamnet 'Tensorflow'.

Andra TensorFlow-relaterade verktyg måste vara helt installerade på systemet. Dessa verktyg kommer att installeras tillsammans med TensorFlow, och det kan ta upp till 10 minuter eller mer.

Steg 04: Installera Essential Packages

Efter den fruktbara konfigurationen av TensorFlow i Ubuntu 20.04-systemet måste vi också konfigurera några byggpaket tillsammans med några andra verktyg som 'git' och 'cmake'. Genom att prova samma 'apt'-verktyg har vi installerat många av de nödvändiga paketen, som visas nedan:

Det här steget tar vår största uppmärksamhet genom att bekräfta denna installation. Tryck på 'y' och fortsätt.

Steg 05: Skapa virtuell miljö

Efter de nödvändiga installationerna är det dags att skapa en virtuell miljö. Därför måste vi använda verktyget Python3 med alternativet '-m' för att skapa den virtuella miljön 'kerasenv' via variabeln 'venv'. 'ls'-frågan visar att miljön är skapad.

Nu måste vi flytta inom den virtuella miljön i mappen Keras. Så vi har använt 'cd'-instruktionen tillsammans med namnet på en virtuell miljömapp. Efter det har vi flyttat in i mappen 'bin' i denna virtuella miljö och listat dess underordnade. För att aktivera denna Python-miljö försökte vi 'källa'-instruktionen i dess frågeområde tillsammans med 'aktivera'-filen. Den virtuella miljön aktiveras med namnet 'kerasenv'.

Steg 06: Installera Python Libraries

Efter att ha ställt in den virtuella Python-miljön framgångsrikt måste du installera alla nödvändiga Python-bibliotek innan installationen av Keras. Därför har vi installerat pandans bibliotek först i samma virtuella miljö med hjälp av 'pip'-paketet från Python.

Systemet kommer att börja konfigurera det i Pythons virtuella miljö, som visas i bilden:

Efter att du har installerat pandornas bibliotek, försök att installera NumPy-biblioteket med följande metod:

På ett mycket liknande sätt, installera scipy-biblioteket i Python i samma miljö.

Installera nu matplotlib-biblioteket i Python i miljön.

Python använder klustrings- och regressionsalgoritmer i maskininlärning för att utföra neurala nätverksmodeller. För detta har den Sci-kit learning-biblioteket som vi installerar med verktyget 'pip' tillsammans med alternativet '-u' för att konfigurera de nödvändiga paketen också.

Bearbetningen av scikit-biblioteksinstallationen har visats nedan:

För visualisering i djupinlärning behöver vi Seaborn-biblioteket Python installeras. Därför har vi installerat det i samma miljö som 'installera'-frågan.

Steg 07: Installera Keras Library

Efter installationen av alla nödvändiga förutsättningsbibliotek för Python kan vi äntligen installera Keras i Pythons virtuella miljö. Verktyget 'pip' kommer att användas för detta ändamål i vår 'installera'-fråga med modulnamnet, det vill säga 'Keras'. Om systemet visar att dess krav redan är uppfyllt betyder det att det redan är installerat och konfigurerat.

Om den inte redan är installerad kommer denna fråga att börja ladda ner och konfigurera den i den virtuella miljön utan en fördröjning på en sekund och bearbetningen kommer att visas enligt nedan:

Efter den fullständiga konfigurationen och installationen av 'Keras'-biblioteket i den virtuella miljön, är det dags att visa all information om det på skalet via 'pip show'-frågan. Utförandet av denna 'visa'-fråga har presenterat versionen av Keras installerad i vår virtuella miljö Python, dess namn, dess sammanfattning, dess hemsida, författare, författarens e-post, licens, platsen den tar på vårt system och många mer som presenteras nedan:

Efter de finaste installationerna av Python-biblioteken Keras och TensorFlow måste vi avsluta den virtuella miljön. För det, prova 'avaktivera'-frågan på skalet och avsluta.

Steg 08: Installera Anaconda Cloud

Python har ett moln som heter 'Anaconda' som är nödvändigt för att bygga exempel på neurala nätverk i Python. Därför har vi laddat ner dess exekveringsfil till vårt system.

Den här filen har legat i den aktuella hemmappen på Linux-maskinen enligt 'ls'-frågan. Du måste se till att det är checksumma först, d.v.s. om det är helt korrekt eller inte via sha256sum-frågan.

Efter det måste vi installera den nedladdade Bash-filen av anaconda i vårt system med hjälp av 'Bash'-instruktionen och filnamnet på samma konsol. Den har bett oss att granska licensavtalet innan installationen. Så vi tryckte på 'Enter' för att fortsätta.

Efter att ha gått igenom licensavtalet ber den oss att trycka på 'ja' om vi accepterar villkoren. Du måste trycka på Enter för att fortsätta installera den på samma plats eller skriv sökvägen till katalogen där du vill installera den. Annars, använd 'Ctrl-c' för att avbryta installationen.

Den kommer att visa den långa listan med paket som kommer att installeras i denna process. Efter en del transaktionsexekvering kommer den att börja installera paketen.

Efter ett tag installerades anacondan framgångsrikt med dess ytterligare paket.

Du måste köra 'aktivera'-filen från anaconda-mappen via 'källa'-frågan som en rot.

Försök att starta anaconda-navigatorn med hjälp av följande fråga.

För att skapa och arbeta med den nya conda-miljön, prova 'conda create'-instruktionen med namnalternativet följt av det nya miljönamnet, d.v.s. PyCPU.

Denna process kräver vår bekräftelse på skapandet av den nya miljön. Tryck på 'y'.

För att aktivera och köra den nyskapade conda-miljön, använd 'conda activate'-frågan med namnet på din nya miljö, dvs PyCPU-miljön är nu aktiverad.

Steg 09: Installera Spyder IDE

Spyder IDE måste installeras i denna miljö för körning av Python-program. För detta har vi provat conda-installationsfrågan i PyCPU-miljöskalet med nyckelordet 'spyder'.

Tryck på 'y' för att fortsätta installera Spyder.

Steg 10: Installera Pandas and Keras Library

Efter installationen av Spyder, installera pandans bibliotek av Python i en anaconda-miljö med hjälp av conda-installationsfrågan med alternativet –c.

Återigen, tryck på 'y'-knappen för att fortsätta.

Efter framgångsrik konfiguration av pandor, installera Keras-biblioteket med samma fråga.

Fortsätt efter att ha klickat på 'y'-knappen.

Du kan starta Spyder IDE i anacondas nuvarande miljökonsol enligt följande:

Spyder IDE har förberett sig för lansering.

Den dolda mappen '.keras' har funnits i hemkatalogen. Visa den och öppna filen 'keras.json' för att lägga till följande konfigurationer i den.

Ställ in Keras och TensorFlow på Windows

För att ställa in Keras och TensorFlow i en Windows-miljö måste du se till att Python-språket tillsammans med dess 'pip'-bibliotek och Anaconda Navigator redan är inställt på det. Efter att du har ställt in den bör du öppna den från ditt sökområde och flytta inom fliken 'miljöer'. På den här fliken hittar du miljönamnet du för närvarande arbetar i, dvs basen. I området nedan hittar du följande flik. Tryck på alternativet 'skapa'.

Här måste du skapa ett nytt miljönamn 'TensorFlow', d.v.s. är för närvarande inne i basmiljön. Välj Pythons senaste version som ska användas och tryck på knappen 'Skapa' för att fortsätta.

Du kommer att se att miljön har börjat ladda.

Efter ett tag blir TensorFlow-miljön helt installerad.

Från området längst till vänster kan du se alla installerade och tillgängliga bibliotek och moduler för Python, som presenteras nedan:

Nu måste vi installera TensorFlow backend-biblioteket i Python med det här området. Skriv 'TensorFlow' i sökfältet och markera samma fallpaket från den visade listan för att installera det. Tryck på knappen 'Apply' för att fortsätta med installationen av TensorFlow tillsammans med dess undermoduler som 'Keras'.

Det har börjat fungera och konfigurera TensorFlow på vår Anaconda-miljö.

Under installationen kommer den att visa listan över underpaket som kommer att installeras i Anaconda-miljön. Klappa på 'Apply'-knappen och vänta ett tag tills det är klart.

Efter ett tag hittar du alla installerade paket i samma modulområde. Du kan se att Keras-biblioteket har installerats med andra paket och vi behöver inte installera det nu.

Sök efter nyckelordet 'Jupyter' i sökfältet i Windows. Applikationen med namnet 'Jupyter Notebook (TensorFlow)' skulle visas tillsammans med andra. Tryck på den för att starta Jupyter Notebook med backend TensorFlow aktiverat. Skapa en ny Python-fil och börja arbeta.

Deep Learning Via Hard

Deep learning inkluderar lager-för-lager-analys av intaget, där varje lager gradvis extraherar detaljer på avancerad nivå från input. En fullständig ram tillhandahålls av Keras för att bilda alla slags neurala nätverk. Både kreativ och otroligt enkel att förstå, Keras. Det möjliggör neurala nätverksmodeller som sträcker sig från de mest naiva till de största och suveräna komplexa.

Artificiellt neuralt nätverk (ANN)

Metodiken 'Artificial Neural Network' (ANN) verkar vara den mest använda och grundläggande metoden för djupinlärning. De tar sina ledtrådar från det mänskliga sinnet, vår kropps naturliga mest komplicerade komponent, som fungerar som deras modell. Över 90 miljarder mikroskopiska celler som kallas 'neuroner' utgör en individs hjärna. Axoner och dendriter är typer av nervfibrer som länkar ihop neuroner. Den primära funktionen för ett axon är att skicka data från en länkad neuron till nästa. För mer information, sök från Googles sökmotor.

Keras arkitektur

Keras API-arkitektur har klassificerats i tre huvuddelar listade nedan. Låt oss ta en distinkt skepnad av var och en.

• Modell
• Lager
• Kärnmoduler

Hård modell

Keras-modellen består av exakt två typer, det vill säga sekventiell och funktionell API.

Sekventiell modell

I grunden är en sekventiell modell en kronologisk sammanställning av Keras-lager. Den enkla, förenklade sekventiella modellen kan beskriva nästan alla neurala nätverk som för närvarande används. En anpassad modell kan göras med den modellklass som den sekventiella modellen avslöjar. Underklassningsmetoden kan användas för att bygga en egen sofistikerad modell. Demonstrationen av den sekventiella modellen har presenterats nedan.

Lägg till lager

Skriptet har startats från importen av sekventiellt läge via keras.models och den andra raden har skapat en sekventiell modell. Efter det skapar import av det täta lagret ett indatalager och lägger till ett indatalager till en modell. Det dolda täta lagret har skapats och lagts till i modellen och detsamma har utförts för det utdatatäta lagret.

Gå till modellen

Du kan få information om dina modelllager, indata som den har använt och dess utdata. Funktionen model.layers låter dig komma åt alla lager. Model.inputs skulle visa ingångstensorer, och model.output kommer att visa utgångstensorer.

Serialisera modellen

Det är lätt att returnera modellen som används i skriptet som ett objekt eller JSON. Till exempel ger funktionen get_config() modellen som en enhet/objekt. Funktionen from_config() skapar en ny modell som använder objektet som ett parametriskt värde.

Du kan också ändra din modell till JSON med funktionen to_json() .

Modellsammanfattning

För att få hela sammanfattningen angående de lager som används i modellen tillsammans med lite ytterligare information, anropa summary()-funktionen.

Träna och förutsäg modellen

För att träna och förutsäga bör vi använda kompileringsfunktionen, passningsfunktionen, utvärdera funktionen och förutsäga funktionen i detta avseende.

Hårda lager

Varje ingångs-, dold- och avkastningslager i den föreslagna modellen av neurala nätverk motsvarar ett annat Keras-lager i den verkliga modellen. Alla sofistikerade neurala nätverk kan snabbt utvecklas med många förbyggda lager i Keras-biblioteket. Det finns olika Keras-lager vi har, det vill säga kärnlager, poollager, återkommande lager och faltningslager. Du kan studera dem genom att söka på webben. De två första raderna har importerat sekventiellt läge, täthet, aktivering och bortfallslager.

Vi har provat Sequential() API för att skapa en sekventiell modell för bortfall. Genom att ta bort aktiveringsmodellen 'relu' har vi skapat ett tätt lager via 'Dense' API. För att tillgodose överpassningen av det täta lagret har vi använt Dropout() API, dvs dropout-lager via dropout()-funktionen. Efter detta har vi använt ett mer tätt lager här med 'relu'-aktiveringsmodellen. För att hantera de täta lagren från överpassning måste vi använda oss av Dropout-lager. Till slut har vi kastat av våra sista täta lager med aktiveringsmodellen av typen 'softmax'.

Har du någonsin utfört lager under matlagning? Om så är fallet, skulle detta koncept inte vara svårt för dig att förstå. Resultatet av en nivå kommer att fungera som indata för det efterföljande lagret. Här är de grundläggande sakerna som krävs för att bygga ett helt nytt lager:

• Indataform
• Totalt antal neuroner/enheter i ett lager
• Initialiserare
• Regulatorer
• Begränsningar
• Aktiveringar

Indataform

Inom Python-språket har alla sorters indata omvandlats till en rad heltal och sedan lagts till i algoritmmodellen. Inom Python måste vi specificera ingångsformen för att få utdata enligt vårt krav. I följande exempel har vi specificerat ingångsformen (3,3), dvs 3 rader och 3 kolumner. Utgången har visat matrisen.

Initialiserare

Initialiseringsmodulen i Keras Layers ger oss många funktioner för att specificera en specifik vikt för indata. Till exempel anger funktionen zeros() 0 för alla, ones() skulle specificera för alla, och funktionen constant() kommer att specificera ett specificerat konstant värde som lagts till av en användare för alla och fler. För en bättre förståelse har vi använt funktionen identity() för att generera en identitetsmatris. Resten av funktionerna kan också sökas från sökmotorn.

Begränsningar

Det finns olika begränsningsfunktioner tillgängliga för att tillämpa begränsningar på 'vikt'-parametern för lagret, d.v.s. icke-negativ, enhetsnorm, maxnorm, minmaxnorm och många fler. Inom följande illustration har vi tillämpat begränsningsnormen mindre än eller lika med vikten. Parametern 'max_value' är den övre gränsen för den begränsning som ska tillämpas och axeln är den dimension på vilken begränsningen skulle tillämpas, dvs dimension 1.

Regulatorer

Under hela optimeringen lägger den olika avgifter på lageregenskapen. Den kom också med några funktioner för att göra det, t.ex. L1 regularizer, L2 regularizer och 'LI and L2' Regularizer. Här är den enklaste illustrationen av L1 regularizer-funktionen:

Aktiveringar

En unik funktion som kallas aktiveringsfunktionen används för att avgöra om en viss neuron är aktiv eller inte. Aktiveringsfunktionen omvandlar inkommande data på ett komplext sätt, vilket hjälper neuronerna att studera mer effektivt. Här är flera aktiveringsmetoder som presenteras i exemplen nedan:

Hårda moduler

Som vi vet innehåller programmeringsmoduler vanligtvis funktioner, klasser och variabler som ska användas för olika och specifika ändamål. Precis som det innehåller Pythons Keras-bibliotek många moduler i det. Du kan få all nödvändig kunskap om Keras-modulerna från webben.

Backend

En av dess mest kända och använda moduler är 'Backend'-modulen som har designats för att använda backend-biblioteken i Python som TensorFlow och Theano. Med hjälp av backend-modulen kan vi använda så många backend-funktioner som möjligt från TensorFlow- och Theano-biblioteket. För att använda backend-biblioteksmodulen måste vi specificera backend-biblioteket som ska användas i konfigurationsfilen 'keras.json, som vi har skapat i den dolda .keras-mappen. Som standard har backend specificerats som 'TensorFlow', men du kan ändra den till någon annan också, t.ex. Theano eller CNTK.

I vårt exempel kommer vi att använda TensorFlow-biblioteket som en backend. För att ladda konfigurationerna av backend från filen keras.json i rotmappen 'keras', använd:

• från keras importera backend som k

Efter att ha lyckats importera backend från filen keras.json är det dags att hämta backend-informationen med hjälp av variabeln 'k' med variabeln som ska hämtas. Först har vi hämtat namnet på en backend som vi har använt och redan importerat med funktionen 'backend()'. Den returnerar 'Tensorflow' som dess backend-värde. För att få float-värdet för backend, har vi anropat floatx()-funktionen via Keras 'k' variabelobjekt. Det visar att vi har använt float32-värdet.

För att få formatet för bilddata, använd funktionen image_Data_format() med variabeln 'k'. När vi använder det visar det att vår backend har använt bilddataformatet 'channels_last'. För att få exponentkraften för backend, anropa epsilon()-funktionen med variabeln 'k'. Det returnerar att backend kommer att använda exponentialpotentialen '07'. Det handlar om hämtning av backend-information.

Get_uid() Funktion

Det är dags att ta en titt på några backend-funktioner i TensorFlow för att förstå dess funktionalitet. En av dess mest använda backend-funktioner 'get_uid() funktion som används för att identifiera standardgrafen vi har använt. Att använda den med parametern prefix='' skulle returnera '1', det vill säga enligt användningen. Återigen, att använda det skulle returnera '2' som vi har kallat det igen och värdet på grafen har ökats. Efter att ha använt funktionen 'reset_uids' skulle grafens användar-ID-värde återställas till 0. Om du använder funktionen get_uid() igen skulle det därför ökas med 1.

Placeholder() Funktion

Tensorn har använt funktionen platshållare() för att hålla olika dimensionsformer i den. Till exempel, inom följande illustration, har vi använt den för att hålla 3D-bilden i tensor via Keras-variabeln 'k' och spara den till en annan variabel 'd'. Utdata från variabel 'd' visar egenskaperna för en form som används i platshållaren.

Funktionen 'int_shape()' används för att visa formen på ett värde som sparats i platshållaren 'd'.

Dot() Funktion

Har du någonsin multiplicerat två vektorer? Om så är fallet kommer det inte att vara en utmaning för dig att multiplicera två tensorer. För detta kom backend-biblioteket med 'dot'-funktionen. För det första, för att hålla de två olika formerna, har vi använt formvärdena i platshållaren()-funktionen i de två första raderna för att skapa två hållare 'x' och 'y'. Dot()-funktionen har tagit 'x'- och 'y'-hållarna för att multiplicera båda tensorerna och spara resultatet till en annan variabel 'z'. När 'z'-tensorn användes för utskrift, visade den den multiplicerade resulterande tensorformen (1, 5) på skärmen.

Ones() Funktion

Ones()-funktionen i backend-modulen har varit känd för att initiera alla värden för en viss form till 1. Vi har till exempel använt funktionen ones() på tensorformen (3,3) och sparat resultatet till variabeln 'v'. Funktionen eval() tas bort här för att utvärdera värdet på en variabel 'v' och visas i Python-miljön. I gengäld har den konverterat formen (3,3) till en arraymatris av alla med datatypen float32.

Batch_dot() Funktion

Tensorbatchen skulle ange det totala antalet prover som ska sorteras innan en modell uppdateras. Batch_dot()-funktionen i TensorFlow-backenden används huvudsakligen för att ta reda på multiplikationsresultatet av två olika batchdata. Därför har vi skapat två tensorvariabler v1 och v2 och använt funktionen Input() för att spara dem i v1 och v2 som indata. Efter det har vi provat funktionen batch_dot() på både tensorvariablerna, v1 och v2, och det resulterande värdet skulle sparas till en annan variabel 'v3'. När vi skrev ut variabeln v3 hittade vi den resulterande formen (2,2) i gengäld.

Variabel funktion

Om du någonsin har arbetat med något annat språk kan du ha initierat många variabler med nyckelordet 'var' eller utan det. Många gånger kan du ha initierat variablerna med deras datatyper som heltal, sträng eller tecken. Inom Python Keras-biblioteket kan vi skapa vilken variabel som helst med hjälp av variabel()-funktionen på vissa tensordata i form av sampel.

I följande bild har vi skapat en variabel 'd' genom att lägga till exempel två listdata till en variabel() funktion med Keras-objektet 'k'. Efter att ha lagt till denna variabel har vi anropat transpose()-funktionen på denna variabel 'd' för att ta reda på transponeringen av en exempeldata i den via Keras-objektet 'k'. Den resulterande transponeringen skulle sparas till en variabel 'val'. Utskriftssatsen för Python-språket har använts här för att skriva ut värdet på den resulterande variabeln 'val'. Utskriftssatsen har visat valet av funktion vi har tillämpat på variabeln 'd' och det totala antalet element i varje lista.

Efter detta försökte vi funktionen 'eval' på variabeln 'val' för att få transponeringen av proverna till variabeln 'd' och utskriftsfunktionen visade den. Du kan se transponeringen av två listor i utgången.

Den tidigare kodillustrationen uppnåddes genom användning av enkla Python-funktioner utan att importera något särskilt Python-bibliotek. 'Transponeringen' av två datamängder kan hittas med hjälp av NumPy-matriserna. För detta måste vi importera NumPy-biblioteket som 'n' i början. Grundformatet är detsamma, men vi måste initiera formdatauppsättningen med nyckelordet 'array' istället för att använda nyckelordet 'variabel'. NumPy-exemplet ska hållas tillbaka till variabeln 'd'. Samma NumPy-objekt 'n' används för att anropa transpose()-funktionen på variabeln 'd' och spara dess resultat i variabeln 'val'.

Utskriftssatsen har anropat variabeln 'val' i den för att visa dess transponeringstensor. Du kan se att för att visa det resulterande transponerade värdet för variabeln 'val' behöver vi inte funktionen 'eval' här. Nu har vi använt variabelfunktionen med argumentet 'd' och sparat resultatet till variabeln 'z'. Efter att ha provat print-satsen genom att lägga till argumentvärdet 'z' i den, visade den utdata i samma tidigare format som vi har försökt i variabelexemplet ovan.

Is_sparse() Funktion

Ordet 'gles' i tensor används för en gles tensor som innehåller poster med nollor mestadels. I det här exemplet kommer vi att använda funktionen is_sparse() i backend-modulen för att kontrollera om tensorn har de flesta nollorna eller inte.

Först har vi anropat platshållaren()-funktionen för att hålla tensorformen (3,3) tillsammans med argumentet Sparse satt till sant. Detta platshållarvärde skulle hållas till det föränderliga 'x' och visas. Utdatan har visat information om platshållarvariabeln 'x'.

Till exempel tillämpas dess datatyp, form och funktion på den. Efter detta provade vi print-satsen en gång till och anropade funktionen is_Sparse() i den. Den här funktionen har tagit variabeln 'x' som sitt argument för att visa om 'x'-tensorn är gles eller inte. Utgången visar 'true'.

To_dense() Funktion

Den täta tensorn sägs vara den som använde det kronologiska minnesblocket för att lagra informationen på ett intilliggande sätt och även representera informationens värden. Funktionen 'to_dense()' i backend-modulen låter oss konvertera den glesa tensorn till en tät tensor. Därför tar vi samma platshållarfunktion för att lägga till tensorn till variabeln 'x' och denna tensor har satts till 'gles'.

Funktionen 'to_dense()' tillämpas på den täta tensorvariabeln 'x', dvs för att konvertera den till en tät tensor och spara den till en annan variabel 'res'. Nu är 'res' en tät tensor i sig. Utskriftssatsen har tagits bort för att skriva ut variabeln 'res'. Användningen av utskriftssatser för variabeln 'res' visade informationen om den konverterade 'res'-variabeln, det vill säga framgångsrikt konverterat sparse till tät och mycket mer.

Sedan anropas en annan utskriftsfunktion genom att använda funktionen is_sparse() i den för att kontrollera om variabeln 'res' är sparsam eller inte. Utdata har visat att variabeln 'res' inte är gles, det vill säga eftersom vi redan har konverterat den till en 'tät' tensor.

Random_uniform_variable() Funktion

Funktionen random_uniform_variable() i Keras backend-modul är speciellt utformad för initiering av en tensor via den enhetliga fördelningen. Det krävs totalt tre argument. Det allra första argumentet 'form' används för att definiera formens rader och kolumner i tupelformen. Om du har gjort matematik har du kanske lärt dig begreppet medelvärde och standardavvikelse.

I metoden random_uniform_variable() är de följande två argumenten medelvärdet och den typiska avvikelsen från en enhetlig fördelning. Inom denna illustration har vi initierat två tensorer 'x' och 'y' med hjälp av den enhetliga standardfördelningen via funktionen random_uniform_variable() . Båda tensorerna innehåller olika formformat, dvs rader och kolumner med samma medelvärde och standardavvikelse, dvs låg=0 och hög=1.

Efter detta tar vi bort 'punkt'-funktionen och tar 'x' och 'y' tensorerna i den för multiplikation. Resultatet av denna multiplikation skulle sparas till variabeln 'z'. I slutändan är int_shape() ett måste att använda för att visa formen på en resulterande tensor 'z'. Utgången visar tensorn (2,2).

Utils

Om du vill använda några av de mycket användbara funktionerna från Pythons djupinlärningskoncept måste du använda modulen utils i Keras-biblioteket i dina skript. Om du till exempel vill visa dina data i HDF5Matrix-format måste du importera HDF5Matrix-klassen och använda dess HDF5Matrix-funktion i skriptet.

To_categorical() Funktion

Denna funktion låter dig modifiera en klassvektor till en matris, dvs binär klassmatris. Låt oss säga att vi har importerat funktionen to_categorical() från utils-modulen och initierat en vektor 'A'. Vektorn 'A' har skickats till to_categorical()-funktionen. Den binära matrisen för denna klassvektor 'A' har visats.

print_summary() Funktion

För att skriva ut sammanfattningen av en modell som vi har kastat ut i vår miljö användes funktionen print_summary.

plot_model() Funktion

Funktionen plot_model() betecknar modellen i ett punktformat och låter dig spara den i ett dokument.

Slutsats

För att sammanfatta kan vi säga att Python-språket är ett nödvändigt språk för dagens era eftersom allt går snabbt och tekniken har utvecklats så galet snabbt. Under hela denna inlärningsriktlinje har vi varit uppe i användningen av Pythons Keras-bibliotek i djupinlärning och artificiella neurala nätverk. För detta har vi också gått igenom vikten och användningen av dess backend-bibliotek 'TensorFlow' för att få en tydlig förståelse. Dessutom har vi diskuterat och förklarat alla konfigurationer som krävs för att ställa in Keras och Anaconda-miljön i Python inom operativsystemet Ubuntu 20.04 Linux. Efter detta har vi noggrant diskuterat Keras-modellerna, -skikten och -modulerna en efter en tillsammans med deras mest använda funktioner. För demonstration av Function API-modellen, se efter den officiella dokumentationen.