[PYTHON] Erstellen Sie mit PyLearn2 eine App zur falschen Unterstützung

Was in diesem Artikel einzuführen

• Erstellen Sie eine App zur falschen Unterstützung als Beispiel für das Spielen mit Deep Learning (RBM).
• Einfaches Lernen mit PyLearn2
• Erstellen Sie ein interaktives Streudiagramm mit Python-Code

Einführung

Als Anwendungsbeispiel für eine Aufgabe mit Deep Learning habe ich versucht, "eine falsche Support-Anwendung zu erstellen".

In einer bequemen Welt gibt es jetzt eine University Misscon Portal Site.

Es gibt viele Teilnehmer und es macht Spaß. Gleichzeitig wollte ich aber auch alle zusammen sehen. Ich wollte auch ähnliche Gesichter zusammenstellen. (Vielleicht ist es eine schlechte Idee, aber zumindest mag ich Miscon so)

Dieses Mal werden wir uns also die folgenden Ziele setzen

• Erstellen Sie ein interaktives Streudiagramm.
• Sehen Sie sich das Streudiagramm an und gelingen Sie, wenn ähnliche Gesichter erfasst werden
• Ich möchte Miscon unterstützen, daher ist es in Ordnung, wenn die Motivation zur Abstimmung hoch ist (wenn ich die Motivation persönlich kenne, reicht das aus).

Daher habe ich den folgenden Arbeitsablauf berücksichtigt.

1. Informieren Sie sich über Teilnehmer
2. Schneiden Sie nur den Gesichtsbildteil aus
3. Lernen Sie die Funktionen kennen, mit denen ähnliche Gesichter erfasst werden können
4. Räumliche Abbildung von Bilddaten unter Verwendung des erlernten Merkmalsvektors (auch Einbettung genannt)
5. In den dimensionalen Raum komprimieren
6. Erstellen Sie ein interaktives Streudiagramm

Ich werde das alles in Python machen.

Jedes kann mit der Python-Bibliothek erreicht werden.

Ich werde Teil 1 weglassen, weil ich normalerweise nur den Scraping-Code schreibe.

Die meisten Artikel verwenden Bibliotheken für maschinelles Lernen.

Wechseln wir zur Anaconda -Distribution, die in Bibliotheken für maschinelles Lernen stark vertreten ist. Referenzartikel

Wir werden auch in einer Umgebung mit MacOSX 10.10 / Python 2.7 fortfahren.

2. Schneiden Sie nur den Gesichtsbildteil aus

Alle Bilder, die erhalten werden können, zeigen nicht nur das Gesicht, sondern auch den ganzen Körper und die Landschaft im Hintergrund. Zum Beispiel Es sieht so aus

Dieses Mal besteht der Zweck darin, einander ein ähnliches Gesicht zu verleihen, sodass der gesamte Körper und der Hintergrund unnötige Informationen sind.

Daher schneide ich automatisch nur das Gesichtsteil aus.

Dieser Vorgang kann mit der Kombination von OpenCV + cv2 erreicht werden.

Installation

Sie können opencv mit conda installieren, einem Paketverwaltungstool von anaconda.

$ conda install -c https://conda.binstar.org/menpo opencv

Lassen Sie uns die Installation überprüfen

>>> import cv2
>>> cv2.__version__
'2.4.9.1'
>>> exit()

Wie benutzt man

Laden Sie zuerst das Bild

import cv2
image = cv2.imread(path_to_imagefile)

Gesichtsbereichsidentifikation

Nehmen Sie als Nächstes Einstellungen vor, um den Bereich zu bestimmen, in dem sich das Gesicht befindet. Ein maschinelles Lernmodell ist erforderlich, um den Gesichtsbereich zu bestimmen. openCV verfügt bereits über ein Modell zur Bestimmung des Gesichtsbereichs, das mit Funktionen namens __Cascade Features __ trainiert wurde.

Das Modell zur Beurteilung des Gesichtsbereichs wird als XML-Datei gespeichert. Geben Sie daher den Pfad an. Wenn Sie es nicht finden können, suchen Sie mit dem Befehl "find" nach "haarcascade_frontalface_alt.xml".

Geben Sie den Pfad als Konstante an.

CASCADE_PATH = "/Users/kensuke-mi/.pyenv/versions/anaconda-2.1.0/share/OpenCV/haarcascades/haarcascade_frontalface_alt.xml"

Graustufen Sie den Gesichtsbereich, bevor Sie ihn identifizieren. (Graustufen sind nicht erforderlich, um den Gesichtsbereich zu identifizieren. Dies ist eine Vorverarbeitung für das Lernen mit Deep NN.)

