Update README.md

README.md

@@ -85,8 +85,137 @@ Finetuned from model [optional]: The model used might have been fine-tuned from
 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
-
-Use the code below 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]