created Bug Priority model and hugging face deployment read project

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README copy.md

@@ -0,0 +1,133 @@
+---
+title: Bug Priority Multiclass
+emoji: 📚
+colorFrom: green
+colorTo: purple
+sdk: docker
+pinned: false
+short_description: This model fine-tunes `roberta-base` using a labeled dataset
+
+tags:
+- text-classification
+- accessibility
+- bug-triage
+- transformers
+- roberta
+- pytorch-lightning
+license: apache-2.0
+datasets:
+- custom
+language:
+- en
+
+# RoBERTa Base Model for Accessibility Bug Priority Classification
+
+This model fine-tunes `roberta-base` using a labeled dataset of accessibility-related bug descriptions to automatically classify their **priority level**. It helps automate the triage of bugs affecting users of screen readers and other assistive technologies.
+
+
+## 🧠 Problem Statement
+
+Modern applications often suffer from accessibility issues that impact users with disabilities, such as content not being read properly by screen readers like **VoiceOver**, **NVDA**, or **JAWS**. These bugs are often reported via issue trackers or user forums in the form of short text summaries.
+
+Due to the unstructured and domain-specific nature of these reports, manual triage is:
+- Time-consuming
+- Inconsistent
+- Often delayed in resolution
+
+There is a critical need to **prioritize accessibility bugs quickly and accurately** to ensure inclusive user experiences.
+
+
+## 🎯 Research Objective
+
+This research project builds a machine learning model that can **automatically assign a priority level** to an accessibility bug report. The goal is to:
+
+- Streamline accessibility QA workflows
+- Accelerate high-impact fixes
+- Empower developers and testers with ML-assisted tooling
+
+## 📊 Dataset Statistics
+
+The dataset used for training consists of real-world accessibility bug reports, each labeled with one of four priority levels. The distribution of labels is imbalanced, and label-aware preprocessing steps were taken to improve model performance.
+
+| Label | Priority Level | Count |
+|-------|----------------|-------|
+| 1     | Medium         | 2035  |
+| 2     | High           | 1465  |
+| 0     | Low            | 804   |
+| 3     | Critical       | 756   |
+
+**Total Samples**: 5,060
+
+### 🧹 Preprocessing
+
+- Text normalization and cleanup  
+- Length filtering based on token count  
+- Label frequency normalization for class-weighted loss  
+
+To address class imbalance, class weights were computed as inverse label frequency and used in the cross-entropy loss during training.
+
+## 🧪 Dataset Description
+
+The dataset consists of short bug report texts labeled with one of four priority levels:
+
+| Label | Meaning     |
+|-------|-------------|
+| 0     | Low         |
+| 1     | Medium      |
+| 2     | High        |
+| 3     | Critical    |
+
+### ✏️ Sample Entries:
+
+```csv
+Text,Label
+"mac voiceover screen reader",3
+"Firefox crashes when interacting with some MathML content using Voiceover on Mac",0
+"VoiceOver skips over text in paragraphs which contain <strong> or <em> tags",2
+```
+
+
+## 📊 Model Comparison
+
+We fine-tuned and evaluated three transformer models under identical training conditions using PyTorch Lightning (multi-GPU, mixed precision, and weighted loss). The validation accuracy and F1 scores are as follows:
+
+| Model           | Base Architecture          | Validation Accuracy | Weighted F1 Score |
+|-----------------|----------------------------|---------------------|-------------------|
+| DeBERTa-v3 Base | microsoft/deberta-v3-base  | **69%**             | **0.69**          |
+| ALBERT Base     | albert-base-v2             | 68%                 | 0.68              |
+| RoBERTa Base    | roberta-base               | 66%                 | 0.67              |
+
+### 📝 Observations
+
+- **DeBERTa** delivered the best performance, likely due to its *disentangled attention* and *enhanced positional encoding*.
+- **ALBERT** performed surprisingly well despite having fewer parameters, showcasing its efficiency.
+- **RoBERTa** provided stable and reliable results but slightly underperformed compared to the others.
+
+
+# RoBERTa Base Model for Accessibility Priority Classification
+
+This model fine-tunes `roberta-base` using a 4-class custom dataset to classify accessibility issues by priority. It was trained using PyTorch Lightning and optimized with mixed precision on multiple GPUs.
+
+## Details
+
+- **Model**: roberta-base
+- **Framework**: PyTorch Lightning
+- **Labels**: 0 (Low), 1 (Medium), 2 (High), 3 (Critical)
+- **Validation F1**: 0.71 (weighted)
+
+## Usage
+
+```python
+from transformers import RobertaTokenizer, RobertaForSequenceClassification
+import torch
+
+model = RobertaForSequenceClassification.from_pretrained("your-username/roberta-priority-multiclass")
+tokenizer = RobertaTokenizer.from_pretrained("your-username/roberta-priority-multiclass")
+
+inputs = tokenizer("VoiceOver skips over text with <strong> tags", return_tensors="pt")
+outputs = model(**inputs)
+prediction = torch.argmax(outputs.logits, dim=1).item()
+
+print("Predicted Priority:", prediction)
+```
+---

