Formattering af data til TensorFlow
Del 1 af denne blogserie demonstrerede fordelene ved at bruge en relationel database til at gemme og udføre dataudforskning af billeder ved hjælp af simple SQL-sætninger. I denne vejledning, del 2, vil de data, der blev brugt i del et, blive tilgået fra en MariaDB Server-database og konverteret til de datastrukturer, som TensorFlow har brug for. Resultaterne af at anvende modellen til at klassificere nye billeder vil blive gemt i en relationstabel til yderligere analyse.
Dette er en hurtig vejledning i et TensorFlow-program med detaljerne beskrevet, mens vi går. Hvis du ikke er bekendt med de grundlæggende begreber, er et godt sted at starte denne TensorFlow-tutorial, "Grundlæggende klassifikation:Klassificer billeder af tøj". Nogle af eksemplerne og koden i selvstudiet bruges her.
Der er behov for yderligere pakker
Nogle ekstra pakker er nødvendige for at bygge og træne billedklassificeringsmodellen:
- Sylteagurk implementerer binære protokoller til serialisering og de-serialisering af en Python-objektstruktur.
- NumPy giver understøttelse af store, multidimensionelle arrays og matricer sammen med matematiske funktioner på højt niveau til at fungere på disse arrays.
- TensorFlow er et Python-bibliotek til hurtig numerisk beregning. Det er et fundamentbibliotek, der kan bruges til at skabe Deep Learning-modeller direkte eller ved at bruge wrapper-biblioteker, der forenkler processen bygget oven på TensorFlow.
- Keras er et open source neuralt netværksbibliotek skrevet i Python.
import pickleimport numpy som npimport tensorflow som tffrom tensorflow import kerasprint('Tensorflow version:', tf.__version__)print('Numpy version:', np.__version__)Tensorflow version:2.0.0Numpy version:1.16.2 Hent billeder
Når pakkerne er blevet importeret, er næste trin at hente træningsbillederne fra databasen og opdele dataene i to numpy arrays. Først skal vi initialisere træningsbillederne (train_images) og træningsetiketter (train_labels) arrays. Da vi allerede har vektoriseret billederne, kan vi bruge img_vector-attributten til at udfylde train_images-arrayet med SQL-sætningen nedenfor.
# Initialiser de numpy arraystrain_images =np.empty((60000,28,28), dtype='uint8')train_labels =np.empty((60000), dtype='uint8')# Hent træningsbillederne fra databasesql="SELECT img_label, img_vector, img_idx \FROM tf_images INNER JOIN img_use ON img_use =use_id \WHERE use_name ='Training'"cur.execute(sql)result =cur.fetchall()# Udfyld de talrige arrays. række[2] indeholder billedindekset for række i result:nparray =pickle.loads(row[1])train_images[row[2]] =nparraytrain_labels[row[2]] =række[0]
På lignende måde kan billederne til test hentes fra databasen. Den numpy arrays brugt i dette tilfælde er test_images og test_labels. I dette tilfælde er testdataene 10.000 billeder ved 28×28 pixel opløsning.
# Initialiser de numpy arraystest_images =np.empty((10000,28,28), dtype='uint8')test_labels =np.empty((10000), dtype='uint8')# Hent testbillederne fra databasesql="SELECT img_label, img_vector, img_idx \FROM tf_images INNER JOIN img_use ON img_use =use_id \WHERE use_name ='Testing'"cur.execute(sql)result =cur.fetchall()# Udfyld de talrige arrays. række[2] indeholder billedindekset for række i result:nparray =pickle.loads(row[1])test_images[row[2]] =nparraytest_labels[row[2]] =række[0]
Til sidst er hvert billede kortlagt til en enkelt etiket. Etiketnavnene gemmes i kategoritabellen og indlæses i arrayet klassenavne:
sql="SELECT class_name FROM categories"cur.execute(sql)class_names =cur.fetchall()
Forbehandle dataene
Dataene skal forbehandles inden træning af netværket. Hvis du inspicerer det første billede i træningssættet, vil du se, at pixelværdierne falder i området fra 0 til 255:
plt.figure()plt.imshow(train_images[0])plt.colorbar()plt.grid(False)plt.show()
ovenfor:billede fra fashion_mnist-datasæt
Før billederne føres til den neurale netværksmodel, skal værdierne skaleres til et område på 0 til 1. For at gøre det skal du dividere værdierne med 255. Det er vigtigt, at træningssættet og testsættet er forbehandlet på samme måde .
Du kan bruge matplotlib for at vise de første 25 billeder for at bekræfte, at dataene er i det korrekte format og klar til at opbygge og træne netværket:
train_images =train_images / 255.0test_images =test_images / 255.0plt.figure(figsize=(10,10))for i in range(25):plt.subplot(5,5,i+1)plt.xticks([ ])plt.yticks([])plt.grid(False)plt.imshow(train_images[i], cmap=plt.cm.binary)plt.xlabel(class_names[train_labels[i]])plt.show()
ovenfor:billeder fra fashion_mnist-datasæt
Opbygning af modellen
Efter at dataene er blevet forbehandlet i to delmængder, kan du fortsætte med en modeltræning. Denne proces indebærer at "fodre" algoritmen med træningsdata. Algoritmen vil behandle dataene og udlæse en model, der er i stand til at finde en målværdi (attribut) i nye data - det vil sige klassificere det billede, der præsenteres for det neurale netværk.
De fleste deep learning neurale netværk er produceret ved at kæde simple lag sammen.
Det første lag i netværket transformerer billedformatet fra et todimensionelt array (på 28 gange 28 pixels) til et endimensionelt array (på 28 * 28 =784 pixels). Dette lag har ingen parametre at lære; den omformaterer kun dataene.
Efter at pixels er fladtrykt, består netværket af to fuldt forbundne lag, der skal aktiveres. I et neuralt netværk er aktiveringsfunktionen ansvarlig for at transformere det summerede vægtede input fra noden til aktiveringen af noden eller output for det input.
Det første tætte lag har 128 noder (eller neuroner) og bruger en Rectified Linear Unit (ReLU) aktiveringsmetode. Den ensrettede lineære aktiveringsfunktion er en stykkevis lineær funktion, der udsender input direkte, hvis det er positivt, ellers vil det udsende nul.
Det andet (og sidste) lag er et 10-node softmax-lag. En softmax-funktion udsender en vektor, der repræsenterer sandsynlighedsfordelingerne for en liste over potentielle udfald. Den returnerer en matrix med 10 sandsynlighedsscore, der summer til 1. Hver knude indeholder en score, der angiver sandsynligheden for, at det aktuelle billede tilhører en af de 10 klasser.
De fleste lag, såsom tf.keras.layers.Dense, har parametre, som læres under træning.
model =keras.Sequential([keras.layers.Flatten(input_shape=(28, 28)),keras.layers.Dense(128, activation='relu'),keras.layers.Dense(10, activation='softmax')])
Kompilering af modellen
Modelkompileringstrinnet bruges til at tilføje et par flere indstillinger, før det er klar til træning. I dette tilfælde er følgende indstillinger aktiveret.
- Optimering – Opdaterer modellen baseret på de data, den ser, og dens tabsfunktion (se nedenfor).
- Tabsfunktion – måler, hvor nøjagtig modellen er under træning. Du ønsker at minimere denne funktion for at "styre" modellen i den rigtige retning.
- Metrics – Overvåg trænings- og testtrinene. Følgende eksempel bruger nøjagtighed, den del af billederne, der er korrekt klassificeret.
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
Uddannelse af modellen
Træning af den neurale netværksmodel kræver følgende trin.
- Før træningsdataene til modellen.
- Modellen lærer at forbinde billeder og etiketter.
- Foretag forudsigelser om et testsæt.
- Bekræft, at forudsigelserne matcher etiketterne fra test_labels-arrayet.
For at starte træning skal du kalde model.fit-metoden – såkaldt fordi den "tilpasser" modellen til træningsdataene:
model.fit(train_images, train_labels, epoker=10) Træn på 60000 prøverEpoke 1/1060000/60000 [==============================] - 5s 83us/prøve - tab:0,4964 - nøjagtighed:0,8236Epoke 2/1060000/60000 [===============================] - 4s 65us/prøve - tab:0,3735 - nøjagtighed:0,8642Epoke 3/1060000/60000 [===============================] - 3s 55us/prøve - tab:0,3347 - nøjagtighed:0,8773Epoke 4/1060000/60000 [===============================] - 3s 56us/prøve - tab:0,3106 - nøjagtighed:0,8861Epoke 5/1060000/60000 [================================] - 3s 58us/sample - tab:0,2921 - nøjagtighed:0,8924s - tab:0,2928 - nøjagtighed - ETA:0s - tab:0,2925 - nøjagtighedEpoke 6/1060000/6000================================] - 3s 57us/prøve - tab:0,2796 - nøjagtighed:0,8969sEpoke 7/1060000/60000 [==============================] - 4s 70us/prøve - tab:0,2659 - nøjagtighed:0,9007Epoke 8/1060000/60000 [==============================] - 4s 61us/sample - tab:0,2548 - nøjagtighed:0,9042Epoke 9/1060000/60000 [ ===============================] - 4s 61us/prøve - tab:0,2449 - nøjagtighed:0,9084Epoke 10/1060000/60000 [==============================] - 5s 76us/sample - tab:0,2358 - nøjagtighed:0,9118
Ved slutningen af hver epoke evalueres det neurale netværk i forhold til valideringssættet. Dette er, hvad tab og nøjagtighed refererer til.
Evaluer nøjagtigheden og forudsig
For at estimere modellens overordnede nøjagtighed skal du beregne gennemsnittet af alle ti forekomster af nøjagtighedsværdien, i dette tilfælde 88 %.
Udfør derefter model.evaluate på testsættet for at få den forudsigende nøjagtighed af det trænede neurale netværk på tidligere usete data.
test_loss, test_acc =model.evaluate(test_images, test_labels, verbose=2)10000/1 - 0s - tab:0,2766 - nøjagtighed:0,8740
Testdatasættet er mindre nøjagtigt end træningsdatasættet. I dette tilfælde repræsenterer denne kløft mellem træningsnøjagtighed og testnøjagtighed overfitting. Det modsatte er underfitting. Hvis du vil lære mere om dette emne, anbefaler jeg Overfitting vs. Underfitting:A Conceptual Explanation af Will Koehrsen.
På dette tidspunkt kan vi komme med nogle forudsigelser om billederne i vores træningsdatasæt.
Outputtet af model.predict er en matrix af 10 tal med sandsynlighed for, at en instans tilhører hver klasse. Det er en god idé at fastholde resultaterne i MariaDB-databasen til yderligere analyse og rapportering. Nedenfor er et eksempel på, hvordan man itererer på forudsigelsesarrayet for at bygge en tupel og derefter indsætte den i forudsigelsesresultaterne tabel.
sql ="INSERT INTO prediction_results (img_idx, img_use, T_shirt_Top, Trouser, Pullover, Kjole, Frakke, Sandal, Skjorte, Sneaker, Taske, Ankel_boot, label)VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);"i =0for række i forudsigelser:insert_tuple =(str(i), str(2), str (række[0]), str(række[1]), str(række[2]), str(række[3]), str(række[4]), str(række[5]), str(række [6]), str(row[7]), str(row[8]), str(row[9]), str(test_labels[i]))cur.execute(sql, insert_tuple)conn.commit() i +=1
Endnu en gang kan en simpel SQL-sætning bruges til at bekræfte, at dataene er blevet indlæst.
sql ="VÆLG T_shirt_Top, Bukser, Pullover, Kjole, Frakke, Sandal, Skjorte, Sneaker, Taske, Ankle_boot, class_name som 'Test Label'FRA prediction_results JOIN kategorier PÅ label =class_idx WHERE img_idx =1"display( pd. read_sql(sql,conn) )
T_shirt_Top Bukse trøje Kjole Frakke Sandal skjorte Sneaker Taske Ankelstøvle Testetiket 0,00001 0,0 0,997912 0,0 0,001267 0,0 0,00081 0,0 0,0 0,0 trøje
Plotning af forudsigelser
Et par plottefunktioner til at vise forudsigelserne er defineret nedenfor (Graphing-funktioner).
Lad os hente et nyt billede fra testsættet og vise den neurale netklassifikation baseret på forudsigelsessandsynligheden.
sql ="SELECT img_idx, label FROM prediction_results WHERE img_idx =1"cur.execute(sql)result =cur.fetchone()plt.figure(figsize=(6,3))plt.subplot(1,2, 1)plot_image(result[0], forudsigelser[resultat[0]], test_labels, test_images)plt.subplot(1,2,2)plot_value_array(result[0], forudsigelser[resultat[0]], test_labels)plt. show()
ovenfor:billede fra fashion_mnist-datasæt
I dette tilfælde var modellen i stand til at klassificere billedet korrekt med 100 % nøjagtighed. Lad os derefter udføre en forespørgsel for at hente de første 15 billeder fra testsættet og klassificere dem.
sql ="SELECT img_idx, label FROM prediction_results LIMIT 15"num_rows =5num_cols =3plt.figure(figsize=(2*2*num_cols, 2*num_rows))cur.execute(sql)result =cur.fetchall() for række i resultat:plt.subplot(antal_rækker, 2*antal_kolonner, 2*række[0]+1)plot_image(række[0], forudsigelser[række[0]], test_etiketter, test_billeder)plt.subplot(antal_rækker, 2 *antal_cols, 2*row[0]+2)plot_value_array(row[0], forudsigelser[row[0]], test_labels)plt.tight_layout()plt.show()
ovenfor:billeder fra fashion_mnist-datasæt
Som du kan se, vil der være tilfælde, hvor modellen kan være forkert som vist i sidste række, venstre kolonne. I dette tilfælde blev en sneaker klassificeret som en sandal (i rød).
Oversigt
Selvom integration mellem TensorFlow og MariaDB Server er let, er fordelene ved denne integration betydelige:
- Brug af relationelle data inden for maskinlæring kan reducere implementeringskompleksiteten. Både dataforskere og dataingeniører kan bruge et fælles sprog til at udføre datastrid og udforskningsopgaver.
- Effektivitet opnået ved adgang til, opdatering, indsættelse, manipulation og ændring af data kan fremskynde time-to-market.
- Muligheden til at gemme resultaterne af modellen tilbage til databasen gør det muligt for slutbrugere og analytikere at udføre forespørgsler og rapporter ved hjælp af venlige rapporteringsværktøjer som Tableau.
MIT-licens
Fashion MNIST (fashion_mnist)-datasættet, der udnyttes af denne blog, er licenseret under MIT-licensen, Copyright © 2017 Zalando SE, https://tech.zalando.com
Kildekoden, der udnyttes af denne blog, er tilpasset fra "Basic classification:Classify images of clothing", som er licenseret under MIT-licensen, Copyright (c) 2017 François Chollet.
Tilladelse gives hermed gratis til enhver person, der anskaffer sig en kopi af denne software og tilknyttede dokumentationsfiler ("Softwaren") til at handle med Softwaren uden begrænsninger, herunder uden begrænsning rettighederne til at bruge, kopiere, ændre, flette , udgive, distribuere, underlicensere og/eller sælge kopier af softwaren og tillade personer, som softwaren er leveret til, at gøre det, på følgende betingelser:
Ovenstående copyright-meddelelse og denne tilladelsesmeddelelse skal være inkluderet i alle kopier eller væsentlige dele af softwaren.
SOFTWAREN LEVERES "SOM DEN ER", UDEN GARANTI AF NOGEN ART, UDTRYKKELIG ELLER UNDERFORSTÅET, HERUNDER MEN IKKE BEGRÆNSET TIL GARANTIERNE FOR SALGBARHED, EGNETHED TIL ET BESTEMT FORMÅL OG IKKE-KRÆNKELSE. UNDER INGEN OMSTÆNDIGHEDER KAN FORFATTERNE ELLER OPHAVSRETSHEDHEDERNE VÆRE ANSVARLIGE FOR NOGEN KRAV, SKADER ELLER ANDEN ANSVAR, HÆVENT I EN KONTRAKTHANDLING, TORT ELLER ANDEN MÅDE, OPSTÅET AF, UD AF ELLER I FORBINDELSE MED DEN ANDEN SOFTWAREN. SOFTWARE.
Referencer
Konverter eget billede til MNISTs billede
matplotlib:Billedvejledning
5 måder, hvorpå AI transformerer kundeoplevelsen
Digitalisering genopfinder forretningen
Hvad er billedklassificering?
Introduktion til Python Deep Learning Library TensorFlow
Tegnende funktioner
def plot_image(i, predictions_array, true_label, img):predictions_array, true_label, img =predictions_array, true_label[i], img[i]plt.grid(False)plt.xticks([])plt.yticks([ ])plt.imshow(img, cmap=plt.cm.binary)predicted_label =np.argmax(predictions_array)if predicted_label ==true_label:color ='blue'else:color ='red'plt.xlabel("{} { :2.0f}% ({})".format(klasse_navne[forudsagt_etiket],100*np.maks(forudsigelsesarray),klassenavne[sand_etiket]),farve=farve)def plot_værdimatrix(i, forudsigelsesarray, sand_etiket):forudsigelsesarray, sand_etiket =predictions_array, true_label[i]plt.grid(False)plt.xticks(range(10))plt.yticks([])thisplot =plt.bar(range(10), predictions_array, color="#777777")plt .ylim([0, 1])predicted_label =np.argmax(predictions_array)thisplot[predicted_label].set_color('red')thisplot[true_label].set_color('blue')