Phenquestions
Összességében három fő témát fogunk bemutatni ebben a leckében:
- Mi a Tensors és a TensorFlow
- ML algoritmusok alkalmazása a TensorFlow segítségével
- TensorFlow használati esetek
A TensorFlow a Google kiváló Python-csomagja, amely jól kihasználja az adatfolyam-programozási paradigmát a nagyon optimalizált matematikai számításokhoz. A TensorFlow néhány jellemzője:
- Elosztott számítási képesség, amely megkönnyíti az adatok nagy halmazokban történő kezelését
- A mély tanulás és a neurális hálózat támogatása jó
- Nagyon hatékonyan kezeli az olyan bonyolult matematikai struktúrákat, mint az n-dimenziós tömbök
Mindezen tulajdonságok és a gépi tanulási algoritmusok köre miatt a TensorFlow megvalósítási léptékű könyvtárgá teszi. Merüljünk el a TensorFlow fogalmaiban, hogy rögtön utána bepiszkolhassuk a kezünket a kóddal.
A TensorFlow telepítése
Mivel a Python API-t fogjuk használni a TensorFlow számára, jó tudni, hogy mindkét Python 2-vel működik.7. és 3. ábra.3+ verziók. Telepítsük a TensorFlow könyvtárat, mielőtt áttérnénk a tényleges példákra és koncepciókra. A csomag telepítésének két módja van. Az első a Python csomagkezelő, pip használatát tartalmazza:
pip install tensorflowA második út az Anacondához kapcsolódik, a csomagot a következőképpen telepíthetjük:
conda install -c conda-forge tensorflowNyugodtan keressen éjszakai buildeket és GPU verziókat a TensorFlow hivatalos telepítési oldalain.
Az Anaconda menedzsert fogom használni a lecke összes példájához. Elindítok egy Jupyter Notebookot ugyanerre:
Most, hogy készen állunk az összes importálási utasítással egy kód beírására, kezdjünk el merülni a SciPy csomagban néhány gyakorlati példával.
Mik azok a tenzorok?
A tenzorok a Tensorflow-ban használt alapvető adatstruktúrák. Igen, ezek csak az adatok reprezentációs módjai a mély tanulásban. Vizualizáljuk őket itt:
A képen leírtak szerint, a tenzorokat n-dimenziós tömbnek nevezhetjük amely lehetővé teszi az adatok komplex dimenziókban való ábrázolását. Gondolhatunk az egyes dimenziókra, mint az adatok különböző jellemzőire a mély tanulás során. Ez azt jelenti, hogy a Tensors meglehetősen összetetté válhat, ha sok funkcióval rendelkező komplex adatkészletekről van szó.
Miután megtudtuk, hogy mik a Tensors, azt hiszem, nagyon könnyű levezetni, mi történik a TensorFlow-ban. Ez a kifejezés azt jelenti, hogy a tenzorok vagy a funkciók hogyan áramolhatnak az adatkészletekben, hogy értékes kimenetet hozzanak létre, amikor különféle műveleteket hajtunk végre rajta.
A TensorFlow megértése konstansokkal
Ahogy a fentiekben olvashattuk, a TensorFlow lehetővé teszi számunkra, hogy gépi tanulási algoritmusokat hajtsunk végre a Tensorokon, hogy értékes kimenetet kapjunk. A TensorFlow segítségével a Deep Learning modellek megtervezése és oktatása egyenesen halad.
A TensorFlow építkezéssel érkezik Számítási grafikonok. A Számítási grafikonok azok az adatfolyam-grafikonok, amelyekben a matematikai műveletek csomópontként, az adatok pedig élként jelennek meg a csomópontok között. Írjunk egy nagyon egyszerű kódrészletet a konkrét megjelenítés érdekében:
import tensorflow mint tfx = tf.állandó (5)
y = tf.állandó (6)
z = x * y
nyomtatás (z)
Amikor futtatjuk ezt a példát, a következő kimenetet látjuk:
Miért rossz a szorzás?? Nem erre számítottunk. Ez azért történt, mert a TensorFlow segítségével nem így tudjuk végrehajtani a műveleteket. Először el kell kezdenünk a ülés hogy a számítási gráf működjön,
A Sessions segítségével megtehetjük beágyazódik a tenzorok működésének és állapotának ellenőrzése. Ez azt jelenti, hogy egy munkamenet egy számítási grafikon eredményét is tárolhatja, hogy ezt az eredményt a csővezetékek végrehajtásának sorrendjében át tudja adni a következő műveletnek. Hozzunk létre most egy munkamenetet a helyes eredmény eléréséhez:
# Kezdje a session objektummalmunkamenet = tf.Ülés()
# Adja meg a munkamenet kiszámítását és tárolja
eredmény = munkamenet.futás (z)
# Nyomtassa ki a számítás eredményét
nyomtatás (eredmény)
# Bezárás
ülés.Bezárás()
Ezúttal megszereztük a munkamenetet, és megadtuk neki a csomópontokon történő futtatáshoz szükséges számítást. Amikor futtatjuk ezt a példát, a következő kimenetet látjuk:
Noha kaptunk egy figyelmeztetést a TensorFlow-tól, a számításból mégis a megfelelő kimenetet kaptuk.
Egyelemes tenzorműveletek
Csakúgy, mint amit az utolsó példában két állandó tenzort szoroztunk, a TensorFlow-ban sok más műveletet is elvégezhetünk, amelyeket egyetlen elemen lehet végrehajtani:
- hozzá
- kivonni
- szaporodnak
- div
- mod
- abs
- negatív
- jel
- négyzet
- kerek
- sqrt
- hadifogoly
- exp
- napló
- maximális
- minimális
- kötözősaláta
- bűn
Az egyelemes műveletek azt jelentik, hogy akkor is, ha megad egy tömböt, a műveleteket a tömb mindegyik elemén végzik. Például:
import tensorflow mint tfimportálja a numpy-t np-ként
tenzor = np.tömb ([2, 5, 8])
tenzor = tf.convert_to_tensor (tenzor, dtype = tf.float64)
tf-vel.Munkamenet () munkamenetként:
nyomtatás (session.futás (tf.cos (tenzor)))
Amikor futtatjuk ezt a példát, a következő kimenetet látjuk:
Itt két fontos fogalmat értettünk meg:
- Bármely NumPy tömb könnyen átalakítható Tensorrá a convert_to_tensor függvény segítségével
- A műveletet a NumPy tömbelemek mindegyikén elvégezték
Helyőrzők és változók
Az előző szakaszok egyikében megvizsgáltuk, hogyan használhatjuk a Tensorflow állandókat számítási grafikonok készítéséhez. De a TensorFlow azt is lehetővé teszi számunkra, hogy menet közben bemeneteket vegyünk, hogy a számítási grafikon dinamikus jellegű lehessen. Ez a Helyőrzők és a Változók segítségével lehetséges.
Valójában a helyőrzők nem tartalmaznak adatokat, és érvényes bemeneteket kell megadniuk futás közben, és ahogy az várható volt, bemenet nélkül hibát generálnak.
A Placeholder egy grafikonban megállapodásnak nevezhető, amely szerint futás közben biztosan megadják az inputot. Íme egy példa a helyőrzőkre:
import tensorflow mint tf# Két helyőrző
x = tf. helyőrző (tf.úszó32)
y = tf. helyőrző (tf.úszó32)
# Szorzási művelet hozzárendelése w.r.t. a & b csomópont mul
z = x * y
# Hozzon létre egy munkamenetet
munkamenet = tf.Ülés()
# A helyjelzők értékeinek átadása
eredmény = munkamenet.futás (z, x: [2, 5], y: [3, 7])
nyomtatás ('x és y szorzása:', eredmény)
Amikor futtatjuk ezt a példát, a következő kimenetet látjuk:
Most, hogy tudtunk a helyőrzőkről, fordítsuk a tekintetünket a Változók felé. Tudjuk, hogy az egyenlet kimenete ugyanazon a bemeneti halmazon változhat az idő múlásával. Tehát, amikor a modellváltozónkat betanítjuk, az idővel megváltoztathatja viselkedését. Ebben a forgatókönyvben egy változó lehetővé teszi számunkra, hogy ezeket a képezhető paramétereket hozzáadjuk a számítási grafikonunkhoz. A változó a következőképpen határozható meg:
x = tf.Változó ([5.2], dtype = tf.úszó32)A fenti egyenletben x olyan változó, amely megadja kezdeti értékét és adattípusát. Ha nem adjuk meg az adattípust, akkor azt a TensorFlow a kezdeti értékével kikövetkezteti. Lásd itt a TensorFlow adattípusokat.
Az állandótól eltérően meg kell hívnunk egy Python függvényt a gráf összes változójának inicializálásához:
init = tf.global_variables_initializer ()ülés.futtatás (init)
Feltétlenül futtassa a fenti TensorFlow függvényt, mielőtt felhasználnánk a grafikonunkat.
Lineáris regresszió a TensorFlow segítségével
A lineáris regresszió az egyik leggyakoribb algoritmus, amelyet egy adott folyamatos adat összefüggésének létrehozására használnak. Ezt a kapcsolatot a koordinátapontok, mondjuk x és y között a-nak nevezzük hipotézis. Amikor a lineáris regresszióról beszélünk, a hipotézis egyenes vonal:
y = mx + cItt m az egyenes meredeksége, itt pedig egy vektor, amely reprezentálja súlyok. c az állandó együttható (y-metszés), és itt az Elfogultság. A súlyt és az elfogultságot nevezzük a modell paraméterei.
A lineáris regressziók lehetővé teszik számunkra a súly és az elfogultság értékeinek megbecsülését úgy, hogy a minimumunk meg legyen költségfüggvény. Végül az x az egyenlet független változója, az y pedig a függő változó. Most kezdjük el felépíteni a lineáris modellt a TensorFlow-ban egy egyszerű kódrészlettel, amelyet elmagyarázunk:
import tensorflow mint tf# A paraméter meredekségének (W) változói 1 kezdőértékkel.1
W = tf.Változó ([1.1], tf.úszó32)
# Az (b) elfogultságra változó, kezdeti értéke -1.1
b = tf.Változó ([- 1.1], tf.úszó32)
# Helyjelzők bemenettel vagy független változóval, x-szel jelölve
x = tf.helyőrző (tf.úszó32)
# Vonalegyenlet vagy a lineáris regresszió
lineáris_modell = W * x + b
# Az összes változó inicializálása
munkamenet = tf.Ülés()
init = tf.global_variables_initializer ()
ülés.futtatás (init)
# Regressziós modell végrehajtása
nyomtatás (session.futtatás (linear_model x: [2, 5, 7, 9]))
Itt csak azt tettük, amit korábban kifejtettünk, itt foglaljuk össze:
- Azzal kezdtük, hogy a TensorFlow-t importáltuk a szkriptünkbe
- Hozzon létre néhány változót a vektor súlyának és a paraméterek elfogultságának ábrázolásához
- Helyőrzőre lesz szükség az x bemenet képviseletéhez
- Ábrázolja a lineáris modellt
- Inicializálja a modellhez szükséges összes értéket
Amikor futtatjuk ezt a példát, a következő kimenetet látjuk:
Az egyszerű kódrészlet csak egy alapötletet ad arról, hogyan építhetünk regressziós modellt. De még mindig meg kell tennünk néhány lépést az általunk gyártott modell befejezéséhez:
- Modellünket önképezhetővé kell tenni, hogy az bármely bemenethez kimenetet tudjon produkálni
- Ellenőriznünk kell a modell által nyújtott kimenetet, összehasonlítva azt az adott x várható kimenetével
A veszteség funkciója és a modell érvényesítése
A modell érvényesítéséhez meg kell mérnünk, hogy az áram kimenete mennyire tér el a várható kimenettől. Különféle veszteségfüggvények használhatók itt az érvényesítéshez, de megnézzük az egyik leggyakoribb módszert, A négyzetes hiba vagy az SSE összege.
Az SSE egyenlete a következő:
E = 1/2 * (t - y) 2Itt:
- E = átlagos négyzet hiba
- t = fogadott kimenet
- y = Várható kimenet
- t - y = Hiba
Most írjunk egy kódrészletet az utolsó részlethez, hogy tükrözze a veszteség értékét:
y = tf.helyőrző (tf.úszó32)hiba = lineáris_modell - y
négyzet_hibák = tf.négyzet (hiba)
veszteség = tf.reduc_sum (négyzet_hibák)
nyomtatás (session.futás (veszteség, x: [2, 5, 7, 9], y: [2, 4, 6, 8])
Amikor futtatjuk ezt a példát, a következő kimenetet látjuk:
Nyilvánvaló, hogy a veszteség értéke nagyon alacsony az adott lineáris regressziós modellnél.
Következtetés
Ebben a leckében megnéztük az egyik legnépszerűbb mély tanulási és gépi tanulási csomagot, a TensorFlow-t. Készítettünk egy lineáris regressziós modellt is, amelynek nagyon nagy pontossága volt.
