Quiero usar caffe con un vector de la etiqueta, no entero. He comprobado algunas respuestas, y parece HDF5 es una mejor manera. Pero yo estoy pegado con el error como:

accuracy_layer.cpp:34] Comprobación de error: outer_num_ * inner_num_ == bottom[1]->count() (50 vs 200) Número de etiquetas debe coincidir con el número de predicciones; por ejemplo, si la etiqueta de eje == 1 y la predicción es la forma (N, C, H, W), la cuenta de la etiqueta (número de etiquetas) debe ser N*H*W, con el entero de los valores en {0, 1, …, C-1}.

con HDF5 creado como:

f = h5py.File('train.h5', 'w')
f.create_dataset('data', (1200, 128), dtype='f8')
f.create_dataset('label', (1200, 4), dtype='f4')

Mi red es generada por:

def net(hdf5, batch_size):
    n = caffe.NetSpec()
    n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
    n.ip1 = L.InnerProduct(n.data, num_output=50, weight_filler=dict(type='xavier'))
    n.relu1 = L.ReLU(n.ip1, in_place=True)
    n.ip2 = L.InnerProduct(n.relu1, num_output=50, weight_filler=dict(type='xavier'))
    n.relu2 = L.ReLU(n.ip2, in_place=True)
    n.ip3 = L.InnerProduct(n.relu1, num_output=4, weight_filler=dict(type='xavier'))
    n.accuracy = L.Accuracy(n.ip3, n.label)
    n.loss = L.SoftmaxWithLoss(n.ip3, n.label)
    return n.to_proto()

with open(PROJECT_HOME + 'auto_train.prototxt', 'w') as f:
f.write(str(net('/home/romulus/code/project/train.h5list', 50)))

with open(PROJECT_HOME + 'auto_test.prototxt', 'w') as f:
f.write(str(net('/home/romulus/code/project/test.h5list', 20)))

Parece que debo aumentar el número de etiqueta y poner las cosas en números enteros, en lugar de la matriz, pero si hago esto, caffe queja de que el número de datos y de la etiqueta no es igual, entonces existe.

Así que, ¿cuál es el formato correcto para alimentar múltiples datos de la etiqueta?

También, estoy preguntando por qué no simplemente escribir el formato de los datos de cómo HDF5 mapas para caffe blobs?

no data de tipo f4 así?
Cambiar a f4 no cambia el error.
Probablemente un valioso recurso: stackoverflow.com/questions/33112941/…
Gracias, que la pérdida de la capa es lo que necesito.

OriginalEl autor Romulus Urakagi Ts’ai | 2015-10-15

