Procesamiento de datos de aprendizaje profundo: cómo mezclar imágenes y etiquetas y dividirlas en conjuntos de prueba y entrenamiento

Procesamiento de datos de aprendizaje profundo: cómo mezclar imágenes y etiquetas y dividirlas en conjuntos de prueba y entrenamiento

Grabar mi primer blog de CSDN

Recientemente encontré el conjunto de datos Office31 en Internet. Este conjunto de datos contiene tres subconjuntos de datos, a saber: Amazon, dslr y cámara web. Cada subconjunto de datos contiene 31 clases. Lo siguiente comenzará con tres aspectos de los objetivos del procesamiento de datos , los procedimientos de procesamiento y los resultados del procesamiento .

1. Objetivos del procesamiento de datos

Importe el conjunto de datos de acuerdo con el subconjunto de datos seleccionado (Amazon, dslr, cámara web) y realice una codificación one-hot en la imagen, y finalmente divida el conjunto de datos en un conjunto de datos de entrenamiento y un conjunto de datos de prueba.
Formato de datos:
train_image = [train_n, w, h, c]
train_label = [train_n, categorías_n]
validate_image = [validate_n, w, h, c]
validate_label = [validate_n, categorías_n]

2. Procesamiento

El proceso de procesamiento se divide en: conjunto de datos de importación, codificación one-hot, dividir en conjunto de entrenamiento y conjunto de prueba

Importar conjunto de datos

Publica el código primero

import os
import glob
import cv2

img_label = []
img_feature = []

def get_datasets(args):
    i_categories = -1
    i_picture = -1
    img_path = os.path.join(args.data, args.datasets)
    # print(img_path)
    for name in glob.glob(img_path+'/images/*'):
        i_categories += 1
        # print(name)
        for jpg in glob.glob(name+'/*'):
            i_picture += 1
            # print(jpg)
            img = cv2.imread(jpg)
            img = cv2.resize(img, (300, 300))
            img_feature.append(img)
            img_label.append(i_categories)

    print("Total number of categories:" + str(i_categories + 1))
    print("Total number of pictures:" + str(i_picture + 1))
    
	# one-hot编码
	onehot_label = one_hot(img_label)
	# 将数据集划分为训练集和测试集
    train_set_label, validate_set_label, train_set_feature, validate_set_feature = _split_train_val(onehot_label,
                                                                                                    img_feature, 0.1)

La primera es la importación de la ruta de la imagen. Almaceno la ruta de la imagen en una declaración de parámetro general argparse. La ruta de guardado de mi imagen es como se muestra en la figura siguiente.

El nivel inferior de las imágenes contiene 31 subcarpetas y cada carpeta contiene una clase imagen

1. La ruta inicial es Original-images / amazon / images
2. Después de dos bucles for, el primero obtiene los nombres de todas las subcarpetas debajo de las imágenes y el segundo obtiene la ruta de las imágenes en cada subcarpeta.
3. Opencv obtiene los datos de la imagen. Aquí hay una operación muy importante, que es cv2.resize. Para el conjunto de datos descargado de Internet, de hecho, no comprobaremos si el tamaño de la imagen es el mismo. Por eso, perdí mucho tiempo. El programa sigue advirtiendo, y luego cambia el tamaño de todas las imágenes para unificarlas, este tamaño de imagen también se puede utilizar como parámetro global para facilitar la modificación del programa.
4. Finalmente, conecte cada dato a través de numpy.append para obtener dos matrices de etiqueta y característica

codificación one-hot

Esto sigue siendo muy simple, lo mismo, primero pega el código

from sklearn.preprocessing import LabelBinarizer

def one_hot(label):
    encoder = LabelBinarizer()
    onehot_label = encoder.fit_transform(label)
    return onehot_label

Se implementa usando LabelBinarizer en sklearn. El formato de datos de la etiqueta es [imagen_n, 1], y el formato de datos final de una etiqueta activa devuelta es [imagen_n, categorías_n]

Dividido en conjunto de entrenamiento y conjunto de prueba

Esto es muy simple para los conjuntos de datos que vienen con pytorch y tensorflow. Se puede hacer llamando a una API, pero para sus propios conjuntos de datos, necesita más energía para obtenerlo. Código postal primero

def _split_train_val(label, feature, val_fraction=0):
    n_train = int((1. - val_fraction) * len(label))
    n_val = len(label) - n_train
    # print(n_train, n_val)
    indices = np.arange(len(label))
    np.random.shuffle(indices)
    # print(np.shape(indices))
    # print(indices)
    train_label = []
    train_feature = []
    val_label = []
    val_feature = []
    for i in range(len(label)):
        if i < n_train:
            train_label.append(label[indices[i]])
            train_feature.append(feature[indices[i]])
        else:
            val_label.append(label[indices[i]])
            val_feature.append(feature[indices[i]])
    print("==> Split the dataset into train_set and validate_set")
    print("train_set: " + str(n_train), ",validate_set: " + str(n_val))
    return train_label, val_label, train_feature, val_feature

Para poder seleccionar aleatoriamente el conjunto de entrenamiento y el conjunto de prueba, primero genere un índice a través de numpy, desde 0- (imagen_n-1), y luego mezcle el índice a través de la función de reproducción aleatoria, de modo que el conjunto de datos se pueda dividir según el índice y el valor del índice. Es la etiqueta y el índice de características.

resultado del proceso

El resultado final se muestra a continuación.

|
|
|
|
| El
blog de referencia
python glob.glob usa
numpy.random.shuffle para mezclar la implementación de la función de orden