Bei allen Aufgaben des Lehrens künstlicher Intelligenz gibt es ein unangenehmes Phänomen - Fehler im Markup der Trainingssequenz. Diese Fehler sind unvermeidlich, da das gesamte Markup manuell erfolgt. Wenn es eine Möglichkeit gibt, echte Daten programmgesteuert zu markieren, warum brauchen wir dann jemanden, der ihnen das Markieren beibringt und Zeit und Geld für die Erstellung eines absolut unnötigen Designs aufwendet?
Das Auffinden und Entfernen gefälschter Masken in einer großen Trainingssequenz ist ziemlich kompliziert. Sie können sie alle manuell anzeigen, dies erspart Ihnen jedoch keine wiederholten Fehler. Wenn Sie sich jedoch die in
früheren Beiträgen vorgeschlagenen Tools zum Studium neuronaler Netze genau ansehen, stellt sich heraus, dass es eine einfache und effektive Möglichkeit gibt, alle Artefakte aus der Trainingssequenz zu erkennen und zu extrahieren.
Und in diesem Beitrag gibt es ein konkretes Beispiel, es ist offensichtlich, dass ein einfaches Beispiel auf Ellipsen und Polygonen für ein gewöhnliches U-Netz wieder ein solches Lego im Sandkasten ist, aber ungewöhnlich konkret, nützlich und effektiv. Wir werden zeigen, wie eine einfache Methode fast alle Artefakte identifiziert und findet, alle Lügen der Trainingssequenz.
Also fangen wir an!
Nach wie vor werden wir die Reihenfolge der Bild / Masken-Paare untersuchen. In dem zufällig ausgewählten Bild in verschiedenen Vierteln platzieren wir eine Ellipse einer zufälligen Größe und ein Viereck einer beliebigen Größe, und beide Farben in derselben Farbe, ebenfalls zufällig ausgewählt aus zwei von ihnen. In der zweiten verbleibenden Farbe färben wir den Hintergrund. Die Abmessungen sowohl der Ellipse als auch des Vierecks sind natürlich begrenzt.
In diesem Fall werden wir jedoch Änderungen in das Paargenerierungsprogramm einführen und zusammen mit einer vollständig korrekten Maske eine falsche, durch eine Lüge vergiftete Maske vorbereiten. In etwa einem Prozent der Fälle ersetzen Sie das Viereck in der Maske durch eine Ellipse, d. H. Das wahre Objekt für die Segmentierung wird durch falsche Masken als Ellipse und nicht als Viereck bezeichnet.
Zufällige Beispiele 10
Beispiele für zufällige 10, aber von fehlerhaften Markups. Die obere Maske ist wahr, die untere ist falsch und die Zahlen in der Trainingssequenz sind in den Bildern gezeigt.
Für die Segmentierung verwenden wir dieselben Metrik- und Verlustberechnungsprogramme und dasselbe einfache U-Netz, verwenden jedoch kein Dropout.
Bibliothekenimport numpy as np import matplotlib.pyplot as plt from matplotlib.colors import NoNorm %matplotlib inline import math from tqdm import tqdm
Metrik- und Verlustfunktionen def dice_coef(y_true, y_pred): y_true_f = K.flatten(y_true) y_pred = K.cast(y_pred, 'float32') y_pred_f = K.cast(K.greater(K.flatten(y_pred), 0.5), 'float32') intersection = y_true_f * y_pred_f score = 2. * K.sum(intersection) / (K.sum(y_true_f) + K.sum(y_pred_f)) return score def dice_loss(y_true, y_pred): smooth = 1. y_true_f = K.flatten(y_true) y_pred_f = K.flatten(y_pred) intersection = y_true_f * y_pred_f score = (2. * K.sum(intersection) + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth) return 1. - score def bce_dice_loss(y_true, y_pred): return binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred) def get_iou_vector(A, B):
Normales U-Netz def build_model(input_layer, start_neurons):
Das Programm zum Generieren von Bildern und Masken - wahr und falsch. Die erste Ebene des Bildes wird in das Array eingefügt, die zweite ist die wahre Maske und die dritte Ebene ist die falsche Maske.
def next_pair_f(idx): img_l = np.ones((w_size, w_size, 1), dtype='float')*0.45 img_h = np.ones((w_size, w_size, 1), dtype='float')*0.55 img = np.zeros((w_size, w_size, 3), dtype='float') i0_qua = math.trunc(np.random.sample()*4.) i1_qua = math.trunc(np.random.sample()*4.) while i0_qua == i1_qua: i1_qua = math.trunc(np.random.sample()*4.) _qua = np.int(w_size/4) qua = np.array([[_qua,_qua],[_qua,_qua*3],[_qua*3,_qua*3],[_qua*3,_qua]]) p = np.random.sample() - 0.5 r = qua[i0_qua,0] c = qua[i0_qua,1] r_radius = np.random.sample()*(radius_max-radius_min) + radius_min c_radius = np.random.sample()*(radius_max-radius_min) + radius_min rot = np.random.sample()*360 rr, cc = ellipse( r, c, r_radius, c_radius, rotation=np.deg2rad(rot), shape=img_l.shape ) p0 = np.rint(np.random.sample()*(radius_max-radius_min) + radius_min) p1 = qua[i1_qua,0] - (radius_max-radius_min) p2 = qua[i1_qua,1] - (radius_max-radius_min) p3 = np.rint(np.random.sample()*radius_min) p4 = np.rint(np.random.sample()*radius_min) p5 = np.rint(np.random.sample()*radius_min) p6 = np.rint(np.random.sample()*radius_min) p7 = np.rint(np.random.sample()*radius_min) p8 = np.rint(np.random.sample()*radius_min) poly = np.array(( (p1, p2), (p1+p3, p2+p4+p0), (p1+p5+p0, p2+p6+p0), (p1+p7+p0, p2+p8), (p1, p2), )) rr_p, cc_p = polygon(poly[:, 0], poly[:, 1], img_l.shape) if p > 0: img[:,:,:1] = img_l.copy() img[rr, cc,:1] = img_h[rr, cc] img[rr_p, cc_p,:1] = img_h[rr_p, cc_p] else: img[:,:,:1] = img_h.copy() img[rr, cc,:1] = img_l[rr, cc] img[rr_p, cc_p,:1] = img_l[rr_p, cc_p] img[:,:,1] = 0. img[:,:,1] = 0. img[rr_p, cc_p,1] = 1. img[:,:,2] = 0. p_f = np.random.sample()*1000. if p_f > 10: img[rr_p, cc_p,2] = 1. else: img[rr, cc,2] = 1. i_false[idx] = 1 return img
Spickzettel-Berechnungsprogramm def make_sh(f_imgs, f_msks, val_len): precision = 0.85 batch_size = 50 t = tqdm() t_batch_size = 50 raw_len = val_len id_train = 1
Das Hauptprogramm der Berechnungen. Wir haben kleine Änderungen am gleichen Programm gegenüber dem vorherigen Beitrag vorgenommen und einige Variablen müssen erklärt und kommentiert werden.
i_false = np.zeros((train_num), dtype='int')
Es gibt eine falsche Maske. Wenn 1, stimmt die Maske von F_msks nicht mit der Maske von f_msks überein. Dies ist ein Indikator dafür, wonach wir tatsächlich suchen - falsche Masken.
m2_select = np.zeros((train_num), dtype='int')
Zeigt an, dass dieses Bild im Spickzettel ausgewählt ist.
batch_size = 50 val_len = batch_size + 1
Wir erstellen Sequenzen von Bild / Masken-Paaren für das Training und eine weitere Sequenz zum Testen. Das heißt, Wir werden eine neue, unabhängige Sequenz von 10.000 Paaren prüfen. Wir zeigen zufällige Bilder mit echten und falschen Masken an und überprüfen sie visuell selektiv. Die obigen Bilder werden gezeigt.
In diesem speziellen Fall wurden 93 falsche Masken erhalten, auf denen eine Ellipse anstelle eines Vierecks als wahr positiv markiert wurde.
Wir beginnen mit dem Training am richtigen Satz und verwenden f_msks als Maske
input_layer = Input((w_size, w_size, 1)) output_layer = build_model(input_layer, 25) model = Model(input_layer, output_layer) model.compile(loss=bce_dice_loss, optimizer=Adam(lr=1e-4), metrics=[my_iou_metric]) v_false = make_sh(f_imgs, f_msks, val_len) t_pred = model.predict(t_imgs,batch_size=batch_size) print (get_iou_vector(t_msks,t_pred.reshape(-1,w_size ,w_size ,1)))
Accuracy 0.9807 loss 0.0092 selected img 404 tested img 10000 : : 1801it [08:13, 3.65it/s] 0.9895299999999841
Der Spickzettel stellte sich in nur 404 Bildern heraus und erhielt eine akzeptable Genauigkeit in einer unabhängigen Testsequenz.
Jetzt kompilieren wir das Netzwerk neu und trainieren in derselben Trainingssequenz, aber als Masken geben wir F_msks mit 1% falschen Masken an die Eingabe weiter
input_layer = Input((w_size, w_size, 1)) output_layer = build_model(input_layer, 25) model = Model(input_layer, output_layer) model.compile(loss=bce_dice_loss, optimizer=Adam(lr=1e-4), metrics=[my_iou_metric]) v_false = make_sh(f_imgs, F_msks, val_len) t_pred = model.predict(t_imgs,batch_size=batch_size) print (get_iou_vector(t_msks,t_pred.reshape(-1,w_size ,w_size ,1)))
Accuracy 0.9821 loss 0.0324 selected img 727 tested img 10000 : : 1679it [25:44, 1.09it/s] 0.9524099999999959
Wir haben einen Spickzettel mit 727 Bildern erhalten, der deutlich größer ist, und die Genauigkeit der Testvorhersagen, wie in der vorherigen Testsequenz, hat sich von 0,98953 auf 0,9525 verringert. Wir haben die Trainingssequenz um weniger als 1% um Lügen erweitert, nur 93 von 10.000 Masken waren falsch, aber das Ergebnis verschlechterte sich um 3,7%. Und das ist nicht nur eine Lüge, es ist eine echte List! Und der Spickzettel stieg von nur 404 auf bereits 727 Bilder.
Beruhigend und angenehm nur eine Sache
print (len(set(np.arange(train_num)[m2_select>0]).intersection(set(np.arange(train_num)[i_false>0])))) 93
Lassen Sie mich diese lange Formel erklären. Wir nehmen den Schnittpunkt der im Spickzettel ausgewählten Bilder mit der Menge der falschen Bilder und sehen, dass der Algorithmus alle 93 falschen Bilder im Spickzettel ausgewählt hat.
Die Aufgabe wird erheblich vereinfacht, es sind nicht 10.000 Bilder, die manuell durchgesehen werden müssen, es sind nur 727 und alle Lügen sind hier konzentriert.
Aber es gibt noch einen interessanteren und nützlicheren Weg. Bei der Zusammenstellung des Spickzettel haben wir nur die Bild / Masken-Paare aufgenommen, deren Vorhersage unter dem Schwellenwert liegt, und in unserem speziellen Fall haben wir den Wert der Vorhersagegenauigkeit im Array
v_false gespeichert . Schauen wir uns Paare aus der Trainingssequenz an, die einen sehr kleinen Vorhersagewert haben, beispielsweise weniger als 0,1, und sehen, wie viele dort liegen
print (len(set(np.arange(train_num)[v_false<0.01]).intersection(set(np.arange(train_num)[i_false>0])))) 89
Wie Sie sehen können, fiel der Hauptteil der falschen Masken, 89 von 93, in diese Masken
np.arange(train_num)[v_false<0.01].shape (382,)
Wenn wir also nur 382 Masken manuell überprüfen und dies von 10.000 Teilen ist, werden wir die meisten falschen Masken ohne Mitleid identifizieren und zerstören.
Wenn es möglich ist, Bilder und Masken während der Entscheidung, sie in den Spickzettel aufzunehmen, anzuzeigen, werden ausgehend von einem Schritt alle falschen Masken, alle Lügen durch die Mindestvorhersagestufe eines leicht trainierten Netzwerks bestimmt, und die richtigen Masken haben eine Vorhersage, die größer als diese Stufe ist .
Zusammenfassend
Wenn in einer imaginären Welt die Wahrheit immer viereckig ist und die ovale Lüge und eine unbekannte Entität beschlossen, die Wahrheit zu verzerren und einige Ellipsen die Wahrheit nennen, und die Vierecke falsch sind, dann wird die lokale Inquisition unter Verwendung künstlicher Intelligenz und der natürlichen Fähigkeit, Spickzettel zu erstellen, schnell und einfach finden und beseitigt Lügen und Betrug vollständig und vollständig.
PS Die Fähigkeit, Ovale, Dreiecke und einfache Polygone zu erkennen, ist eine Voraussetzung für die Erstellung einer KI, die das Auto steuert. Wenn Sie nicht wissen, wie Sie nach Ovalen und Dreiecken suchen sollen, finden Sie nicht alle Verkehrszeichen und Ihre KI fährt im falschen Auto ab.