Float Multi-Label-Regression in Caffe - Verlust Ergebnisse

Question

Ich habe NN für Regressionsproblem trainiert. Mein Datentyp ist HDF5_DATA, die aus .jpg Bilder (3X256X256) und Float-Label-Array (3 Etiketten) gemacht. Daten-Set Skript erstellen:

import h5py, os 
import caffe 
import numpy as np 

SIZE = 256 # images size 
with open('/home/path/trainingTintText.txt', 'r') as T : 
    lines = T.readlines() 

X = np.zeros((len(lines), 3, SIZE, SIZE), dtype='f4') 
labels = np.zeros((len(lines),3), dtype='f4') 

for i,l in enumerate(lines): 
    sp = l.split(' ') 
    img = caffe.io.load_image(sp[0]) 
    img = caffe.io.resize(img, (SIZE, SIZE, 3)) 
    transposed_img = img.transpose((2,0,1))[::-1,:,:] # RGB->BGR 
    X[i] = transposed_img*255 
    print X[i] 
    labels[i,0] = float(sp[1]) 
    labels[i,1] = float(sp[2]) 
    labels[i,2] = float(sp[3]) 

with h5py.File('/home/path/train.h5','w') as H: 
    H.create_dataset('data', data=X) 
    H.create_dataset('label', data=labels) 

with open('/home/path/train_h5_list.txt','w') as L: 
    L.write('/home/path/train.h5') 

das ist (nicht fullish) Architektur:

name: "NN" 

layers { 
    name: "NNd" 
    top: "data" 
    top: "label" 
    type: HDF5_DATA 
    hdf5_data_param { 
    source: "/home/path/train_h5_list.txt" 
    batch_size: 64 
    } 
    include: { phase: TRAIN } 

} 

layers { 
    name: "data" 
    type: HDF5_DATA 
    top: "data" 
    top: "label" 
    hdf5_data_param { 
    source: "/home/path/train_h5_list.txt" 
    batch_size: 100 

    } 
    include: { phase: TEST } 
} 

layers { 
    name: "conv1" 
    type: CONVOLUTION 
    bottom: "data" 
    top: "conv1" 
    convolution_param { 
    num_output: 32 
    kernel_size: 11 
    stride: 2 

    bias_filler { 
     type: "constant" 
     value: 0.1 
    } 
    } 
} 


layers { 
    name: "ip2" 
    type: INNER_PRODUCT 
    bottom: "ip1" 
    top: "ip2" 
    inner_product_param { 
    num_output: 3 

    bias_filler { 
     type: "constant" 
     value: 0.1 
    } 
    } 
} 

layers { 
    name: "relu22" 
    type: RELU 
    bottom: "ip2" 
    top: "ip2" 
} 

layers { 
    name: "loss" 
    type: EUCLIDEAN_LOSS 
    bottom: "ip2" 
    bottom: "label" 
    top: "loss" 
} 

, wenn ich das NN trainiert habe ich sehr hohe Verlustwerte:

I1117 08:15:57.707001 2767 solver.cpp:337] Iteration 0, Testing net (#0) 
I1117 08:15:57.707033 2767 net.cpp:684] Ignoring source layer fkp 
I1117 08:15:59.111842 2767 solver.cpp:404]  Test net output #0: loss = 256.672 (* 1 = 256.672 loss) 
I1117 08:15:59.275205 2767 solver.cpp:228] Iteration 0, loss = 278.909 
I1117 08:15:59.275255 2767 solver.cpp:244]  Train net output #0: loss = 278.909 (* 1 = 278.909 loss) 
I1117 08:15:59.275276 2767 sgd_solver.cpp:106] Iteration 0, lr = 0.01 
I1117 08:16:57.115145 2767 solver.cpp:337] Iteration 100, Testing net (#0) 
I1117 08:16:57.115486 2767 net.cpp:684] Ignoring source layer fkp 
I1117 08:16:58.884704 2767 solver.cpp:404]  Test net output #0: loss = 238.257 (* 1 = 238.257 loss) 
I1117 08:16:59.026926 2767 solver.cpp:228] Iteration 100, loss = 191.836 
I1117 08:16:59.026971 2767 solver.cpp:244]  Train net output #0: loss = 191.836 (* 1 = 191.836 loss) 
I1117 08:16:59.026993 2767 sgd_solver.cpp:106] Iteration 100, lr = 0.01 
I1117 08:17:56.890614 2767 solver.cpp:337] Iteration 200, Testing net (#0) 
I1117 08:17:56.890880 2767 net.cpp:684] Ignoring source layer fkp 
I1117 08:17:58.665057 2767 solver.cpp:404]  Test net output #0: loss = 208.236 (* 1 = 208.236 loss) 
I1117 08:17:58.809150 2767 solver.cpp:228] Iteration 200, loss = 136.422 
I1117 08:17:58.809248 2767 solver.cpp:244]  Train net output #0: loss = 136.422 (* 1 = 136.422 loss) 

, wenn ich teilen die Bilder und die Label-Arrays von 255 Ich habe sehr geringe Verluste Ergebnisse (ordentlich zu 0). Was ist der Grund für diese Verlustergebnisse? mache ich etwas falsch? Danke

Answer 1

Mit dem euklidischen Verlust ist dies nur zu erwarten. Der euklidische Verlust sollte um einen Faktor von 256 kleiner sein, wenn Sie alle Labels durch 256 teilen und neu trainieren. Es bedeutet nicht, dass die Aufteilung der Labels um 256 das Netzwerk bei der Vorhersage der Labels besser macht; Sie haben gerade die "Skala" (die "Einheiten") geändert.

Insbesondere die euklidische Verlust ist (grob) L = sqrt ((x - y) + (x - y)), wobei x ist die richtige Antwort und y ist die Ausgabe vom neuronalen Netzwerk. Angenommen, Sie teilen alle x mit 256, dann neu trainieren. Das neuronale Netzwerk wird lernen, seine Ausgabe y durch 256 zu teilen. Wie wirkt sich das auf den euklidischen Verlust aus? L? Nun, wenn Sie durch die Mathematik arbeiten, werden Sie feststellen, dass L schrumpft um einen Faktor von 256.

Es wäre wie der Unterschied zwischen dem Versuch, eine Entfernung in Fuß zu prognostizieren, vs eine Entfernung in Yards. Letzteres würde bedeuten, durch 3 zu teilen. Konzeptionell würde die Gesamtgenauigkeit des Netzes gleich bleiben; aber der euklidische Verlust würde durch einen Faktor von drei geteilt, weil Sie die Einheiten von Yards zu Metern geändert haben. Ein durchschnittlicher Fehler von 0,1 Fuß würde einem durchschnittlichen Fehler von 0,0333 Yards entsprechen; aber konzeptionell die "gleiche" Genauigkeit, obwohl 0,0333 sieht aus wie eine kleinere Zahl als 0,1.

Die Aufteilung der Bilder um 256 sollte irrelevant sein. Es teilt die Beschriftungen mit 256, was die Reduzierung der Verlustfunktion verursachte.