image_gray = cv2.cvtColor(image, cv2.cv.CV_BGR2GRAY)

Machen Sie außerdem die numerischen Werte der Bildmatrix einheitlich. Weitere Informationen finden Sie unter Handbuch.

image_gray = cv2.equalizeHist(image_gray)

Rufen Sie abschließend den Gesichtsbereichsrichter an, um den Bereich zu finden.

cascade = cv2.CascadeClassifier(CASCADE_PATH)
facerect = cascade.detectMultiScale(image_gray, scaleFactor=1.1, minNeighbors=3, minSize=(50, 50))

Die Flächenkoordinaten des Gesichtsbildes werden in "facerect" zurückgegeben.

Ich habe versucht, eine Reihe von Flüssen in eine Funktion zu verwandeln.

def detectFace(image):
    image_gray = cv2.cvtColor(image, cv2.cv.CV_BGR2GRAY)
    image_gray = cv2.equalizeHist(image_gray)

    cascade = cv2.CascadeClassifier(CASCADE_PATH)
    facerect = cascade.detectMultiScale(image_gray, scaleFactor=1.1, minNeighbors=3, minSize=(50, 50))

    return facerect

Bildausschnitt

Da der Bereich bereits bekannt ist, kann der Gesichtsteil einfach durch Ausschneiden des Bereichs aus dem "imaga" -Objekt extrahiert werden. Dies ist auch eine Funktion.

def extract_face(facerect_list, image, path_to_save):
    """Schneiden Sie das Gesichtsteil aus. Beachten Sie jedoch, dass ein Foto nur ein Gesicht enthält.
    :param facerect_list:
    :param image:
    :param path_to_save:
    :return:
    """
    assert os.path.exists(os.path.dirname(path_to_save))

    for rect in facerect_list:
        x = rect[0]
        y = rect[1]
        w = rect[2]
        h = rect[3]

        # img[y: y + h, x: x + w]
        cv2.imwrite(path_to_save, image[y:y+h, x:x+w])

        return image[y:y+h, x:x+w]

Bildgröße ändern

Vereinheitlicht die Größe des Bildes.

Dies dient dazu, mit DeepNN effizient zu lernen. Selbst wenn die Größen unterschiedlich sind, ist es möglich zu lernen, aber der Rechenaufwand ist groß, daher werden wir die Größen hier anordnen.

Setzen Sie das image-Objekt auf im, geben Sie die Größe nach der Größenänderung an und führen Sie die Größenänderung aus.

RESIZED_TUPLE = (100, 100)
resized_im = cv2.resize(im,size_tuple)

Den Ablauf finden Sie unter github.

3 Erfahren Sie, wie viele Funktionen ähnliche Gesichter erfassen können

RBM, eine Art Deep NN (Neural Network), wird verwendet. Dieser Artikel eignet sich hervorragend für das Funktionsprinzip von RBM, daher ist es gut, darauf zu verweisen.

Verwenden Sie zur Verwendung von RBM die Bibliothek "Pylearn2". Wenn es um Deep Learning geht, ist PFIs "Chainer" berühmt, aber "Chainer" unterstützt die Lernmethode für die Verwendung von RBM nicht (Stand: 25. Oktober 2015).

Wenn Sie das Auto Encoder-Netzwerk anstelle von RBM verwenden möchten, empfehlen wir "Chainer".

Installation

Grundsätzlich müssen Sie nur das Git-Repository klonen und installieren.

git clone git://github.com/lisa-lab/pylearn2.git
cd pylearn2
python setup.py build
sudo python setup.py install

Danach sehe ich oft Erklärungen wie "Übergeben Sie den von pylearn2 verwendeten Pfad", aber tatsächlich funktioniert Pylearn2 auch dann, wenn Sie den Pfad nicht übergeben.

Damit der Tutorial-Code funktioniert, müssen Sie jedoch noch den Pfad durchlaufen.

Vom Git-Klon bis zur Ausführung des Tutorial-Codes wird in ein Shell-Skript umgewandelt. (Es tut mir leid, wenn es nicht funktioniert)

Versuchen Sie es mit

Der allgemeine Fluss von pylearn2 ist wie folgt

1. Erstellen Sie die Trainingsdaten in einem Format, das mit pylearn2 verwendet werden kann
2. Schreiben Sie die Trainingsmethode in die yaml-Datei
3. Führen Sie das Trainingsskript aus

1 Erstellen Sie Trainingsdaten in einem Format, das mit pylearn2 verwendet werden kann

Die Trainingsdaten werden von numpys ndarray vorbereitet und in ein Objekt für pylearn2 konvertiert.