README.md

@@ -1,11 +1,133 @@
 ---
 title: Bug Priority Multiclass
-emoji: 💻
-colorFrom: red
-colorTo: gray
+emoji: 📚
+colorFrom: green
+colorTo: purple
 sdk: docker
 pinned: false
-short_description: This is a Multiclass Bug Priority Model
----
+short_description: This model fine-tunes `roberta-base` using a labeled dataset
+
+tags:
+- text-classification
+- accessibility
+- bug-triage
+- transformers
+- roberta
+- pytorch-lightning
+license: apache-2.0
+datasets:
+- custom
+language:
+- en
+
+# RoBERTa Base Model for Accessibility Bug Priority Classification
+
+This model fine-tunes `roberta-base` using a labeled dataset of accessibility-related bug descriptions to automatically classify their **priority level**. It helps automate the triage of bugs affecting users of screen readers and other assistive technologies.
+
+
+## 🧠 Problem Statement
+
+Modern applications often suffer from accessibility issues that impact users with disabilities, such as content not being read properly by screen readers like **VoiceOver**, **NVDA**, or **JAWS**. These bugs are often reported via issue trackers or user forums in the form of short text summaries.
+
+Due to the unstructured and domain-specific nature of these reports, manual triage is:
+- Time-consuming
+- Inconsistent
+- Often delayed in resolution
+
+There is a critical need to **prioritize accessibility bugs quickly and accurately** to ensure inclusive user experiences.
+
+
+## 🎯 Research Objective
+
+This research project builds a machine learning model that can **automatically assign a priority level** to an accessibility bug report. The goal is to:
+
+- Streamline accessibility QA workflows
+- Accelerate high-impact fixes
+- Empower developers and testers with ML-assisted tooling
+
+## 📊 Dataset Statistics
+
+The dataset used for training consists of real-world accessibility bug reports, each labeled with one of four priority levels. The distribution of labels is imbalanced, and label-aware preprocessing steps were taken to improve model performance.
+
+| Label | Priority Level | Count |
+|-------|----------------|-------|
+| 1     | Medium         | 2035  |
+| 2     | High           | 1465  |
+| 0     | Low            | 804   |
+| 3     | Critical       | 756   |
+
+**Total Samples**: 5,060
+
+### 🧹 Preprocessing
+
+- Text normalization and cleanup  
+- Length filtering based on token count  
+- Label frequency normalization for class-weighted loss  
+
+To address class imbalance, class weights were computed as inverse label frequency and used in the cross-entropy loss during training.
+
+## 🧪 Dataset Description
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+The dataset consists of short bug report texts labeled with one of four priority levels:
+
+| Label | Meaning     |
+|-------|-------------|
+| 0     | Low         |
+| 1     | Medium      |
+| 2     | High        |
+| 3     | Critical    |
+
+### ✏️ Sample Entries:
+
+```csv
+Text,Label
+"mac voiceover screen reader",3
+"Firefox crashes when interacting with some MathML content using Voiceover on Mac",0
+"VoiceOver skips over text in paragraphs which contain <strong> or <em> tags",2
+```
+
+
+## 📊 Model Comparison
+
+We fine-tuned and evaluated three transformer models under identical training conditions using PyTorch Lightning (multi-GPU, mixed precision, and weighted loss). The validation accuracy and F1 scores are as follows:
+
+| Model           | Base Architecture          | Validation Accuracy | Weighted F1 Score |
+|-----------------|----------------------------|---------------------|-------------------|
+| DeBERTa-v3 Base | microsoft/deberta-v3-base  | **69%**             | **0.69**          |
+| ALBERT Base     | albert-base-v2             | 68%                 | 0.68              |
+| RoBERTa Base    | roberta-base               | 66%                 | 0.67              |
+
+### 📝 Observations
+
+- **DeBERTa** delivered the best performance, likely due to its *disentangled attention* and *enhanced positional encoding*.
+- **ALBERT** performed surprisingly well despite having fewer parameters, showcasing its efficiency.
+- **RoBERTa** provided stable and reliable results but slightly underperformed compared to the others.
+
+
+# RoBERTa Base Model for Accessibility Priority Classification
+
+This model fine-tunes `roberta-base` using a 4-class custom dataset to classify accessibility issues by priority. It was trained using PyTorch Lightning and optimized with mixed precision on multiple GPUs.
+
+## Details
+
+- **Model**: roberta-base
+- **Framework**: PyTorch Lightning
+- **Labels**: 0 (Low), 1 (Medium), 2 (High), 3 (Critical)
+- **Validation F1**: 0.71 (weighted)
+
+## Usage
+
+```python
+from transformers import RobertaTokenizer, RobertaForSequenceClassification
+import torch
+
+model = RobertaForSequenceClassification.from_pretrained("your-username/roberta-priority-multiclass")
+tokenizer = RobertaTokenizer.from_pretrained("your-username/roberta-priority-multiclass")
+
+inputs = tokenizer("VoiceOver skips over text with <strong> tags", return_tensors="pt")
+outputs = model(**inputs)
+prediction = torch.argmax(outputs.logits, dim=1).item()
+
+print("Predicted Priority:", prediction)
+```
+---

