Phenquestions
Samlet sett vil vi dekke tre hovedtemaer i denne leksjonen:
- Hva er Tensors og TensorFlow
- Bruk av ML-algoritmer med TensorFlow
- TensorFlow brukstilfeller
TensorFlow er en utmerket Python-pakke fra Google som bruker god dataflytprogrammeringsparadigme for svært optimaliserte matematiske beregninger. Noen av funksjonene til TensorFlow er:
- Distribuert beregningsevne som gjør administrering av data i store sett lettere
- Dyp læring og nevralt nettverksstøtte er bra
- Den styrer komplekse matematiske strukturer som n-dimensjonale matriser veldig effektivt
På grunn av alle disse funksjonene og rekkevidden av maskinlæringsalgoritmer gjør TensorFlow det til et bibliotek for produksjonsskala. La oss dykke ned i konsepter i TensorFlow slik at vi kan gjøre hendene skitne med kode rett etterpå.
Installere TensorFlow
Da vi skal bruke Python API for TensorFlow, er det godt å vite at det fungerer med begge Python 2.7 og 3.3+ versjoner. La oss installere TensorFlow-biblioteket før vi går til de faktiske eksemplene og konseptene. Det er to måter å installere denne pakken på. Den første inkluderer bruk av Python pakkebehandling, pip:
pip installere tensorflowDen andre måten gjelder Anaconda, vi kan installere pakken som:
conda install -c conda-forge tensorflowSe gjerne etter nattlige bygg og GPU-versjoner på de offisielle TensorFlow-installasjonssidene.
Jeg vil bruke Anaconda-sjefen for alle eksemplene i denne leksjonen. Jeg vil lansere en Jupyter Notebook for det samme:
Nå som vi er klare med alle importuttalelser for å skrive litt kode, la oss begynne å dykke ned i SciPy-pakken med noen praktiske eksempler.
Hva er tensorer?
Tensorer er de grunnleggende datastrukturene som brukes i Tensorflow. Ja, de er bare en måte å representere data i dyp læring. La oss visualisere dem her:
Som beskrevet på bildet, tensorer kan betegnes som n-dimensjonalt array som lar oss representere data i komplekse dimensjoner. Vi kan tenke på hver dimensjon som et annet trekk ved data i dyp læring. Dette betyr at Tensorer kan vokse ut til å bli ganske komplekse når det gjelder komplekse datasett med mange funksjoner.
Når vi vet hva Tensorer er, tror jeg det er ganske enkelt å utlede hva som skjer i TensorFlow. Disse begrepene betyr hvordan tensorer eller funksjoner kan strømme i datasett for å produsere verdifull effekt når vi utfører forskjellige operasjoner på den.
Forstå TensorFlow med konstanter
Akkurat som vi leser ovenfor, tillater TensorFlow oss å utføre maskinlæringsalgoritmer på Tensors for å produsere verdifull produksjon. Med TensorFlow er design og trening av Deep Learning-modeller rett frem.
TensorFlow kommer med bygningen Beregningsdiagrammer. Beregningsdiagrammer er dataflytgrafene der matematiske operasjoner er representert som noder og data er representert som kanter mellom disse nodene. La oss skrive en veldig enkel kodebit for å gi en konkret visualisering:
importer tensorflow som tfx = tf.konstant (5)
y = tf.konstant (6)
z = x * y
skriv ut (z)
Når vi kjører dette eksemplet, ser vi følgende utdata:
Hvorfor er mangedoblingen feil? Det var ikke det vi forventet. Dette skjedde fordi dette ikke er hvordan vi kan utføre operasjoner med TensorFlow. Først må vi starte en økt for å få beregningsgrafen til å fungere,
Med Sessions kan vi innkapslet kontrollen av operasjoner og tilstanden til Tensorer. Dette betyr at en økt også kan lagre resultatet av en beregningsgraf, slik at den kan overføre resultatet til neste operasjon i rekkefølgen for utførelsen av rørledningene. La oss lage en økt nå for å få riktig resultat:
# Start med øktobjektetøkt = tf.Økt()
# Gi beregningen til økten og lagre den
resultat = økt.løp (z)
# Skriv ut resultatet av beregningen
skriv ut (resultat)
# Lukk økt
økt.Lukk()
Denne gangen fikk vi økten og ga den beregningen den trenger for å kjøre på nodene. Når vi kjører dette eksemplet, ser vi følgende utdata:
Selv om vi mottok en advarsel fra TensorFlow, fikk vi fortsatt riktig utdata fra beregningen.
Single-element Tensor Operations
Akkurat som det vi multipliserte to konstante tensorer i det siste eksemplet, har vi mange andre operasjoner i TensorFlow som kan utføres på enkeltelementer:
- legge til
- trekke fra
- multiplisere
- div
- mod
- abs
- negativ
- skilt
- torget
- rund
- sqrt
- pow
- eksp
- Logg
- maksimum
- minimum
- cos
- synd
Enkeltelementoperasjoner betyr at selv når du gir en matrise, vil operasjonene bli utført på hvert av elementene i den matrisen. For eksempel:
importer tensorflow som tfimporter nummen som np
tensor = np.matrise ([2, 5, 8])
tensor = tf.convert_to_tensor (tensor, dtype = tf.float64)
med tf.Økt () som økt:
skriv ut (økt.kjøre (tf.cos (tensor)))
Når vi kjører dette eksemplet, ser vi følgende utdata:
Vi forsto to viktige begreper her:
- Enhver NumPy-matrise kan enkelt konverteres til en Tensor ved hjelp av convert_to_tensor-funksjonen
- Operasjonen ble utført på hvert av NumPy-arrayelementene
Plassholdere og variabler
I en av forrige seksjoner så vi på hvordan vi kan bruke Tensorflow-konstanter til å lage beregningsdiagrammer. Men TensorFlow lar oss også ta innspill på løp slik at beregningsgrafen kan være dynamisk. Dette er mulig ved hjelp av plassholdere og variabler.
Faktisk inneholder ikke plassholdere noen data og må gis gyldige innganger i løpet av kjøretiden, og som forventet, uten inndata, vil de generere en feil.
En plassholder kan betegnes som en avtale i en graf om at en innspill sikkert vil bli gitt ved kjøretid. Her er et eksempel på plassholdere:
importer tensorflow som tf# To plassholdere
x = tf. plassholder (tf.float32)
y = tf. plassholder (tf.float32)
# Tilordne multiplikasjonsoperasjon w.r.t. en & b til node mul
z = x * y
# Opprett en økt
økt = tf.Økt()
# Pass verdier for plassholdere
resultat = økt.kjør (z, x: [2, 5], y: [3, 7])
skriv ut ('Multiplikere x og y:', resultat)
Når vi kjører dette eksemplet, ser vi følgende utdata:
Nå som vi har kunnskap om plassholdere, la oss rette blikket mot variabler. Vi vet at utgangen fra en ligning kan endres for samme sett med innganger over tid. Så når vi trener modellvariabelen vår, kan den endre oppførselen over tid. I dette scenariet tillater en variabel oss å legge til disse treningsparametrene i beregningsgrafen vår. En variabel kan defineres som følger:
x = tf.Variabel ([5.2], dtype = tf.float32)I ovenstående ligning er x en variabel som får sin opprinnelige verdi og datatypen. Hvis vi ikke oppgir datatypen, vil den utlede av TensorFlow med sin opprinnelige verdi. Se datatypene til TensorFlow her.
I motsetning til en konstant, må vi ringe en Python-funksjon for å initialisere alle variablene i en graf:
init = tf.global_variables_initializer ()økt.kjøre (init)
Sørg for å kjøre ovennevnte TensorFlow-funksjon før vi bruker grafen vår.
Lineær regresjon med TensorFlow
Lineær regresjon er en av de vanligste algoritmene som brukes til å etablere et forhold i en gitt kontinuerlig data. Dette forholdet mellom koordinatpunktene, si x og y, kalles a hypotese. Når vi snakker om lineær regresjon, er hypotesen en rett linje:
y = mx + cHer er m linjens skråning, og her er det en vektor som representerer vekter. c er konstant koeffisient (y-skjæringspunkt) og her representerer den Partiskhet. Vekten og skjevheten kalles parametere for modellen.
Lineære regresjoner gjør at vi kan estimere verdiene for vekt og skjevhet slik at vi har et minimum kostnadsfunksjon. Til slutt er x den uavhengige variabelen i ligningen, og y er den avhengige variabelen. La oss nå begynne å bygge den lineære modellen i TensorFlow med en enkel kodebit som vi vil forklare:
importer tensorflow som tf# Variabler for parameterhelling (W) med startverdi som 1.1
W = tf.Variabel ([1.1], tf.float32)
# Variabel for skjevhet (b) med startverdi som -1.1
b = tf.Variabel ([- 1.1], tf.float32)
# Plassholdere for å levere input eller uavhengig variabel, betegnet med x
x = tf.plassholder (tf.float32)
# Ligning av linje eller lineær regresjon
lineær_modell = W * x + b
# Initialisere alle variablene
økt = tf.Økt()
init = tf.global_variables_initializer ()
økt.kjøre (init)
# Utfør regresjonsmodell
skriv ut (økt.kjør (lineær_modell x: [2, 5, 7, 9]))
Her gjorde vi akkurat det vi forklarte tidligere, la oss oppsummere her:
- Vi startet med å importere TensorFlow til skriptet vårt
- Lag noen variabler for å representere vekta for vekt og parameterskjevhet
- En plassholder vil være nødvendig for å representere innspillene, x
- Representere den lineære modellen
- Initialiser alle verdiene som trengs for modellen
Når vi kjører dette eksemplet, ser vi følgende utdata:
Den enkle kodebiten gir bare en grunnleggende ide om hvordan vi kan bygge en regresjonsmodell. Men vi må fremdeles gjøre noen flere trinn for å fullføre modellen vi bygde:
- Vi må gjøre modellen vår selvutdannelig, slik at den kan produsere utdata for alle innganger
- Vi må validere utdataene som leveres av modellen ved å sammenligne den med forventet utgang for gitt x
Tapfunksjon og modellvalidering
For å validere modellen, må vi ha et mål på hvor avvikende strømutgang er fra forventet utgang. Det er forskjellige tapsfunksjoner som kan brukes her for validering, men vi vil se på en av de vanligste metodene, Summen av kvadratfeil eller SSE.
Ligningen for SSE er gitt som:
E = 1/2 * (t - y) 2Her:
- E = Gjennomsnittlig kvadratfeil
- t = Mottatt utgang
- y = forventet utgang
- t - y = Feil
La oss nå skrive et kodebit i forlengelse av det siste utdraget for å gjenspeile tapsverdien:
y = tf.plassholder (tf.float32)feil = lineær_modell - y
squared_errors = tf.kvadrat (feil)
tap = tf.reduser_sum (kvadratfeil)
skriv ut (økt.kjøre (tap, x: [2, 5, 7, 9], y: [2, 4, 6, 8]))
Når vi kjører dette eksemplet, ser vi følgende utdata:
Det er klart at tapsverdien er veldig lav for den gitte lineære regresjonsmodellen.
Konklusjon
I denne leksjonen så vi på en av de mest populære Deep learning and Machine learning-pakken, TensorFlow. Vi laget også en lineær regresjonsmodell som hadde veldig høy nøyaktighet.