Hierbei wird davon ausgegangen, dass die Daten bereits in numpy.ndarray aufbereitet sind.

Bereiten Sie zunächst eine Klasse vor, um das Format für pylearn2 neu zu schreiben.

Hier bereiten wir eine Klasse namens "FacePicDataSet" vor, was "Gesichtsbilddaten" bedeutet. Diese Klasse erbt von pylearn2.datasets.DenseDesignMatrix.

from pylearn2.datasets import DenseDesignMatrix
class FacePicDataSet(DenseDesignMatrix):
    def __init__(self, data):
        self.data = data
        super(FacePicDataSet, self).__init__(X=data))

Erstellen Sie als Nächstes ein FacePicDataSet-Objekt

train = FacePicDataSet(data=data_matrix)

Speichern Sie als Nächstes die Datei im Nupmy-Format und die Dataset-Pickle-Datei.

from pylearn2.utils import serial
train.use_design_loc(path_to_npy_file)
# save in pickle
serial.save(train_pkl_path, train)

2. Schreiben Sie die Trainingsmethode in die yaml-Datei

Im Grunde ist es so, als würde man eine Tutorial-Vorlage mitbringen und damit spielen.

Der Ort, an dem aus dem Trainingsskript aufgerufen und die Variable eingefügt werden soll, wird mit dem Typ "% (Variablenname)" beschrieben.

Der Punkt ist

• Beschreiben Sie den Pfad der Pickle-Datei in raw: & raw_train! Pkl:
• Beschreiben Sie die Anzahl der Dimensionen der Daten in nvis: (10000 Dimensionen für 100 * 100 Bilder)
• Beschreiben Sie das Datenspeicherziel nach dem Training in save_path:

Den vollständigen Text finden Sie unter Meine Yaml-Datei.

3. Führen Sie das Trainingsskript aus

Importieren Sie zunächst das Nutzungspaket. Stellen Sie sicher, dass Sie die Klasse der Dataset-Pickle-Datei __ importieren

import os
from pylearn2.testing import skip
from pylearn2.testing import no_debug_mode
from pylearn2.config import yaml_parse
from make_dataset_pylearn2 import FacePicDataSet

Schreiben Sie zunächst eine Funktion für das Training

@no_debug_mode
def train_yaml(yaml_file):

    train = yaml_parse.load(yaml_file)
    train.main_loop()

Lesen Sie außerdem die yaml-Datei und geben Sie die Variablen ein.

yaml_file_path = path_to_yaml_file
save_path = path_to_save_file
yaml = open(yaml_file_path, 'r').read()

hyper_params = {'detector_layer_dim': 500,
                    'monitoring_batches': 10,
                    'train_stop': 50000,
                    'max_epochs': 300,
                    'save_path': save_path,
                    'input_pickle_path': input_pickle_path}

    yaml = yaml % (hyper_params)

Führen Sie schließlich das Training durch

train_yaml(yaml)

Extra: Visualisieren

DeepNN hat eine verborgene Schicht, und diese verborgene Schicht entspricht den extrahierten Merkmalen.

Da es eine große Sache ist, habe ich auch ein Skript erstellt, um die verborgene Ebene zu extrahieren.

Alles was Sie tun müssen, ist ein Bild mit den Zahlen in nupmy.ndarray zu erstellen.

Eine ausführliche Erklärung finden Sie unter hier.

Bei der Ausführung werden auf diese Weise Bilder für die Anzahl der Knoten mit ausgeblendeten Ebenen angezeigt.

4. Räumliche Abbildung von Bilddaten unter Verwendung des gelernten Merkmalsmengenvektors

Die Originaldaten werden mithilfe der erlernten Funktionen zugeordnet.

Diesmal enthalten die Originaldaten beispielsweise 711 Fotos, und jedes Bild hat eine Größe von 150 * 150 = 22.500 Abmessungen. Daher besteht die Matrix der Originaldaten aus "711 * 22500".

Andererseits ist die Merkmalsmengenumwandlungsmatrix "(die Anzahl der ursprünglichen Dimensionen) * (die Anzahl der verborgenen Schichtknoten)". Dieses Mal haben wir 500 Knoten mit versteckten Schichten vorbereitet, es handelt sich also um eine Matrix von "22500 * 500".

Daher ist die Matrix nach der Konvertierung "(711 * 22500) * (22500 * 500) = 711 * 500".

Originaldaten lesen

Lesen Sie die Matrixdaten von 711 * 22500.

Es scheint, dass ich die Trainingsdaten-Pickle-Datei lesen sollte, aber es hat nicht funktioniert. Ich erhalte einen Fehler aufgrund der FacePicDataSet -Klasse.