Training/deberta.py

@@ -0,0 +1,126 @@
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from datasets import Dataset
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, f1_score, classification_report
+
+import pytorch_lightning as pl
+from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping
+from pytorch_lightning.strategies import DDPStrategy
+
+from transformers import AutoTokenizer, AutoModel, DataCollatorWithPadding, get_cosine_schedule_with_warmup
+
+
+class DebertaClassifier(pl.LightningModule):
+    def __init__(self, num_labels=4, lr=2e-5, class_weights=None):
+        super().__init__()
+        self.save_hyperparameters()
+        self.model = AutoModel.from_pretrained("microsoft/deberta-v3-large")
+        self.dropout = nn.Dropout(0.3)
+        self.classifier = nn.Sequential(
+            nn.LayerNorm(self.model.config.hidden_size),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(self.model.config.hidden_size, num_labels)
+        )
+
+        if class_weights is not None:
+            weights = torch.tensor(class_weights, dtype=torch.float32)
+            self.loss_fn = nn.CrossEntropyLoss(weight=weights)
+        else:
+            self.loss_fn = nn.CrossEntropyLoss()
+
+    def forward(self, input_ids, attention_mask):
+        outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
+        cls_output = outputs.last_hidden_state[:, 0, :]
+        cls_output = self.dropout(cls_output)
+        return self.classifier(cls_output)
+
+    def training_step(self, batch, batch_idx):
+        input_ids, attention_mask, labels = batch["input_ids"], batch["attention_mask"], batch["labels"]
+        logits = self(input_ids, attention_mask)
+        loss = self.loss_fn(logits, labels)
+        preds = torch.argmax(logits, dim=1)
+        acc = accuracy_score(labels.cpu(), preds.cpu())
+        self.log("train_loss", loss, prog_bar=True)
+        self.log("train_acc", acc, prog_bar=True)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        input_ids, attention_mask, labels = batch["input_ids"], batch["attention_mask"], batch["labels"]
+        logits = self(input_ids, attention_mask)
+        loss = self.loss_fn(logits, labels)
+        preds = torch.argmax(logits, dim=1)
+        acc = accuracy_score(labels.cpu(), preds.cpu())
+        f1 = f1_score(labels.cpu(), preds.cpu(), average='weighted')
+        self.log("val_loss", loss, prog_bar=True)
+        self.log("val_acc", acc, prog_bar=True)
+        self.log("val_f1", f1, prog_bar=True, sync_dist=True)
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.AdamW(self.parameters(), lr=self.hparams.lr)
+        scheduler = get_cosine_schedule_with_warmup(
+            optimizer,
+            num_warmup_steps=100,
+            num_training_steps=self.trainer.estimated_stepping_batches
+        )
+        return {"optimizer": optimizer, "lr_scheduler": scheduler, "interval": "step"}
+
+
+if __name__ == "__main__":
+    df = pd.read_csv("data_cleaned2.csv")
+    print(df.head())
+    class_counts = df["labels"].value_counts().sort_index().tolist()
+    class_weights = 1.0 / np.array(class_counts)
+    class_weights = class_weights / class_weights.sum()
+
+    train_df = df.sample(frac=0.8, random_state=42)
+    val_df = df.drop(train_df.index)
+
+    tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v3-large")
+
+    def tokenize(batch):
+        return tokenizer(batch["text"], truncation=True)
+
+    train_dataset = Dataset.from_pandas(train_df).map(tokenize, batched=True)
+    val_dataset = Dataset.from_pandas(val_df).map(tokenize, batched=True)
+
+    train_dataset.set_format("torch", columns=["input_ids", "attention_mask", "labels"])
+    val_dataset.set_format("torch", columns=["input_ids", "attention_mask", "labels"])
+
+    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+    train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True, num_workers=8, collate_fn=data_collator)
+    val_loader = DataLoader(val_dataset, batch_size=16, num_workers=8, collate_fn=data_collator)
+
+    checkpoint_callback = ModelCheckpoint(
+        dirpath="checkpoints/",
+        filename="deberta3-{epoch:02d}-{val_f1:.2f}",
+        save_top_k=2,
+        monitor="val_f1",
+        mode="max",
+        save_weights_only=True,
+        every_n_epochs=1
+    )
+
+    early_stopping = EarlyStopping(
+        monitor="val_f1",
+        patience=3,
+        mode="max",
+        verbose=True,
+    )
+
+    trainer = pl.Trainer(
+        accelerator="gpu",
+        devices=2,
+        strategy=DDPStrategy(find_unused_parameters=False),
+        max_epochs=10,
+        precision=16,
+        log_every_n_steps=10,
+        callbacks=[checkpoint_callback, early_stopping],
+    )
+
+    model = DebertaClassifier(class_weights=class_weights)
+    trainer.fit(model, train_loader, val_loader)

