Wie man Bilder mit Tensorflow einliest

Hallo Steemians,

die letzte Zeit liest man immer wieder mal etwas Maschinellen Lernen, Künstliche Intelligenz (K.I.) usw. Naja das Them K.I. hat mich, privat so wie beruflich, schon sehr lange im Griff. Ich glaube auch nicht das ich davon so schnell wieder wegkommen werde.

Ich bin mir nicht mehr sicher wann doch ich glaube letzte oder vorletze Jahr hat Google Tensorflow auf dem Markt gebracht. Mittlerweile ist Tensorflow in der Version 1.x.x. Als ich angefangen habe mit Tensorflow rum zu spielen war ich ziemlich schnell demotiviert weil ich es einfach nicht hin bekommen habe meine eigene Trainingsbilder zu laden um damit mein Neuronales Netz zu trainieren. Vor allem auch weil hier und da mal etwas geschrieben stand was so nicht funktionierte. Mittlerweile habe ich schon paar Methoden gesehen mit denen es sehr gut klappt.
In meinem heutigen und ersten Post über Maschinelles Lernen und Tensorflow (ja ich spiele mit dem Gedanken noch mehr in der Richtung zu bringen) möchte ich euch zeigen wie Ihr mittels Tensorflow Bilder aus eine Verzeichnis laden könnt um diese dann später in der Training-Phase benutzen zu können.
Dafür braucht ihr Bilder, Tensorflow selbst und Python. Wie ihr Tensorflow installiert erfahrt ihr hier:
Eine IDE wäre auch nicht verkehrt aber das ist ja Standard. Ich persönlich bevorzuge die IDE PyCharm die könnt ihr euch einfach und kostenlos runter Laden und installieren.

Erstellt euch zuerst ein Python File das ist einfach eine Datei mit der Endung .py.

Zuerst brauchen wir einige import's:

import os
import tensorflow as tf
import numpy as np

IMG_WIDTH = 150
IMG_HIGHT = 150

Die erste Methode/Funktion die man zuerst braucht sieht fol­gen­der­ma­ßen aus:

def read_images_from_disk(dir_path):
    '''reading images from disk
    Parameter:
        dir_path: path to images directory
    Returns:
        images: list with images as nd.array'''
    path, dirs, files = os.walk(dir_path).next()
    file_count = len(files)
    filename_queue = tf.train.string_input_producer(tf.train.match_filenames_once(dir_path + "/*.jpg"), shuffle=False)
    reader = tf.WholeFileReader()
    key, value = reader.read(filename_queue)

    # hier werden die Bilder geladen
    image = tf.image.decode_jpeg(value, channels=1)
    # so ändert man diegröße des Bildes
    # die größe habe wir oben mit
    # IMG_WIDTH, IMG_HIGHT = 150 definiert
    image = tf.image.resize_images(image, [IMG_WIDTH, IMG_HIGHT], method=1)
    # und so standardiziert man bilder
    image = tf.image.per_image_standardization(image)

    images = []
    init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
    # hier passiert der Hauptteil
    # in Tensorflow wird alles in einer Session abgearbeitet
    with tf.Session() as read_images_sess:
        read_images_sess.run(init_op)

        # Start populating the filename queue.
        read_images_coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=read_images_sess, coord=read_images_coord)

        for i in range(file_count):
            # bild auslesen
            eval_image = image.eval()
            # bild als numpy array in die Liste hinzufügen
            # weil Tensorflow die Bilder als numpy array braucht
            images.append(np.asarray(eval_image))

        # diese Zeilen werden benötigt
        # um sauber das auslesen zu beenden
        read_images_coord.request_stop()
        read_images_coord.join(threads)
        read_images_sess.close()

    # gibt die Bilder in einer Liste
    # als numpy array zurück
    return images

Es ist üblich die Bilder dem Neuronalen Netz nicht alle auf einmal zu übergeben sondern "häpchen weise" . Dazu erstellen wir wieder eine Methode/Funktion :

def get_next_batch(images_seq, batch_size):
    '''chunker for getting images as batches
    Parameter:
        image_seq: images as list
        batch_size: how much images to chunk out (batch_size)
    Returns:
        images as seq with given batch_size'''
    return (images_seq[pos:pos + batch_size] for pos in xrange(0, len(images_seq), batch_size))

So das war es auch schon mit den Hauptteil der Arbeit. Kommen wir zu anwenden der Methoden.
Um jetzt die Bilder zu laden ruft ihr einfach die Methode/Funktion von oben auf.

# train_dir sollte den Pfad zu euren Bilder enthalten
 train_images = read_images_from_disk(train_dir)

Und so werden die Bilder an das Neuronale Netz zum trainieren übergeben.

train_sess = tf.Session()
train_sess.run(tf.global_variables_initializer())

for epoch_i in range(n_epochs):
             # hier ruft die andere Funktion auf um die Bilder batch wise zu laden, also in häpchen
             # ein guter start punkt ist batch_size=32 zu setzen
             for train_batch in get_next_batch(train_images, batch_size):
                    # diese zeile ist nur als beispiel gedacht muss natürlich auf euer Model
                    # zugeschnitten werden. Ich nutze hier einen Autoencoder, 
                    # daher werden keine Labels (target)  benötigt
                    train_step = train_sess.run([optimizer],feed_dict={ae['x']: train_batch})        

Sodas war es schon mit meinem Post zu Maschinellen Lernen und Tensorflow.
Ich hoffe es hat euch gefallen.

Hinter lasst mir bitte ein Feedback. War der Beitrag zu technisch oder nicht technisch genug? Würdet ihr noch mehr von solchen Beiträgen sehen.

Danke für's lesen.
Einen schönen Tag noch

Alex