FreddyM/Modeloafinclasiftexto

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 presented in Lacoste et al. (2019).

• 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]