Amazon revisa la transformación de datos en parte 1 aprendemos sobre la teoría en esta publicación aprenderemos la codificación.
El Conjunto de datos etiquetado manualmente del producto UCSD Amazondisponible en el enlace de github a continuación, dividiéndolo en 9637 entradas para capacitación y 2416 entradas para fines de prueba.
1. Tokenización de vocabulario
La tokenización de Vocab se utiliza básicamente como entrada de los modelos CNN, LSTM y RNN. La función tokenizadora toma dos argumentos: el tokenizador y la longitud máxima de cada secuencia tokenizada. La función tokenizer luego usa el tokenizer para tokenizar la columna reviewText y devuelve un DataFrame con las secuencias tokenizadas. La función concat luego concatena las secuencias tokenizadas DataFrame con el DataFrame original, agregando una nueva columna llamada tokens y la longitud de cada secuencia tokenizada llamada longitud. Se muestra en la figura Salida del tokenizador.
# Define the tokenizer to be used
tokenizer = torchtext.data.utils.get_tokenizer('basic_english')# Tokenize the reviewText column using a tokenizer function
df_train = pd.concat([df_train, df_train['reviewText'].apply(tokenize_data, tokenizer=tokenizer, max_length=256).apply(pd.Series)], axis=1)
La función numerize_data convierte un ejemplo tokenizado en una lista de ID. La variable special_tokens es una lista de tokens especiales que se agregan al vocabulario. La variable tokens es una lista de todos los tokens en el conjunto de datos. La variable vocab es un objeto de vocabulario que asigna tokens a ID. La variable unk_index es el índice del token en el vocabulario. La variable pad_index es el índice del token
def numericalize_data(example, vocab):
# Convert each token in the example to its corresponding ID from the vocabulary
ids = [vocab[token] for token in example['tokens']]
return {'ids': ids}special_tokens = ['<unk>', '<pad>']
tokens = df_train['tokens'].tolist()
# Build a vocabulary from the tokenized data with a minimum frequency and special tokens
vocab = torchtext.vocab.build_vocab_from_iterator(tokens, min_freq=5, specials=special_tokens)
unk_index = vocab['<unk>']
pad_index = vocab['<pad>']
vocab.set_default_index(unk_index)
# Numericalize the tokenized data using the vocabulary
df_train = pd.concat([df_train, df_train.apply(numericalize_data, vocab=vocab, axis=1).apply(pd.Series)], axis=1)
La variable de tren contiene una lista de diccionarios, cada uno de los cuales representa una sola revisión. La clave de ids en cada diccionario es el ID de la revisión, la clave de longitud es la longitud de la revisión, la clave de target_list es el valor de la columna target_list y la clave de reviewText es el texto de la revisión y se muestra en la figura Vocab Tokenization Producción. La variable df_train se puede usar para entrenar un modelo de procesamiento de lenguaje natural como CNN, LSTM y RNN.
# Assign the value 'encoded_topic' to the variable target_list
target_list = 'encoded_topic'# Select specific columns from the df_train DataFrame
df_train = df_train[['ids', target_list, 'length', 'reviewText']]
# Calculate the vocabulary size by getting the length of the vocab list
vocab_size = len(vocab)
output_dim = df_train[target_list].nunique()
# Prepare data for training
train = df_train.apply(lambda row: {
'ids': row['ids'],
'length': row['length'],
target_list: row[target_list],
'reviewText': row['reviewText']
}, axis=1).tolist()
La variable batch_size se establece en 64, lo que significa que cada lote contendrá 64 ejemplos. La variable collate_fn se establece en una función que convierte el diccionario por lotes en un formato que el modelo puede usar. La función collate_fn se crea utilizando la función functools.partial. La función functools.partial nos permite pasar las variables pad_index y target_list a la función collate. La función de clasificación convierte los datos a un formato que el modelo puede usar. La clase DataLoader crea un cargador de datos para cargar los datos en lotes para ayudar a evitar que el modelo se ajuste demasiado a los datos.
def collate(batch, pad_index,target_list):
batch_ids = [torch.tensor(i['ids']) for i in batch] # Convert ids list to tensor
batch_ids = pad_sequence(batch_ids, padding_value=torch.tensor(pad_index), batch_first=True)
batch_length = [torch.tensor(i['length']) for i in batch] # Convert length list to tensor
batch_length = torch.stack(batch_length)
batch_label = [torch.tensor(i[target_list]) for i in batch] # Convert reviewText list to tensor
batch_label = torch.stack(batch_label)
batch_text = [(i['reviewText']) for i in batch]
batch = {'ids': batch_ids,
'length': batch_length,
target_list: batch_label,
'text': batch_text}
return batchbatch_size = 64
collate_fn = functools.partial(collate, pad_index=pad_index, target_list=target_list)
# Create data loaders for training and validation
train_dataloader = DataLoader(train, batch_size=batch_size, collate_fn=collate_fn, shuffle=True)
2. Tokenizadores de ids y máscaras
Los tokenizadores de ID y máscaras se utilizan básicamente para modelos de transformadores como DistilBERT y BERT. El modelo preentrenado está basado en una destilería y proporciona un objeto DistilBertTokenizer. Este tokenizador se crea explícitamente para los modelos DistilBert y ofrece una alternativa más pequeña y rápida al tokenizador BERT. A pesar de su tamaño más pequeño, DistilBertTokenizer aún puede ofrecer un rendimiento de última generación en varias tareas de procesamiento de lenguaje natural.
Del mismo modo, el modelo preentrenado roberta-base proporciona un tokenizador BERT. Este tokenizador está diseñado para modelos BERT y es más grande y complejo que el DistilBertTokenizer. Sin embargo, también ofrece un rendimiento superior en varias tareas de procesamiento de lenguaje natural.
Para cargar de manera eficiente los datos para el entrenamiento y la inferencia, utilizamos un objeto DataLoader para el conjunto de entrenamiento y otro objeto DataLoader para el conjunto de prueba. Estos objetos DataLoader aseguran que los datos se carguen eficientemente en la memoria. Los parámetros train_batch_size y valid_batch_size controlan el tamaño del lote, determinando el número de muestras cargadas en la memoria.
tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-cased')
train_loader, valid_loader = get_data_loaders(df_train, df_test, tokenizer, train_batch_size = 8, valid_batch_size = 8)
La clase CustomDataset es una clase de PyTorch que se puede usar para cargar y procesar conjuntos de datos personalizados. El método __init__ de la clase inicializa las variables de clase. El método __len__ devuelve la longitud del conjunto de datos. El método __getitem__ primero usa el tokenizador para codificar los datos de texto. El generador de tokens devuelve un diccionario que contiene los ID de token, la máscara de atención y los ID de tipo de token para la secuencia de entrada. El método __getitem__ luego convierte los ID de token, la máscara de atención y los ID de tipo de token en tensores de PyTorch. El método __getitem__ también devuelve el texto original de la secuencia de entrada.
class CustomDataset(Dataset):
def __init__(self, df, tokenizer, max_len):
self.df = df
self.max_len = max_len
self.text = df.reviewText
self.tokenizer = tokenizer
self.targets = df[target_list].valuesdef __len__(self):
return len(self.df)
def __getitem__(self, index):
text = self.text[index]
inputs = self.tokenizer.encode_plus(
text,
truncation=True,
add_special_tokens=True,
max_length=self.max_len,
padding='max_length',
return_token_type_ids=True
)
#the attention_masks and token type ids, everything is returned in a dictionary format
ids = inputs['input_ids']
mask = inputs['attention_mask']
token_type_ids = inputs["token_type_ids"]
return {
'ids': torch.tensor(ids, dtype=torch.long),
'mask': torch.tensor(mask, dtype=torch.long),
'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long),
'targets': torch.tensor(self.targets[index], dtype=torch.long),
'text' : text
}
La función get_data_loaders toma un marco de datos de entrenamiento y validación, un tokenizador y algunos hiperparámetros, y devuelve un DataLoader de entrenamiento y validación. Los DataLoaders se utilizan para cargar los datos en lotes para entrenamiento y evaluación.
La función primero lee los marcos de datos de tren y validación en Pandas DataFrames. Luego, crea un objeto CustomDataset para cada DataFrame. El objeto CustomDataset toma el DataFrame, el tokenizador y la longitud máxima, y crea un conjunto de datos que se puede usar para cargar los datos en lotes.
La función crea un objeto DataLoader para cada objeto CustomDataset. Los objetos DataLoader toman el conjunto de datos, el tamaño del lote, la cantidad de trabajadores, el indicador de reproducción aleatoria y el indicador de memoria pin. El indicador de reproducción aleatoria controla si los datos se mezclan en el DataLoader, y el indicador de memoria pin controla si los datos se cargan en la memoria de la GPU.
def get_data_loaders(train_dataframe, valid_dataframe, tokenizer, max_len=512, train_batch_size=16, valid_batch_size=16, learning_rate=2e-5):Train_Dataframe = pd.read_csv(train_dataframe)
Validation_Dataframe = pd.read_csv(valid_dataframe)
train_dataset = CustomDataset(Train_Dataframe, tokenizer, max_len)
valid_dataset = CustomDataset(Validation_Dataframe, tokenizer, max_len)
train_loader = DataLoader(train_dataset, batch_size=train_batch_size,
num_workers=1, shuffle=True, pin_memory=True)
valid_loader = DataLoader(valid_dataset, batch_size=valid_batch_size,
num_workers=1, shuffle=False, pin_memory=True)
return train_loader, valid_loader