Also werde ich dieses Mal die Numpy-Datei lesen.

import numpy
datasource_ndarray = numpy.load(path_to_datasource_npy)

Also wurden die Originaldaten gelesen.

Laden Sie dann die trainierte Pickle-Objektdatei.

import pickle
file_obj = open(path_to_trained_model_pickle, 'rb')
model_object = pickle.load(file_obj)

Holen Sie sich außerdem die Gewichtsmatrix der verborgenen Ebene

feature_vector = model_object.get_weights()

Schließlich räumliche Zuordnung Da feature_vector verschoben wurde, wird es mit T med verschoben.

new_space_matrix = numpy.dot(a=data_matrix, b=feature_vectors.T)

Dadurch erhalten Sie die transformierte Matrix "new_space_matrix".

Diese Operation wird üblicherweise als "Einbetten" bezeichnet.

5. In den dimensionalen Raum komprimieren

Komprimieren Sie die Einbettungsdaten.

Dieses Mal möchte ich eine zweidimensionale Streukarte erstellen, damit sie auch in einem 500-dimensionalen Raum noch groß ist.

TSNE / PCA wird häufig zur Dimensionskomprimierung verwendet. (Ich denke empirisch)

Diese beiden können leicht mit scicit-learn durchgeführt werden. tSNE, [pca](http://scikit-learn.org/stable/modules/generated/sklearn .decomposition.PCA.html)

Ich werde die ausführliche Erklärung weglassen. Sehen Sie sich daher das Beispiel von scikit-learn und [Mein Code] an (https://github.com/Kensuke-Mitsuzawa/let_s_analyze_miss_collection_girls/blob/master/analysis/dimension_reduction/modules/reduction_core.py). Bitte gib mir.

6. Erstellen Sie ein interaktives Streudiagramm

Erstellen Sie ein interaktives Streudiagramm.

Ich möchte einige Funktionen, weil es eine große Sache ist. Weil es falsch unterstützt

• Ich möchte das Gesichtsbild anzeigen
• Ich möchte auch mein Profil sehen
• Ich möchte in der Lage sein, zur Programmseite zu springen

Ich möchte die Funktion von.

Sie können alles tun. Mit Bokeh!

Installation

Wenn Sie Anakonda verwenden, ist es sehr einfach.

Der Befehl auf der offiziellen Bokeh-Seite endet sofort.

Beachten Sie jedoch, dass es das Standard-Ipython-Notebook ersetzt.

Es ist eine gute Idee, die globale Python-Umgebung mit pyenv wechseln zu können.

Diagrammerstellung

Das Schöne an Bokeh ist, dass Sie es mit ipython notebook erstellen können.

Ich habe es mit dem ipython notebook erstellt.

Irgendwie ist die Erklärung durcheinander, aber nehmen wir an, Sie haben jetzt ein Diktierobjekt wie dieses. Schlüssel und Werte werden für die Anzahl der Teilnehmer gespeichert.

{
    string: {
        "major": string, 
        "grade": int, 
        "age": int, 
        "member_name_rubi": string, 
        "height": float, 
        "member_index": int, 
        "profile_url": string, 
        "blog_url": string, 
        "member_name": string, 
        "university": string, 
        "position_vector": [
            float, 
            float
        ], 
        "photo_url": string
    }

Um mit Bokeh ein Diagramm zu erstellen, gehen Sie ungefähr so vor

1. Erstellen Sie ein Bokeh-Tabellenobjekt
2. Erstellen Sie ein Diagrammobjekt aus einem Tabellenobjekt
3. Erstellen Sie ein eingebettetes HTML-Diagramm mit "show (Diagrammobjekt)"

1. Erstellen Sie ein Bokeh-Tabellenobjekt

Um ein Bokeh-Tabellenobjekt zu erstellen, bereiten Sie mehrere Listendaten vor und verwenden Sie die ColumnDataSource-Methode.

Transformieren Sie das Diktierobjekt so, dass es so aussieht

{
    'X': [Daten hier],
    'Y': [Daten hier],
    'desc': [Daten hier],
    'imgs': [Daten hier],
Kombiniert mit Schlüssel und Wert
}

X und Y können beliebige Schlüsselnamen sein, z. B. desc. Offensichtlich müssen alle Wertelisten gleich lang sein. Speichern Sie es unter dem Objektnamen items_for_graph.

Erstellen Sie zunächst ein Tabellenobjekt für Bokeh.

    from bokeh.plotting import figure, output_file, show, ColumnDataSource

    source = ColumnDataSource(
            data=dict(
            x=items_for_graph['X'],
            y=items_for_graph['Y'],
            desc=items_for_graph['labels'],
            imgs = items_for_graph['images'],
            univ = items_for_graph['universities'],
            major = items_for_graph['major'],
            height = items_for_graph['height'],
            age = items_for_graph['age'],
            blog = items_for_graph['blog_links'],
            profile= items_for_graph['profile_links'],
            )
        )

Geben Sie als Nächstes die Funktion an, die Sie im Diagramm verwenden möchten, und geben Sie die Diagrammgröße an. Geben Sie unter Extras die Funktion an, die Sie im Diagramm verwenden möchten. Weitere Informationen finden Sie im Bokeh-Handbuch.

    from bokeh.io import output_file, show, vform, vplot
    from bokeh.models import HoverTool, OpenURL, TapTool    
    # Import bokeh, sub modules for making scallter graph with tooltip
    from bokeh.models.widgets import DataTable, DateFormatter, TableColumn    
    from bokeh.models import ColumnDataSource, OpenURL, TapTool
    from bokeh.plotting import figure, output_file, show  
    
    GRAPH_HEIGHT = 1000
    GRAPH_WIDTH = 800
    TOOLS = [WheelZoomTool(), PanTool(), ResetTool(), TapTool()]

Erstellen Sie dann ein Diagrammobjekt. Dieses Mal wird die Kreismethode angegeben, um ein Streudiagramm zu erstellen. Wenn Sie dies ändern, können Sie eine Linie zeichnen, um die Zeitreihen anzuzeigen. Schauen wir uns auch das [Bokeh-Handbuch] an (http://bokeh.pydata.org/en/0.10.0/docs/reference/plotting.html).

    s1 = figure(plot_width=GRAPH_WIDTH, plot_height=GRAPH_HEIGHT, tools=TOOLS, title=graph_title_name)
    s1.circle('x', 'y', size=10, source=source)

Erstellen Sie schließlich ein Diagramm-HTML mit show (s1).

Fügen Sie verschiedene Funktionen hinzu

Gesichtsbildanzeige

In Bokeh können Sie selbst HTML-Tags schreiben, um Toolchips herzustellen.

Daher können Sie ein HTML-Tag schreiben, das ein Bild anzeigt, und es als Toolchip verwenden.

Weitere Informationen hier

Klicken Sie hier, um die URL zu öffnen

Sie können die URL einfach mit der OpenURL-Methode einbetten.

Klicken Sie hier, um die URL in der Tabelle zu öffnen.

Weitere Informationen finden Sie hier (http://bokeh.pydata.org/en/latest/docs/user_guide/interaction.html#openurl).

Zeigen Sie sowohl Tabellen als auch Grafiken an

Es ist nicht möglich, alle Informationen in der Grafik anzuzeigen. Daher werde ich detaillierte Informationen in die Tabelle aufnehmen.

Und die Oberseite ist ein Streudiagramm und die Unterseite ist eine Grafik. Sie können es so anzeigen.

Weitere Informationen finden Sie in diesem Teil.

Aus diesem Grund ist das von mir erstellte Diagramm hier. Dieses Diagramm ist das Ergebnis einer zweidimensionalen Darstellung mit RBM-Einbettungen + PCA.

Siehe auch tSNE.

Im Vergleich dazu habe ich das Gefühl, dass PCA ähnlichere Gesichter hat, die näher dargestellt sind.

Ich bin der Meinung, dass PCA die Dimensionen von Einbettungen besser auf zwei Dimensionen komprimieren kann.

Deshalb habe ich dieses Mal Deep Learning verwendet, um etwas zur Unterstützung von Miscon zu erstellen. Wir hoffen, dass Sie dies als Beispiel für die Verwendung von Deep Learning betrachten.

Außerdem ist der gesamte Code auf github veröffentlicht. Bitte verwenden Sie alle Mittel. Außerdem suchen wir Menschen, die gemeinsam interessante Dinge entwickeln. Wenn Sie interessante Ideen haben, können Sie sich gerne an uns wenden.

Andere-Referenzfälle

• Personen, die eine Pipeline erstellt haben, die die Verwendung von pylearn2 vereinfacht
• [Personen, die versucht haben, Twitter-Symbole mit CSV-Daten zu lernen](http://laughing.hatenablog.com/entry/2013/11/30/pylearn2_%E5%85%A5%E9%96%80 % E3% 81% 97% E3% 81% 9F% E3% 81% 84% E7% B7% A8)
• Pylearn2-Installation und Tutorial
• Handschriftliche Zeichenerkennung mit pylearn2
• Ansicht mit pylearn2 mit künstlichen Daten