Upload 5 files

app.py

@@ -0,0 +1,43 @@
+import streamlit as st
+import tempfile
+import whisper
+from langdetect import detect
+
+st.set_page_config(page_title="ILR-Based Multilingual Language Assessment App")
+st.title("ILR-Based Multilingual Language Assessment App")
+st.write("Upload speech to assess your ILR level with transcription and feedback.")
+
+# File uploader
+uploaded_file = st.file_uploader("Upload Audio File (.wav, .mp3, .m4a)", type=["wav", "mp3", "m4a"])
+
+if uploaded_file is not None:
+    # Save uploaded file to a temporary location
+    with tempfile.NamedTemporaryFile(delete=False, suffix=uploaded_file.name) as tmp:
+        tmp.write(uploaded_file.read())
+        tmp_path = tmp.name
+
+    # Load whisper model
+    model = whisper.load_model("base")
+    
+    # Transcribe audio
+    try:
+        result = model.transcribe(tmp_path)
+        transcription = result["text"]
+
+        # Display audio and transcription
+        st.audio(uploaded_file, format="audio/m4a")
+        st.subheader("Transcription")
+        st.write(transcription)
+
+        # Detect language
+        language = detect(transcription)
+        st.write(f"**Detected Language**: {language}")
+
+        # Placeholder for ILR scoring logic
+        st.subheader("ILR Level Feedback")
+        st.write("🧠 *Analyzing speech features...*")
+        st.success("Estimated ILR Level: **2+**")
+        st.info("To reach ILR Level 3: Improve connected speech, accuracy, and topic development.")
+
+    except Exception as e:
+        st.error(f"Error processing audio: {e}")

evaluate.py

@@ -0,0 +1,42 @@
+import argparse
+import numpy as np
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+parser = argparse.ArgumentParser(description="Evaluate a fine-tuned DistilBERT model.")
+parser.add_argument("--task", type=str, required=True,
+                    choices=["classification", "nli"],
+                    help="The evaluation task.")
+parser.add_argument("--model_dir", type=str, required=True,
+                    help="Path to your saved model directory.")
+args = parser.parse_args()
+
+tokenizer = AutoTokenizer.from_pretrained(args.model_dir)
+model = AutoModelForSequenceClassification.from_pretrained(args.model_dir)
+
+if args.task == "classification":
+    dataset = load_dataset("glue", "sst2", split="validation").select(range(200))
+    dataset = dataset.map(lambda e: tokenizer(e["sentence"], truncation=True, padding="max_length"), batched=True)
+    labels = dataset["label"]
+elif args.task == "nli":
+    dataset = load_dataset("snli", split="validation")
+    dataset = dataset.filter(lambda x: x["label"] != -1).select(range(200))
+    dataset = dataset.map(lambda e: tokenizer(e["premise"], e["hypothesis"], truncation=True, padding="max_length"), batched=True)
+    labels = dataset["label"]
+
+dataset.set_format(type="torch", columns=["input_ids", "attention_mask"])
+loader = torch.utils.data.DataLoader(dataset, batch_size=8)
+
+all_preds = []
+
+model.eval()
+with torch.no_grad():
+    for batch in loader:
+        outputs = model(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"])
+        logits = outputs.logits
+        preds = torch.argmax(logits, dim=-1)
+        all_preds.extend(preds.cpu().numpy())
+
+accuracy = (np.array(all_preds) == np.array(labels)).mean()
+print(f"Accuracy on {args.task} validation set: {accuracy:.2%}")

inference.py

@@ -0,0 +1,32 @@
+import argparse
+import torch
+from pathlib import Path
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+def classify(text, model, tokenizer):
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    logits = outputs.logits
+    prediction = torch.argmax(logits, dim=1).item()
+    label = model.config.id2label.get(prediction, str(prediction))
+    return label
+
+parser = argparse.ArgumentParser(description="Run inference with your fine-tuned DistilBERT model.")
+parser.add_argument("--task", type=str, choices=["classification"], required=True, help="Task to run inference on.")
+parser.add_argument("--model_dir", type=str, required=True, help="Relative or absolute path to model directory.")
+parser.add_argument("--text", type=str, help="Input text to classify.")
+
+args = parser.parse_args()
+
+# Ensure the model directory is interpreted as a local folder
+model_path = Path(args.model_dir).resolve()
+
+tokenizer = AutoTokenizer.from_pretrained(model_path, local_files_only=True)
+model = AutoModelForSequenceClassification.from_pretrained(model_path, local_files_only=True)
+
+if args.task == "classification":
+    if not args.text:
+        raise ValueError("Please provide --text for classification.")
+    result = classify(args.text, model, tokenizer)
+    print(f"\nInput: {args.text}\nPrediction: {result}")

train.py

@@ -0,0 +1,50 @@
+from transformers import Trainer, TrainingArguments, AutoModelForSequenceClassification, AutoTokenizer
+from datasets import load_dataset
+import numpy as np
+import evaluate
+
+# Load dataset
+dataset = load_dataset("imdb")
+tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
+
+# Tokenization function
+def tokenize_function(example):
+    return tokenizer(example["text"], padding="max_length", truncation=True)
+
+# Tokenize dataset
+tokenized_datasets = dataset.map(tokenize_function, batched=True)
+
+# Load model
+model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=2)
+
+# Load accuracy metric
+accuracy = evaluate.load("accuracy")
+
+# Compute metrics function
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    return accuracy.compute(predictions=predictions, references=labels)
+
+# Define training arguments
+training_args = TrainingArguments(
+    output_dir="./results",
+    evaluation_strategy="epoch",
+    learning_rate=2e-5,
+    per_device_train_batch_size=8,
+    per_device_eval_batch_size=8,
+    num_train_epochs=1,
+    weight_decay=0.01,
+)
+
+# Initialize Trainer
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_datasets["train"].shuffle(seed=42).select(range(2000)),
+    eval_dataset=tokenized_datasets["test"].shuffle(seed=42).select(range(1000)),
+    compute_metrics=compute_metrics,
+)
+
+# Train model
+trainer.train()