--- language: - en metrics: - accuracy library_name: adapter-transformers pipeline_tag: text-classification tags: - code --- # Model Card for Model ID ## Model Details los detalles del modelo que utilizamos: Modelo base: BERT (Bidirectional Encoder Representations from Transformers). Función del modelo: Clasificación de secuencias de texto. Número de etiquetas: Dos clases o categorías. Tokenizer utilizado: BertTokenizer de la biblioteca Transformers. Modelo específico utilizado: BertForSequenceClassification de la biblioteca Transformers. Optimizador: AdamW (una variante de Adam, con correcciones de peso) para ajustar los pesos del modelo durante el entrenamiento. Dispositivo de entrenamiento: GPU si está disponible, de lo contrario, se usa CPU. Métricas evaluadas: Durante el entrenamiento, se evaluaron métricas como precisión, exactitud, sensibilidad (recall) y especificidad en un conjunto de validación. Proceso de entrenamiento: Entrenamiento del modelo durante múltiples épocas (ajustable) con un ciclo que involucra actualización de pesos basada en la pérdida (loss) calculada y evaluación del desempeño del modelo en un conjunto de validación. ### Model Description El modelo utilizado, BERT (Bidirectional Encoder Representations from Transformers), es una red neuronal preentrenada que ha mostrado un rendimiento excepcional en tareas de procesamiento de lenguaje natural (NLP). Utiliza una arquitectura Transformer que permite capturar y comprender contextos de palabras y frases en ambos sentidos, lo que lo hace efectivo para entender el significado y contexto de una secuencia de texto. En este caso, empleamos BertForSequenceClassification, una adaptación de BERT para la clasificación de secuencias de texto. Esta variante agrega una capa de clasificación lineal sobre la salida de la capa de representación de BERT, permitiendo clasificar secuencias en un número específico de categorías. El modelo se entrenó para diferenciar entre dos etiquetas o clases en este caso particular. El proceso de entrenamiento consistió en ajustar los pesos del modelo utilizando un optimizador AdamW, minimizando la función de pérdida a través de múltiples épocas de entrenamiento. Se evaluó el desempeño del modelo utilizando métricas como precisión, exactitud, sensibilidad y especificidad en un conjunto de validación para garantizar su capacidad predictiva. Developed by: Freddy Morales Funded by [optional]: N/A Shared by [optional]: Model type: BERT (Bidirectional Encoder Representations from Transformers). Language(s) (NLP): Primarily designed for English, but can be fine-tuned and adapted to other languages. License: BERT and its variations are released under the Apache License 2.0. Finetuned from model [optional]: The model used might have been fine-tuned from the 'bert-base-uncased' model, a pre-trained version of BERT released by Google. ### Model Sources [optional] - **Repository:** [More Information Needed] - **Paper [optional]:** https://towardsdatascience.com/fine-tuning-bert-for-text-classification-54e7df642894 - **Demo [optional]:** [More Information Needed] ## Uses ### Direct Use [More Information Needed] ### Downstream Use [optional] [More Information Needed] ### Out-of-Scope Use [More Information Needed] ## Bias, Risks, and Limitations [More Information Needed] ### Recommendations Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations. ## How to Get Started with the Model from transformers import BertTokenizer, BertForSequenceClassification # Número de etiquetas/clases en tu problema de clasificación num_etiquetas = 2 # Actualiza con el número correcto de clases #1 Descargar y cargar el modelo BERT para clasificación: # Descargar el tokenizador y el modelo preentrenado BERT para clasificación tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=num_etiquetas) from transformers import BertTokenizer, BertForSequenceClassification #2. Configuración del optimizador y del dispositivo: from torch.optim import AdamW # Parámetros de optimización optimizador = AdamW(model.parameters(), lr=5e-5) # Dispositivo (GPU si está disponible, de lo contrario, CPU) dispositivo = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(dispositivo) # 3 División del conjunto de datos y creación de DataLoader: from torch.utils.data import DataLoader, TensorDataset, RandomSampler, SequentialSampler from sklearn.model_selection import train_test_split # División del conjunto de datos train_idx, val_idx = train_test_split(np.arange(len(labels)), test_size=val_ratio, shuffle=True, stratify=labels) # Creación de DataLoader para entrenamiento train_dataloader = DataLoader( TensorDataset(token_id[train_idx], attention_masks[train_idx], labels[train_idx]), sampler=RandomSampler(train_idx), batch_size=batch_size ) # Creación de DataLoader para validación val_dataloader = DataLoader( TensorDataset(token_id[val_idx], attention_masks[val_idx], labels[val_idx]), sampler=SequentialSampler(val_idx), batch_size=batch_size ) from sklearn.metrics import precision_score # ... #4Entrenamiento del modelo BERT para clasificación: num_epochs = 3 # ajusta el número de épocas según sea necesario # Ciclo de entrenamiento for epoch in trange(num_epochs, desc='Epoch'): model.train() for step, batch in enumerate(train_dataloader): batch = tuple(t.to(dispositivo) for t in batch) input_ids, attention_mask, labels = batch optimizador.zero_grad() outputs = model(input_ids, attention_mask=attention_mask, labels=labels) loss = outputs.loss loss.backward() optimizador.step() # Evaluación en el conjunto de validación después de cada época model.eval() # Tracking variables val_accuracy = [] val_precision = [] for batch in val_dataloader: # Cambiado a val_dataloader en lugar de validation_dataloader batch = tuple(t.to(dispositivo) for t in batch) b_input_ids, b_input_mask, b_labels = batch with torch.no_grad(): # Forward pass eval_output = model( b_input_ids, token_type_ids=None, attention_mask=b_input_mask ) logits = eval_output.logits.detach().cpu().numpy() label_ids = b_labels.to('cpu').numpy() # Calculate validation metrics b_accuracy, _, _, b_precision = b_metrics(logits, label_ids) val_accuracy.append(b_accuracy) val_precision.append(b_precision) # Calcular métricas promedio para la época avg_val_accuracy = sum(val_accuracy) / len(val_accuracy) avg_val_precision = sum(val_precision) / len(val_precision) if len(val_precision) > 0 else float('nan') # Imprimir resultados de la época print(f'\nEpoch {epoch + 1}/{num_epochs}') print(f' - Training Loss: {loss.item()}') print(f' - Validation Accuracy: {avg_val_accuracy}') print(f' - Validation Precision: {avg_val_precision}') # Predicción en un nuevo ejemplo nueva_oracion = "Nah I don't think he goes to usf, he lives around here though" # Aplicar el tokenizer para obtener los IDs de tokens y la máscara de atención encoding = tokenizer.encode_plus( nueva_oracion, add_special_tokens=True, max_length=32, # Ajusta la longitud máxima según sea necesario pad_to_max_length=True, return_attention_mask=True, return_tensors='pt' # Devuelve tensores de PyTorch ) # Obtener los IDs de tokens y la máscara de atención input_ids = encoding['input_ids'].to(dispositivo) attention_mask = encoding['attention_mask'].to(dispositivo) # Asegurarse de que las dimensiones sean adecuadas para el modelo BERT input_ids = input_ids.view(1, -1) # Cambiar la forma a (1, longitud) attention_mask = attention_mask.view(1, -1) # Cambiar la forma a (1, longitud) # Realizar la predicción with torch.no_grad(): output = model(input_ids, attention_mask=attention_mask) # Obtener la clase predicha prediccion = 'Clase A' if torch.argmax(output.logits[0]).item() == 0 else 'Clase B' # Imprimir resultados print(f'Nueva Oración: {nueva_oracion}') print(f'Predicción: {prediccion}') [More Information Needed] ## Training Details ### Training Data [More Information Needed] ### Training Procedure #### Preprocessing [optional] [More Information Needed] #### Training Hyperparameters - **Training regime:** [More Information Needed] #### Speeds, Sizes, Times [optional] [More Information Needed] ## Evaluation ### Testing Data, Factors & Metrics #### Testing Data [More Information Needed] #### Factors [More Information Needed] #### Metrics [More Information Needed] ### Results [More Information Needed] #### Summary ## Model Examination [optional] [More Information Needed] ## Environmental Impact Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700). - **Hardware Type:** [More Information Needed] - **Hours used:** [More Information Needed] - **Cloud Provider:** [More Information Needed] - **Compute Region:** [More Information Needed] - **Carbon Emitted:** [More Information Needed] ## Technical Specifications [optional] ### Model Architecture and Objective [More Information Needed] ### Compute Infrastructure [More Information Needed] #### Hardware [More Information Needed] #### Software [More Information Needed] ## Citation [optional] **BibTeX:** [More Information Needed] **APA:** [More Information Needed] ## Glossary [optional] [More Information Needed] ## More Information [optional] [More Information Needed] ## Model Card Authors [optional] [More Information Needed] ## Model Card Contact [More Information Needed]