2 Comentarios

  1. 23

    Respuesta a esta pregunta del título:

    La HDF5 archivo debe tener dos conjunto de datos en la raíz, llamada “data” y “etiqueta”, respectivamente. La forma es (data amount, dimension). Estoy usando sólo una dimensión de los datos, así que no estoy seguro de cuál es el orden de channel, width, y height. Tal vez no importa. dtype debe ser float o double.

    Un código de ejemplo de la creación de juego de trenes con h5py es:

    de importación h5py, os 
    import numpy como np 
    
    f = h5py.Archivo('tren.h5', 'w') 
    # 1200 de datos, cada una es de 128-dim vector 
    f.create_dataset('datos', (1200, 128), dtype= "f8") 
    # Datos de etiquetas, cada una es un 4-dim vector 
    f.create_dataset('etiqueta', (1200, 4), dtype='f4') 
    
    # Llenar en algo con un patrón fijo 
    # Regularizar valores entre 0 y 1, o SigmoidCrossEntropyLoss no funcionará 
    for i in range(1200): 
    a = np.vacío(128) 
    si me % 4 == 0: 
    for j in range(128): 
    a[j] = j /128.0; 
    l = [1,0,0,0] 
    elif i % 4 == 1: 
    for j in range(128): 
    a[j] = (128 - j) /128.0; 
    l = [1,0,1,0] 
    elif i % 4 == 2: 
    for j in range(128): 
    a[j] = (j % 6) /128.0; 
    l = [0,1,1,0] 
    elif i % 4 == 3: 
    for j in range(128): 
    a[j] = (j % 4) * 4 /128.0; 
    l = [1,0,1,1] 
    f['data'][i] = a 
    f['etiqueta'][i] = l 
    
    f.close() 
    

    También, la exactitud de la capa no es necesaria, simplemente quitando está bien. El siguiente problema es la pérdida de la capa. Desde SoftmaxWithLoss sólo tiene una salida (índice de la dimensión con el valor máximo), no puede ser utilizado para varias etiquetas de problema. Gracias a Adian y Shai, me parece SigmoidCrossEntropyLoss es buena en este caso.

    A continuación está el código completo, desde la creación de datos, red de formación, y obtener el resultado de la prueba:

    main.py (modificado a partir de caffe lanet ejemplo)

    de importación os, sys 
    
    PROJECT_HOME = '.../proyecto/' 
    CAFFE_HOME = '.../caffe/' 
    os.chdir(PROJECT_HOME) 
    
    sys.ruta de acceso.insert(0, CAFFE_HOME + 'caffe/python') 
    importación de caffe, h5py 
    
    from pylab import * 
    de caffe importar capas como L 
    
    def neto(hdf5, batch_size): 
    n = caffe.NetSpec() 
    n.de datos, n.label = L. HDF5Data(batch_size=batch_size, fuente=hdf5, ntop=2) 
    n.ip1 = L. InnerProduct(n.de datos, num_output=50, weight_filler=dict(tipo='xavier')) 
    n.relu1 = L. ReLU(n.ip1, in_place=True) 
    n.ip2 = L. InnerProduct(n.relu1, num_output=50, weight_filler=dict(tipo='xavier')) 
    n.relu2 = L. ReLU(n.ip2, in_place=True) 
    n.ip3 = L. InnerProduct(n.relu2, num_output=4, weight_filler=dict(tipo='xavier')) 
    n.pérdida = L. SigmoidCrossEntropyLoss(n.ip3, n.la etiqueta) 
    de retorno n.to_proto() 
    
    con open(PROJECT_HOME + 'auto_train.prototxt', 'w') como f: 
    f.write(str(neto(PROJECT_HOME + 'tren.h5list', 50))) 
    con open(PROJECT_HOME + 'auto_test.prototxt', 'w') como f: 
    f.write(str(neto(PROJECT_HOME + 'de la prueba.h5list', 20))) 
    
    caffe.set_device(0) 
    caffe.set_mode_gpu() 
    solver = caffe.SGDSolver(PROJECT_HOME + 'auto_solver.prototxt') 
    
    solver.net.forward() 
    solver.test_nets[0].forward() 
    solver.el paso(1) 
    
    niter = 200 
    test_interval = 10 
    train_loss = zeros(niter) 
    test_acc = zeros(int(np.ceil(niter * 1.0 /test_interval))) 
    print len(test_acc) 
    salida = zeros((niter, 8, 4)) 
    
    # El principal solver bucle 
    en el rango de(niter): 
    solver.el paso(1) # SGD por Caffe 
    train_loss[es] = solver.net.blob['pérdida'].datos 
    solver.test_nets[0].hacia adelante(inicio='datos') 
    salida[es] = solver.test_nets[0].blob['ip3'].datos[:8] 
    
    si % test_interval == 0: 
    print 'Iteración', 'prueba de...' 
    correcto = 0 
    datos = solver.test_nets[0].blob['ip3'].datos 
    label = solver.test_nets[0].blob['etiqueta'].datos 
    para test_it en el rango(100): 
    solver.test_nets[0].forward() 
    # Valores positivos mapa de la etiqueta 1, mientras que los valores negativos mapa de la etiqueta 0 
    for i in range(len(datos)): 
    for j in range(len(datos[i])): 
    si los datos[i][j] > 0 y etiqueta[i][j] == 1: 
    correcto += 1 
    elif datos[i][j] %lt;= 0 y la etiqueta[i][j] == 0: 
    correcto += 1 
    test_acc[int (/test_interval)] = correcto * 1.0 /(len(datos) * len(datos[0]) * 100) 
    
    # Tren y prueba, imprimir convege gráfico 
    _, ax1 = subparcelas() 
    ax2 = ax1.twinx() 
    ax1.parcela(arange(niter), train_loss) 
    ax2.parcela(test_interval * arange(len(test_acc)), test_acc, 'r') 
    ax1.set_xlabel('iteración') 
    ax1.set_ylabel('tren de la pérdida') 
    ax2.set_ylabel('la exactitud de la prueba') 
    _.savefig('convergen.png') 
    
    # Comprobar el resultado de la última hornada 
    impresión de solver.test_nets[0].blob['ip3'].datos 
    impresión de solver.test_nets[0].blob['etiqueta'].datos 
    

    h5list archivos simplemente contener rutas de h5 archivos en cada línea:

    de tren.h5list

    /home/foo/bar/project/train.h5

    de la prueba.h5list

    /home/foo/bar/project/test.h5

    y el solver:

    auto_solver.prototxt

    train_net: "auto_train.prototxt" 
    test_net: "auto_test.prototxt" 
    test_iter: 10 
    test_interval: 20 
    base_lr: 0.01 
    impulso: 0.9 
    weight_decay: 0.0005 
    lr_policy: "inv" 
    gamma: 0.0001 
    potencia: 0.75 
    pantalla: 100 
    max_iter: 10000 
    instantánea: 5000 
    snapshot_prefix: "sed" 
    solver_mode: GPU 
    

    Convergen gráfico:
    Cómo alimentar caffe multi etiqueta de datos en formato HDF5?

    Último lote resultado:

    [[ 35.91593933 -37.46276474 -6.2579031 -6.30313492] 
    [ 42.69248581 -43.00864792 13.19664764 -3.35134125] 
    [ -1.36403108 1.38531208 2.77786589 -0.34310576] 
    [ 2.91686511 -2.88944006 4.34043217 0.32656598] 
    ... 
    [ 35.91593933 -37.46276474 -6.2579031 -6.30313492] 
    [ 42.69248581 -43.00864792 13.19664764 -3.35134125] 
    [ -1.36403108 1.38531208 2.77786589 -0.34310576] 
    [ 2.91686511 -2.88944006 4.34043217 0.32656598]] 
    
    [[ 1. 0. 0. 0.] 
    [ 1. 0. 1. 0.] 
    [ 0. 1. 1. 0.] 
    [ 1. 0. 1. 1.] 
    ... 
    [ 1. 0. 0. 0.] 
    [ 1. 0. 1. 0.] 
    [ 0. 1. 1. 0.] 
    [ 1. 0. 1. 1.]] 
    

    Creo que este código todavía tiene muchas cosas que mejorar. Cualquier sugerencia se agradece.

    Puede usted explicar cómo la etiqueta se define, es un sistema binario?
    Sí, yo sólo traté de sistema binario. EN es 1 y se APAGA es 0.
    ¿Cuál es el caffe versión? Hay un error para mí ImportError: cannot import name layers
    Yo actualmente no tengo la máquina, esta debe de ser la versión más reciente en Octubre de 2015.
    ¿por qué necesitamos para ejecutar test_net 100 veces a la hora de calcular la precisión? Por qué el resultado de estos 100 va a ser diferente?

    OriginalEl autor Romulus Urakagi Ts’ai

  2. 1

    Su exactitud capa no tiene sentido.

    El camino de la exactitud de la capa de obras: en precisión de la capa de espera de dos entradas

    (i) una predicción de la probabilidad de vector y

    (ii) la realidad sobre el terreno correspondiente escalar entero de la etiqueta.

    La exactitud de la capa que cheques si la probabilidad de que la predicción de la etiqueta es de hecho la máxima (o dentro de top_k).

    Por lo tanto, si usted tiene que clasificar C diferentes clases, las entradas van a ser NporC (donde N es el tamaño de lote) de entrada predijo que las probabilidades para N muestras pertenecientes a cada uno de los C clases, y N etiquetas.

    La forma en que se define en su red: precisión de entrada de la capa de N-por-4 predicciones y N-por-4 etiquetas — esto no tiene sentido para caffe.

    Parece que no he entendido exactitud de la capa. Pero si lo voy a borrar, la pérdida de la capa devuelve el mismo error que a mí. Tal vez necesite otro la Pérdida de la capa de vector de la etiqueta? No puedo encontrar una lista de pérdida de las capas disponibles.
    Traté de EuclideanLoss (sin precisión de la capa), pero devuelve masiva nan.
    es NaN por el principio? podría ser que la pérdida es demasiado alto, provocando la degradados a “explotar” tirar la formación de distancia. Trate de significativamente la reducción de la loss_weight de la pérdida de la capa.
    Sí, es NaN. Voy a tratar de que, muchas gracias!
    Bastante cosas diferentes, voy a publicar una respuesta completa de los códigos.

    OriginalEl autor Shai

Dejar respuesta

Please enter your comment!
Please enter your name here