Training/model.py

@@ -0,0 +1,115 @@
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, f1_score
+from datasets import Dataset
+
+import pytorch_lightning as pl
+from transformers import RobertaTokenizer, RobertaModel
+from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping
+from pytorch_lightning.strategies import DDPStrategy
+
+
+class RoBERTaClassifier(pl.LightningModule):
+    def __init__(self, num_labels=4, lr=2e-5, class_weights=None):
+        super().__init__()
+        self.save_hyperparameters()
+        self.model = RobertaModel.from_pretrained("roberta-base", add_pooling_layer=False)
+        self.dropout = nn.Dropout(0.3)
+        self.classifier = nn.Linear(self.model.config.hidden_size, num_labels)
+
+        if class_weights is not None:
+            weights = torch.tensor(class_weights, dtype=torch.float32)
+            self.loss_fn = nn.CrossEntropyLoss(weight=weights)
+        else:
+            self.loss_fn = nn.CrossEntropyLoss()
+
+    def forward(self, input_ids, attention_mask):
+        outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
+        cls_output = outputs.last_hidden_state[:, 0, :]
+        cls_output = self.dropout(cls_output)
+        return self.classifier(cls_output)
+
+    def training_step(self, batch, batch_idx):
+        input_ids, attention_mask, labels = batch["input_ids"], batch["attention_mask"], batch["label"]
+        logits = self(input_ids, attention_mask)
+        loss = self.loss_fn(logits, labels)
+        preds = torch.argmax(logits, dim=1)
+        acc = accuracy_score(labels.cpu(), preds.cpu())
+        self.log("train_loss", loss, prog_bar=True)
+        self.log("train_acc", acc, prog_bar=True)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        input_ids, attention_mask, labels = batch["input_ids"], batch["attention_mask"], batch["label"]
+        logits = self(input_ids, attention_mask)
+        loss = self.loss_fn(logits, labels)
+        preds = torch.argmax(logits, dim=1)
+        acc = accuracy_score(labels.cpu(), preds.cpu())
+        f1 = f1_score(labels.cpu(), preds.cpu(), average='weighted')
+        self.log("val_loss", loss, prog_bar=True)
+        self.log("val_acc", acc, prog_bar=True)
+        self.log("val_f1", f1, prog_bar=True, sync_dist=True)
+
+    def configure_optimizers(self):
+        return torch.optim.AdamW(self.parameters(), lr=self.hparams.lr)
+
+
+if __name__ == "__main__":
+    df = pd.read_csv("data_cleaned2.csv")
+
+    class_counts = df["label"].value_counts().sort_index().tolist()
+    class_weights = 1.0 / np.array(class_counts)
+    class_weights = class_weights / class_weights.sum()
+
+    train_df = df.sample(frac=0.8, random_state=42)
+    val_df = df.drop(train_df.index)
+
+    tokenizer = RobertaTokenizer.from_pretrained("roberta-base")
+
+    def tokenize(batch):
+        return tokenizer(batch["text"], truncation=True, padding="max_length", max_length=64)
+
+    train_dataset = Dataset.from_pandas(train_df).map(tokenize, batched=True)
+    val_dataset = Dataset.from_pandas(val_df).map(tokenize, batched=True)
+
+    train_dataset.set_format("torch", columns=["input_ids", "attention_mask", "label"])
+    val_dataset.set_format("torch", columns=["input_ids", "attention_mask", "label"])
+
+    train_loader = DataLoader(train_dataset, batch_size=16, num_workers=8, shuffle=True)
+    val_loader = DataLoader(val_dataset, batch_size=16, num_workers=8)
+
+    checkpoint_callback = ModelCheckpoint(
+        dirpath="checkpoints/",
+        filename="roberta-priority-{epoch:02d}-{val_f1:.2f}",
+        save_top_k=3,
+        monitor="val_f1",
+        mode="max",
+        save_weights_only=True,
+        every_n_epochs=1
+    )
+
+    early_stopping = EarlyStopping(
+        monitor="val_f1",
+        patience=2,
+        mode="max",
+        verbose=True,
+    )
+
+    trainer_kwargs = dict(
+        accelerator="gpu",
+        devices=2,
+        strategy=DDPStrategy(find_unused_parameters=True),
+        max_epochs=20,
+        precision=16,
+        log_every_n_steps=10,
+        callbacks=[checkpoint_callback, early_stopping],
+    )
+
+    trainer = pl.Trainer(**trainer_kwargs)
+    model = RoBERTaClassifier(class_weights=class_weights)
+
+    trainer.fit(model, train_loader, val_loader)

