es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo puedo mapear clases/etiquetas a enteros y convertirlas en tensores?

Tengo imágenes y etiquetas correspondientes, pero las etiquetas se dan como palabras (cadenas de texto). Creé una clase de conjunto de datos y una función de análisis para analizar los datos. Ahora, el problema que tengo es que cuando creo un lote, necesito poner las etiquetas en la GPU al igual que los datos y el modelo para poder hacer predicciones. El problema es que las etiquetas siguen siendo una tupla de cadenas (etiquetas correspondientes a las imágenes en el lote). He intentado asignar etiquetas a enteros, pero probablemente no sé cómo hacerlo, y mucho menos convertirlas en tensores.

Aquí está mi clase de conjunto de datos:

def parse_data(carpeta_imagenes, train_df):
    lista_img = []
    lista_etiquetas = []
    for nombre_archivo, etiqueta in zip(train_df['img_IDS'], train_df['Label']):
        nombre_completo = nombre_archivo + ".jpg"
        archivo_i = os.path.join(carpeta_imagenes, nombre_completo)

        lista_img.append(archivo_i)
        lista_etiquetas.append(etiqueta)

    etiquetas_unicas = list(set(lista_etiquetas))
    num_clases = len(etiquetas_unicas)
    lista_enteros = []
    i = 0
    for etiqueta in etiquetas_unicas:
        lista_enteros.append(i)
        i += 1

    print('#Imágenes\t#Etiquetas\n{}\t\t{}'.format(len(lista_img), len(set(lista_etiquetas))))
    return lista_img, lista_etiquetas, num_clases

Clase TestImageDataset(Dataset):
def init(self, lista_archivos, nombres_archivos, transformaciones):
self.lista_archivos = lista_archivos
self.transformaciones = transformaciones
self.nombres_archivos = nombres_archivos

def __len__(self):
    return len(self.lista_archivos)

def __getitem__(self, indice):
    img = Image.open(self.lista_archivos[indice])
    img = self.transformaciones(img)
    return img

def returnNamesList(self):
    return self.nombres_archivos

Esta es la función de análisis de imágenes: ```python def parse_test_data(carpeta_imagenes, test_df): lista_img = [] nombres_archivos = [] for nombre_archivo in test_df['img_IDS']: nombre_completo = nombre_archivo + ".jpg" nombres_archivos.append(nombre_completo) archivo_i = os.path.join(carpeta_imagenes, nombre_archivo) lista_img.append(archivo_i) print('#Imágenes de prueba:', len(lista_img)) return lista_img, nombres_archivos
Tags:  , , ,

Answer

  1. Avatar for davy.ai

    Para convertir las etiquetas (cadenas) en números enteros de tensor, puedes crear un diccionario que mapee cada cadena de etiqueta a un número entero único. Luego, recorre la lista de etiquetas y reemplaza cada cadena de etiqueta por su valor entero correspondiente. Aquí tienes una versión actualizada de la función parse_data que hace esto:

    def parse_data(Images_folder, train_df):
        img_list = []
        label_list = []
        for filename, label in zip(train_df['img_IDS'], train_df['Label']):
            full_name = filename + ".jpg"
            filei = os.path.join(Images_folder, full_name)
    
            img_list.append(filei)
            label_list.append(label)
    
        # crea un diccionario que mapea las etiquetas a enteros
        class_int_dict = {}
        labels = sorted(list(set(label_list)))
        for i, label in enumerate(labels):
            class_int_dict[label] = i
    
        # recorre la lista de etiquetas y reemplaza las etiquetas de cadena por valores enteros
        int_label_list = [class_int_dict[label] for label in label_list]
    
        print('#Imágenes\t\t#Etiquetas\n{}\t\t{}'.format(len(img_list), len(set(label_list))))
        return img_list, int_label_list, len(labels)
    

    Ahora, al crear un lote utilizando DataLoader, puedes usar el parámetro collate_fn para especificar cómo combinar las muestras individuales en el lote. Aquí tienes un ejemplo de la función collate_fn que convierte la lista de etiquetas enteras en un tensor:

    def collate_fn(batch):
        # images es una lista de tensores
        images = [item[0] for item in batch]
    
        # labels es una lista de enteros
        labels = [item[1] for item in batch]
        labels = torch.tensor(labels)
    
        return images, labels
    

    Luego, al crear un DataLoader, puedes especificar esta función collate_fn:

    train_data = TestImageDataset(train_img_list, train_labels, transforms=train_transform)
    train_loader = DataLoader(train_data, batch_size=32, shuffle=True, num_workers=4, collate_fn=collate_fn)
    

    Ahora, el lote devuelto por DataLoader incluirá un tensor de etiquetas enteras, que se puede pasar a tu modelo junto con el lote de imágenes.

Comments are closed.