app.py

@@ -0,0 +1,30 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from classifier.Bug_Priority import get_model
+from fastapi.responses import PlainTextResponse
+
+app = FastAPI()
+model = get_model()
+
+# Request body schema
+class Issue(BaseModel):
+    text: str
+
+PRIORITY_LABELS = ["Low", "Medium", "High", "Critical"]
+
+@app.post("/predict")
+async def predict(issue: Issue):
+    probs, predicted_label = model.predict(issue.text)
+    return {
+        "input_text": issue.text,
+        "predicted_label": predicted_label,
+        "label_index": PRIORITY_LABELS.index(predicted_label),
+        "confidence_scores": {
+            PRIORITY_LABELS[i]: f"{probs[i]:.4f}" for i in range(len(PRIORITY_LABELS))
+        }
+    }
+
+@app.get("/", response_class=PlainTextResponse)
+def root():
+    with open("README.md", "r") as f:
+        return f.read()

assets/roberta-priority-epoch=06-val_f1=0.72.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7b19ddbb19ce104a6ac94f8a7ee103330dde7a1b94a113c17ff7692a6243a40
+size 496315810

classifier/Bug_Priority.py

@@ -0,0 +1,55 @@
+from transformers import RobertaTokenizer, RobertaForSequenceClassification
+import torch
+import numpy as np
+
+class Model:
+    def __init__(self, model_weights):
+        self.tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
+        self.model = RobertaForSequenceClassification.from_pretrained('roberta-base', num_labels=4)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        # ✅ Load Lightning checkpoint
+        checkpoint = torch.load(model_weights, map_location=self.device)
+        state_dict = checkpoint.get("state_dict", checkpoint)
+
+        # ✅ Remove 'model.' prefix used by LightningModule
+        filtered_state_dict = {
+            k.replace("model.", ""): v
+            for k, v in state_dict.items()
+            if k.startswith("model.")
+        }
+
+        # ✅ Load weights into Hugging Face model
+        self.model.load_state_dict(filtered_state_dict, strict=False)
+
+        self.currepoch = checkpoint.get("epoch", "N/A")
+        self.loss = checkpoint.get("loss", "N/A")
+
+        print(f"✅ Loaded model state — Epoch: {self.currepoch}, Loss: {self.loss}")
+
+        self.model.to(self.device)
+        self.model.eval()
+
+        self.labels = ["Low", "Medium", "High", "Critical"]
+
+    def predict(self, text):
+        inputs = self.tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)
+        inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=-1)
+        predicted_label = self.labels[torch.argmax(probs).item()]
+        return probs[0].tolist(), predicted_label
+
+# Singleton instance
+model_instance = None
+model_weights = "assets/roberta-priority-epoch=06-val_f1=0.72.ckpt"  # Update path if needed
+
+def get_model():
+    global model_instance
+    if model_instance is None:
+        model_instance = Model(model_weights)
+    return model_instance

datapreprocessing.ipynb

@@ -0,0 +1,513 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "albert_multiclass.ipynb             data.csv\n",
+      "albert_sentiment_checkpoint_100.pt  datapreprocessing.ipynb\n",
+      "albert_sentiment_checkpoint_96.pt   deberta.py\n",
+      "albert_sentiment_checkpoint_97.pt   evaludate_roberta.py\n",
+      "albert_sentiment_checkpoint_98.pt   \u001b[0m\u001b[01;34mlightning_logs\u001b[0m/\n",
+      "albert_sentiment_checkpoint_99.pt   model.py\n",
+      "\u001b[01;34mbug_priority_multiclass\u001b[0m/            newdata.csv\n",
+      "bug_priority_multiclass.zip         preProcessed.csv\n",
+      "\u001b[01;34mcheckpoints\u001b[0m/                        Pri_Android_A11y.xlsx\n",
+      "data_cleaned2.csv                   \u001b[01;34m__pycache__\u001b[0m/\n",
+      "data_cleaned.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "ls"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df=pd.read_csv('./data_cleaned2.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>text</th>\n",
+       "      <th>labels</th>\n",
+       "      <th>textlen</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>VoiceOver skips over text in paragraphs which ...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>AXEnhancedUserInterface breaks window managers...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>14</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>mac voiceover screen reader</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>when using firefox on mac with voiceover you c...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Children of HTML label element are read 3 time...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  labels  textlen\n",
+       "0  VoiceOver skips over text in paragraphs which ...       2       12\n",
+       "1  AXEnhancedUserInterface breaks window managers...       2       14\n",
+       "2                        mac voiceover screen reader       3        4\n",
+       "3  when using firefox on mac with voiceover you c...       2       13\n",
+       "4  Children of HTML label element are read 3 time...       2       11"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.rename(columns={'Kevin_Pri':'label','Summary':'text'}, inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>text</th>\n",
+       "      <th>labels</th>\n",
+       "      <th>textlen</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>VoiceOver skips over text in paragraphs which ...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>AXEnhancedUserInterface breaks window managers...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>14</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>mac voiceover screen reader</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>when using firefox on mac with voiceover you c...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Children of HTML label element are read 3 time...</td>\n",
+       "      <td>2</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  labels  textlen\n",
+       "0  VoiceOver skips over text in paragraphs which ...       2       12\n",
+       "1  AXEnhancedUserInterface breaks window managers...       2       14\n",
+       "2                        mac voiceover screen reader       3        4\n",
+       "3  when using firefox on mac with voiceover you c...       2       13\n",
+       "4  Children of HTML label element are read 3 time...       2       11"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df['textlen']= df['text'].apply(lambda x: len(x.split()))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "KeyError",
+     "evalue": "'label'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
+      "File \u001b[0;32m~/miniconda3/envs/albert/lib/python3.12/site-packages/pandas/core/indexes/base.py:3805\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   3804\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 3805\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   3806\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n",
+      "File \u001b[0;32mindex.pyx:167\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mindex.pyx:196\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7081\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7089\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
+      "\u001b[0;31mKeyError\u001b[0m: 'label'",
+      "\nThe above exception was the direct cause of the following exception:\n",
+      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabel\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;241m=\u001b[39m \u001b[43mdf\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mlabel\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m\n",
+      "File \u001b[0;32m~/miniconda3/envs/albert/lib/python3.12/site-packages/pandas/core/frame.py:4102\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   4100\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m   4101\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[0;32m-> 4102\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   4103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[1;32m   4104\u001b[0m     indexer \u001b[38;5;241m=\u001b[39m [indexer]\n",
+      "File \u001b[0;32m~/miniconda3/envs/albert/lib/python3.12/site-packages/pandas/core/indexes/base.py:3812\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   3807\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(casted_key, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m   3808\u001b[0m         \u001b[38;5;28misinstance\u001b[39m(casted_key, abc\u001b[38;5;241m.\u001b[39mIterable)\n\u001b[1;32m   3809\u001b[0m         \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(x, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m casted_key)\n\u001b[1;32m   3810\u001b[0m     ):\n\u001b[1;32m   3811\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n\u001b[0;32m-> 3812\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[1;32m   3813\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m   3814\u001b[0m     \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m   3815\u001b[0m     \u001b[38;5;66;03m#  InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m   3816\u001b[0m     \u001b[38;5;66;03m#  the TypeError.\u001b[39;00m\n\u001b[1;32m   3817\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_indexing_error(key)\n",
+      "\u001b[0;31mKeyError\u001b[0m: 'label'"
+     ]
+    }
+   ],
+   "source": [
+    "df['label']= df['label']-1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df['textlen'].hist(bins=50)\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    5060.00000\n",
+       "mean        9.63083\n",
+       "std         4.25744\n",
+       "min         1.00000\n",
+       "25%         7.00000\n",
+       "50%         9.00000\n",
+       "75%        12.00000\n",
+       "max        43.00000\n",
+       "Name: textlen, dtype: float64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df['textlen'].describe()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "labels\n",
+       "1    2035\n",
+       "2    1465\n",
+       "0     804\n",
+       "3     756\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df['labels'].value_counts().plot(kind='bar')\n",
+    "plt.show()\n",
+    "df['labels'].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df[df['textlen'] >= 10]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: >"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df['textlen'].hist(bins=50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.to_csv('data_cleaned.csv', index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>label</th>\n",
+       "      <th>text</th>\n",
+       "      <th>textlen</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>focus should go to the web content after acti...</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0</td>\n",
+       "      <td>Aria-owns crash if the ID of an owned element ...</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>1</td>\n",
+       "      <td>Regression in presubmit.py checking of accessi...</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>2</td>\n",
+       "      <td>Label names when they embed a control are not ...</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>2</td>\n",
+       "      <td>TalkBack doesn't read the text of the popup di...</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    label                                               text  textlen\n",
+       "1       2   focus should go to the web content after acti...       11\n",
+       "8       0  Aria-owns crash if the ID of an owned element ...       10\n",
+       "9       1  Regression in presubmit.py checking of accessi...       11\n",
+       "14      2  Label names when they embed a control are not ...       10\n",
+       "15      2  TalkBack doesn't read the text of the popup di...       12"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "albert",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,33 @@
+anyio==3.5.0
+asgiref==3.5.0
+certifi==2021.10.8
+charset-normalizer==2.0.12
+click==8.0.4
+colorama==0.4.4
+fastapi==0.75.0
+filelock==3.6.0
+gunicorn==20.1.0
+h11==0.13.0
+huggingface-hub==0.4.0
+idna==3.3
+joblib==1.1.0
+numpy==1.22.3
+packaging==21.3
+pydantic==1.9.0
+pyparsing==3.0.7
+PyYAML==6.0
+regex==2022.3.15
+requests==2.27.1
+sacremoses==0.0.49
+sentencepiece==0.1.96
+six==1.16.0
+sniffio==1.2.0
+starlette==0.17.1
+tokenizers==0.11.6
+--find-links https://download.pytorch.org/whl/torch_stable.html
+torch==1.11.0+cpu
+tqdm==4.63.0
+transformers==4.17.0
+typing_extensions==4.1.1
+urllib3==1.26.8
+uvicorn==0.17.6