monorepo

app.py

@@ -1,30 +1,32 @@
 import gradio as gr
 import pandas as pd
-import requests
 from pathlib import Path
-from datetime import datetime
 import logging
-import os
+from datetime import datetime
+import sys
+import uuid
+from typing import Dict, Any
+
+# Add parent directory to path to import main
+sys.path.append(str(Path(__file__).parent))
+from main import (
+    StorageManager, 
+    EvaluationRequest,
+    evaluate_model,
+    PATHS
+)
 
 logging.basicConfig(level=logging.INFO)
 
-QUEUE_SPACE_URL = os.getenv(
-    'QUEUE_SPACE_URL', 
-    'https://koellabs-ipa-transcription-en-queue.hf.space/api'
-).rstrip('/')
+# Initialize storage manager
+storage_manager = StorageManager(PATHS)
 
 def load_leaderboard_data():
     try:
-        response = requests.get(f"{QUEUE_SPACE_URL}/leaderboard", timeout=10)
-        logging.info(f"Leaderboard request URL: {QUEUE_SPACE_URL}/leaderboard")
-        response.raise_for_status()
-        return pd.DataFrame(response.json())
-    except requests.RequestException as e:
+        return pd.DataFrame(storage_manager.load('leaderboard'))
+    except Exception as e:
         logging.error(f"Error loading leaderboard: {e}")
-        try:
-            return pd.read_json(Path("fake_queue/leaderboard.json"))
-        except:
-            return pd.DataFrame()
+        return pd.DataFrame()
 
 def format_leaderboard_df(df):
     if df.empty:
@@ -43,43 +45,85 @@ def format_leaderboard_df(df):
 def create_html_table(df):
     return df.to_html(escape=False, index=False, classes="styled-table")
 
-def submit_evaluation(model_name, submission_name, github_url):
+def submit_evaluation(model_name: str, submission_name: str, github_url: str) -> str:
     if not model_name or not submission_name:
         return "⚠️ Please provide both model name and submission name."
     
-    request_data = {
-        "transcription_model": model_name,
-        "subset": "test",
-        "submission_name": submission_name,
-        "github_url": github_url if github_url else None
-    }
-    
     try:
-        response = requests.post(
-            f"{QUEUE_SPACE_URL}/evaluate", 
-            json=request_data,
-            timeout=10
+        # Generate a task ID
+        task_id = str(uuid.uuid4())
+        
+        # Create evaluation request
+        request = EvaluationRequest(
+            transcription_model=model_name,
+            submission_name=submission_name,
+            github_url=github_url if github_url else None,
+            subset="test"
         )
-        logging.info(f"Submit request URL: {QUEUE_SPACE_URL}/evaluate")
-        response.raise_for_status()
-        task_id = response.json()["task_id"]
+        
+        # Create task entry
+        task = {
+            "id": task_id,
+            "model": model_name,
+            "subset": "test",
+            "submission_name": submission_name,
+            "github_url": github_url,
+            "status": "queued",
+            "submitted_at": datetime.now().isoformat()
+        }
+        
+        # Save task
+        tasks = storage_manager.load('tasks')
+        tasks.append(task)
+        storage_manager.save('tasks', tasks)
+        
+        # Start evaluation in background
+        import asyncio
+        asyncio.run(evaluate_model(task_id, request))
+        
         return f"✅ Evaluation submitted successfully! Task ID: {task_id}"
-    except requests.RequestException as e:
+    except Exception as e:
         return f"❌ Error: {str(e)}"
 
-def check_task_status(task_id):
-    if not task_id:
-        return "Please enter a task ID"
+def check_status(query: str) -> Dict[str, Any]:
+    if not query:
+        return {"error": "Please enter a model name or task ID"}
+    
     try:
-        response = requests.get(
-            f"{QUEUE_SPACE_URL}/tasks/{task_id}",
-            timeout=10
-        )
-        logging.info(f"Status check URL: {QUEUE_SPACE_URL}/tasks/{task_id}")
-        response.raise_for_status()
-        return response.json()
-    except requests.RequestException as e:
-        return f"Error checking status: {str(e)}"
+        results = storage_manager.load('results')
+        tasks = storage_manager.load('tasks')
+        
+        # First try to find by task ID
+        result = next((r for r in results if r["task_id"] == query), None)
+        task = next((t for t in tasks if t["id"] == query), None)
+        
+        # If not found, try to find by model name
+        if not result:
+            result = next((r for r in results if r["model"] == query), None)
+        if not task:
+            task = next((t for t in tasks if t["model"] == query), None)
+        
+        if result:
+            # If we found results, return them
+            return {
+                "status": "completed",
+                "model": result["model"],
+                "subset": result["subset"],
+                "num_files": result["num_files"],
+                "average_per": result["average_per"],
+                "average_pwed": result["average_pwed"],
+                "detailed_results": result["detailed_results"],
+                "timestamp": result["timestamp"]
+            }
+        elif task:
+            # If we only found task status, return that
+            return task
+        else:
+            return {"error": f"No results found for '{query}'"}
+            
+    except Exception as e:
+        logging.error(f"Error checking status: {e}")
+        return {"error": f"Error checking status: {str(e)}"}
 
 with gr.Blocks(css="""
     .styled-table {
@@ -127,19 +171,16 @@ with gr.Blocks(css="""
                 outputs=result
             )
         
-        with gr.TabItem("📊 Task Status"):
-            task_id = gr.Textbox(label="Task ID")
+        with gr.TabItem("📊 Model Status"):
+            query = gr.Textbox(label="Model Name or Task ID", placeholder="Enter model name (e.g., facebook/wav2vec2-lv-60-espeak-cv-ft)")
             status_btn = gr.Button("Check Status")
             status_output = gr.JSON(label="Status")
             
-            # Use a simple function wrapper to ensure direct HTTP request
-            def check_status_wrapper(task_id):
-                return check_task_status(task_id)
-            
             status_btn.click(
-                fn=check_status_wrapper,
-                inputs=task_id,
+                fn=check_status,
+                inputs=query,
                 outputs=status_output
             )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()

fake_queue/leaderboard.json

@@ -1,7 +1,7 @@
 [
     {
         "submission_id": "8e6a3a00-59fa-4a24-861d-a132a8212658",
-        "submission_name": "facebook espeak",
+        "submission_name": "fake-facebook espeak",
         "model": "facebook/wav2vec2-lv-60-espeak-cv-ft",
         "average_per": 0.33667301260691423,
         "average_pwed": 0.1276725657099669,

main.py

@@ -0,0 +1,499 @@
+import gradio as gr
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from pydantic import BaseModel, HttpUrl
+from typing import List, Optional, Dict
+import torch
+import torchaudio
+from transformers import AutoProcessor, AutoModelForCTC
+import evaluate
+import zipfile
+from datetime import datetime
+import json
+import uuid
+import os
+from pathlib import Path
+
+app = FastAPI(title="TIMIT Phoneme Transcription Leaderboard")
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=lambda x: x,
+    inputs=gr.Textbox(visible=False),
+    outputs=gr.Textbox(visible=False),
+    title="TIMIT Phoneme Transcription Queue",
+    description="API endpoints are available at /api/leaderboard, /api/evaluate, and /api/tasks/{task_id}"
+)
+
+
+# Get absolute path - Updated for HF Spaces
+CURRENT_DIR = Path(__file__).parent.absolute()
+
+# Constants - Updated for HF Spaces environment
+TIMIT_PATH = CURRENT_DIR / ".data" / "TIMIT.zip" # Move TIMIT.zip to root of space
+QUEUE_DIR = CURRENT_DIR / "queue"
+PATHS = {
+    'tasks': QUEUE_DIR / "tasks.json",
+    'results': QUEUE_DIR / "results.json",
+    'leaderboard': QUEUE_DIR / "leaderboard.json"
+}
+
+# Initialize evaluation metric
+phone_errors = evaluate.load("ginic/phone_errors")
+
+class TimitDataManager:
+    """Handles all TIMIT dataset operations"""
+    
+    # TIMIT to IPA mapping with direct simplifications
+    TIMIT_TO_IPA = {
+        # Vowels (simplified)
+        'aa': 'ɑ',
+        'ae': 'æ',
+        'ah': 'ʌ',
+        'ao': 'ɔ',
+        'aw': 'aʊ',
+        'ay': 'aɪ',
+        'eh': 'ɛ',
+        'er': 'ɹ',      # Simplified from 'ɝ'
+        'ey': 'eɪ',
+        'ih': 'ɪ',
+        'ix': 'i',      # Simplified from 'ɨ'
+        'iy': 'i',
+        'ow': 'oʊ',
+        'oy': 'ɔɪ',
+        'uh': 'ʊ',
+        'uw': 'u',
+        'ux': 'u',      # Simplified from 'ʉ'
+        'ax': 'ə',
+        'ax-h': 'ə',    # Simplified from 'ə̥'
+        'axr': 'ɹ',     # Simplified from 'ɚ'
+        
+        # Consonants
+        'b': '',        
+        'bcl': 'b',
+        'd': '',
+        'dcl': 'd',
+        'g': '',
+        'gcl': 'g',
+        'p': '',
+        'pcl': 'p',
+        't': '',
+        'tcl': 't',
+        'k': '',
+        'kcl': 'k',
+        'dx': 'ɾ',
+        'q': 'ʔ',
+        
+        # Fricatives
+        'jh': 'dʒ',
+        'ch': 'tʃ',
+        's': 's',
+        'sh': 'ʃ',
+        'z': 'z',
+        'zh': 'ʒ',
+        'f': 'f',
+        'th': 'θ',
+        'v': 'v',
+        'dh': 'ð',
+        'hh': 'h',
+        'hv': 'h',      # Simplified from 'ɦ'
+        
+        # Nasals (simplified)
+        'm': 'm',
+        'n': 'n',
+        'ng': 'ŋ',
+        'em': 'm',      # Simplified from 'm̩'
+        'en': 'n',      # Simplified from 'n̩'
+        'eng': 'ŋ',     # Simplified from 'ŋ̍'
+        'nx': 'ɾ',      # Simplified from 'ɾ̃'
+        
+        # Semivowels and Glides
+        'l': 'l',
+        'r': 'ɹ',
+        'w': 'w',
+        'wh': 'ʍ',
+        'y': 'j',
+        'el': 'l',      # Simplified from 'l̩'
+        
+        # Special
+        'epi': '',      # Remove epenthetic silence
+        'h#': '',       # Remove start/end silence
+        'pau': '',      # Remove pause
+    }
+
+    
+    def __init__(self, timit_path: Path):
+        self.timit_path = timit_path
+        self._zip = None
+        print(f"TimitDataManager initialized with path: {self.timit_path.absolute()}")
+        if not self.timit_path.exists():
+            raise FileNotFoundError(f"TIMIT dataset not found at {self.timit_path.absolute()}")
+        print("TIMIT dataset file exists!")
+    
+    @property
+    def zip(self):
+        if not self._zip:
+            try:
+                self._zip = zipfile.ZipFile(self.timit_path, 'r')
+                print("Successfully opened TIMIT zip file")
+            except FileNotFoundError:
+                raise FileNotFoundError(f"TIMIT dataset not found at {self.timit_path}")
+        return self._zip
+    
+    def get_file_list(self, subset: str) -> List[str]:
+        """Get list of WAV files for given subset"""
+        files = [f for f in self.zip.namelist() 
+                if f.endswith('.WAV') and subset.lower() in f.lower()]
+        print(f"Found {len(files)} WAV files in {subset} subset")
+        if files:
+            print("First 3 files:", files[:3])
+        return files
+    
+    def load_audio(self, filename: str) -> torch.Tensor:
+        """Load and preprocess audio file"""
+        with self.zip.open(filename) as wav_file:
+            waveform, sample_rate = torchaudio.load(wav_file)
+            
+            if waveform.shape[0] > 1:
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+            
+            if sample_rate != 16000:
+                waveform = torchaudio.transforms.Resample(sample_rate, 16000)(waveform)
+            
+            waveform = (waveform - waveform.mean()) / (waveform.std() + 1e-7)
+            
+            if waveform.dim() == 1:
+                waveform = waveform.unsqueeze(0)
+                
+            return waveform
+    
+    def get_phonemes(self, filename: str) -> str:
+        """Get cleaned phoneme sequence from PHN file and convert to IPA"""
+        phn_file = filename.replace('.WAV', '.PHN')
+        with self.zip.open(phn_file) as f:
+            phonemes = []
+            for line in f.read().decode('utf-8').splitlines():
+                if line.strip():
+                    _, _, phone = line.split()
+                    phone = self.remove_stress_mark(phone)
+                    # Convert to IPA instead of using simplify_timit
+                    ipa = self.TIMIT_TO_IPA.get(phone.lower(), '')
+                    if ipa:
+                        phonemes.append(ipa)
+            return ''.join(phonemes)  # Join without spaces for IPA
+    
+    def simplify_timit(self, phoneme: str) -> str:
+        """Apply substitutions to simplify TIMIT phonemes"""
+        return self.PHONE_SUBSTITUTIONS.get(phoneme, phoneme)
+    
+    def remove_stress_mark(self, text: str) -> str:
+        """Removes the combining double inverted breve (͡) from text"""
+        if not isinstance(text, str):
+            raise TypeError("Input must be string")
+        return text.replace('͡', '')
+
+class ModelManager:
+    """Handles model loading and inference"""
+    
+    def __init__(self):
+        self.models = {}
+        self.processors = {}
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.batch_size = 32  # Added batch size parameter
+    
+    def get_model_and_processor(self, model_name: str):
+        """Get or load model and processor"""
+        if model_name not in self.models:
+            print("Loading processor with phoneme tokenizer...")
+            processor = AutoProcessor.from_pretrained(model_name)
+            
+            print("Loading model...", {model_name})
+            model = AutoModelForCTC.from_pretrained(model_name).to(self.device)
+            
+            self.models[model_name] = model
+            self.processors[model_name] = processor
+        
+        return self.models[model_name], self.processors[model_name]
+    
+    def transcribe(self, audio_list: List[torch.Tensor], model_name: str) -> List[str]:
+        """Transcribe a batch of audio using specified model"""
+        model, processor = self.get_model_and_processor(model_name)
+        if not model or not processor:
+            raise Exception("Model and processor not loaded")
+        
+        # Process audio in batches
+        all_predictions = []
+        for i in range(0, len(audio_list), self.batch_size):
+            batch_audio = audio_list[i:i + self.batch_size]
+            
+            # Pad sequence within batch
+            max_length = max(audio.shape[-1] for audio in batch_audio)
+            padded_audio = torch.zeros((len(batch_audio), 1, max_length))
+            attention_mask = torch.zeros((len(batch_audio), max_length))
+            
+            for j, audio in enumerate(batch_audio):
+                padded_audio[j, :, :audio.shape[-1]] = audio
+                attention_mask[j, :audio.shape[-1]] = 1
+            
+            # Process batch
+            inputs = processor(
+                padded_audio.squeeze(1).numpy(),
+                sampling_rate=16000,
+                return_tensors="pt",
+                padding=True
+            )
+            
+            input_values = inputs.input_values.to(self.device)
+            attention_mask = inputs.get("attention_mask", attention_mask).to(self.device)
+            
+            with torch.no_grad():
+                outputs = model(
+                    input_values=input_values,
+                    attention_mask=attention_mask
+                )
+                logits = outputs.logits
+                predicted_ids = torch.argmax(logits, dim=-1)
+                predictions = processor.batch_decode(predicted_ids, skip_special_tokens=True)
+                predictions = [pred.replace(' ', '') for pred in predictions]
+                all_predictions.extend(predictions)
+        
+        return all_predictions
+
+class StorageManager:
+    """Handles all JSON storage operations"""
+    
+    def __init__(self, paths: Dict[str, Path]):
+        self.paths = paths
+        self._ensure_directories()
+    
+    def _ensure_directories(self):
+        """Ensure all necessary directories and files exist"""
+        for path in self.paths.values():
+            path.parent.mkdir(parents=True, exist_ok=True)
+            if not path.exists():
+                path.write_text('[]')
+    
+    def load(self, key: str) -> List:
+        """Load JSON file"""
+        return json.loads(self.paths[key].read_text())
+    
+    def save(self, key: str, data: List):
+        """Save data to JSON file"""
+        self.paths[key].write_text(json.dumps(data, indent=4, default=str, ensure_ascii=False))
+    
+    def update_task(self, task_id: str, updates: Dict):
+        """Update specific task with new data"""
+        tasks = self.load('tasks')
+        for task in tasks:
+            if task['id'] == task_id:
+                task.update(updates)
+                break
+        self.save('tasks', tasks)
+
+class EvaluationRequest(BaseModel):
+    """Request model for TIMIT evaluation"""
+    transcription_model: str
+    subset: str = "test"
+    max_samples: Optional[int] = None
+    submission_name: str
+    github_url: Optional[str] = None
+
+# Initialize managers
+timit_manager = TimitDataManager(TIMIT_PATH)
+model_manager = ModelManager()
+storage_manager = StorageManager(PATHS)
+
+async def evaluate_model(task_id: str, request: EvaluationRequest):
+    """Background task to evaluate model on TIMIT"""
+    try:
+        storage_manager.update_task(task_id, {"status": "processing"})
+        
+        files = timit_manager.get_file_list(request.subset)
+        if request.max_samples:
+            files = files[:request.max_samples]
+        
+        results = []
+        total_per = total_pwed = 0
+        
+        # Process files in batches
+        batch_size = model_manager.batch_size
+        for i in range(0, len(files), batch_size):
+            batch_files = files[i:i + batch_size]
+            
+            # Load batch audio and ground truth
+            batch_audio = []
+            batch_ground_truth = []
+            for wav_file in batch_files:
+                audio = timit_manager.load_audio(wav_file)
+                ground_truth = timit_manager.get_phonemes(wav_file)
+                batch_audio.append(audio)
+                batch_ground_truth.append(ground_truth)
+            
+            # Get predictions for batch
+            predictions = model_manager.transcribe(batch_audio, request.transcription_model)
+            
+            # Calculate metrics for each file in batch
+            for j, (wav_file, prediction, ground_truth) in enumerate(zip(batch_files, predictions, batch_ground_truth)):
+                # Convert Unicode to readable format
+                #prediction_str = repr(prediction)[1:-1]  # Remove quotes but keep escaped unicode
+                
+                metrics = phone_errors.compute(
+                    predictions=[prediction],
+                    references=[ground_truth],
+                    is_normalize_pfer=True
+                )
+                
+                per = metrics['phone_error_rates'][0]
+                pwed = metrics['phone_feature_error_rates'][0]
+                
+                results.append({
+                    "file": wav_file,
+                    "ground_truth": ground_truth,
+                    "prediction": prediction,
+                    "per": per,
+                    "pwed": pwed
+                })
+                
+                total_per += per
+                total_pwed += pwed
+        
+        if not results:
+            raise Exception("No files were successfully processed")
+        
+        avg_per = total_per / len(results)
+        avg_pwed = total_pwed / len(results)
+        
+        result = {
+            "task_id": task_id,
+            "model": request.transcription_model,
+            "subset": request.subset,
+            "num_files": len(results),
+            "average_per": avg_per,
+            "average_pwed": avg_pwed,
+            "detailed_results": results[:5],
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        # Save results
+        print("Saving results...")
+        current_results = storage_manager.load('results')
+        current_results.append(result)
+        storage_manager.save('results', current_results)
+        
+        # Update leaderboard
+        print("Updating leaderboard...")
+        leaderboard = storage_manager.load('leaderboard')
+        entry = next((e for e in leaderboard 
+                     if e["submission_name"] == request.submission_name), None)
+        
+        if entry:
+            # Simply update with new scores
+            entry.update({
+                "average_per": avg_per,
+                "average_pwed": avg_pwed,
+                "model": request.transcription_model,
+                "subset": request.subset,
+                "github_url": request.github_url,
+                "submission_date": datetime.now().isoformat()
+            })
+        else:
+            leaderboard.append({
+                "submission_id": str(uuid.uuid4()),
+                "submission_name": request.submission_name,
+                "model": request.transcription_model,
+                "average_per": avg_per,
+                "average_pwed": avg_pwed,
+                "subset": request.subset,
+                "github_url": request.github_url,
+                "submission_date": datetime.now().isoformat()
+            })
+        
+        storage_manager.save('leaderboard', leaderboard)
+        storage_manager.update_task(task_id, {"status": "completed"})
+        print("Evaluation completed successfully")
+        
+    except Exception as e:
+        error_msg = f"Evaluation failed: {str(e)}"
+        print(error_msg)
+        storage_manager.update_task(task_id, {
+            "status": "failed",
+            "error": error_msg
+        })
+
+# Initialize managers
+def init_directories():
+    """Ensure all necessary directories exist"""
+    (CURRENT_DIR / ".data").mkdir(parents=True, exist_ok=True)
+    QUEUE_DIR.mkdir(parents=True, exist_ok=True)
+    
+    for path in PATHS.values():
+        if not path.exists():
+            path.write_text('[]')
+
+# Initialize your managers
+init_directories()  # Your existing initialization function
+timit_manager = TimitDataManager(TIMIT_PATH)
+model_manager = ModelManager()
+storage_manager = StorageManager(PATHS)
+
+@app.get("/api/health")
+async def health_check():
+    """Simple health check endpoint"""
+    return {"status": "healthy"}
+
+@app.post("/api/evaluate")
+async def submit_evaluation(
+    request: EvaluationRequest,
+    background_tasks: BackgroundTasks
+):
+    """Submit new evaluation task"""
+    task_id = str(uuid.uuid4())
+    
+    task = {
+        "id": task_id,
+        "model": request.transcription_model,
+        "subset": request.subset,
+        "submission_name": request.submission_name,
+        "github_url": request.github_url,
+        "status": "queued",
+        "submitted_at": datetime.now().isoformat()
+    }
+    
+    tasks = storage_manager.load('tasks')
+    tasks.append(task)
+    storage_manager.save('tasks', tasks)
+    
+    background_tasks.add_task(evaluate_model, task_id, request)
+    
+    return {
+        "message": "Evaluation task submitted successfully",
+        "task_id": task_id
+    }
+
+@app.get("/api/tasks/{task_id}")
+async def get_task(task_id: str):
+    """Get specific task status"""
+    tasks = storage_manager.load('tasks')
+    task = next((t for t in tasks if t["id"] == task_id), None)
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return task
+
+@app.get("/api/leaderboard")
+async def get_leaderboard():
+    """Get current leaderboard"""
+    try:
+        leaderboard = storage_manager.load('leaderboard')
+        sorted_leaderboard = sorted(leaderboard, key=lambda x: (x["average_per"], x["average_pwed"]))
+        return sorted_leaderboard
+    except Exception as e:
+        print(f"Error loading leaderboard: {e}")
+        return []
+
+# Note: We need to mount the FastAPI app after defining all routes
+app = gr.mount_gradio_app(app, demo, path="/")
+
+# For local development
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+

queue/leaderboard.json

@@ -0,0 +1,72 @@
+[
+    {
+        "submission_id": "8e6a3a00-59fa-4a24-861d-a132a8212658",
+        "submission_name": "facebook espeak",
+        "model": "facebook/wav2vec2-lv-60-espeak-cv-ft",
+        "average_per": 0.33667301260691423,
+        "average_pwed": 0.1276725657099669,
+        "subset": "test",
+        "github_url": "https://github.com/facebookresearch/fairseq/blob/main/examples/wav2vec/README.md",
+        "submission_date": "2024-12-05T07:32:06.850230"
+    },
+    {
+        "submission_id": "70aceb68-ad86-4a83-9998-08adb27b4d5c",
+        "submission_name": "english phoneme model",
+        "model": "KoelLabs/xlsr-timit-b0",
+        "average_per": 0.12572285528714347,
+        "average_pwed": 0.06476636812791145,
+        "subset": "test",
+        "github_url": "https://github.com/KoelLabs/",
+        "submission_date": "2024-12-05T08:25:24.982477"
+    },
+    {
+        "submission_id": "80b57299-b3ab-4caf-ac4a-898c8398046e",
+        "submission_name": "speech 31 model",
+        "model": "speech31/wav2vec2-large-TIMIT-IPA",
+        "average_per": 0.4415425496841929,
+        "average_pwed": 0.18625930002594002,
+        "subset": "test",
+        "github_url": "https://huggingface.co/speech31/wav2vec2-large-TIMIT-IPA2",
+        "submission_date": "2024-12-05T09:36:14.570315"
+    },
+    {
+        "submission_id": "0cbcab0a-bd07-421f-82a0-480c9507a214",
+        "submission_name": "jubiliano model wav2vec2",
+        "model": "Jubliano/wav2vec2-large-xls-r-300m-ipa-INTERNATIONAL1.5",
+        "average_per": 0.6318471187460027,
+        "average_pwed": 0.222932144739126,
+        "subset": "test",
+        "github_url": "https://huggingface.co/Jubliano/wav2vec2-large-xls-r-300m-ipa-INTERNATIONAL1.5WithoutSpaces/tree/d5312009d8e620b183c334dfdd9ffc6b4f06f8c1",
+        "submission_date": "2024-12-05T10:17:21.334530"
+    },
+    {
+        "submission_id": "0fc29c54-3db2-46b6-aeee-c96484306751",
+        "submission_name": "xlsr 53 model",
+        "model": "facebook/wav2vec2-xlsr-53-espeak-cv-ft",
+        "average_per": 0.348845592557092,
+        "average_pwed": 0.1386742019529415,
+        "subset": "test",
+        "github_url": "https://github.com/facebookresearch/fairseq/blob/main/examples/wav2vec/README.md",
+        "submission_date": "2024-12-05T10:34:26.157054"
+    },
+    {
+        "submission_id": "a23026ec-acac-4481-9761-f9368b4b94f1",
+        "submission_name": "ginic model wav2vec2 finetuned on buckeye",
+        "model": "ginic/hyperparam_tuning_1_wav2vec2-large-xlsr-buckeye-ipa",
+        "average_per": 0.2766466385175833,
+        "average_pwed": 0.10410683992600853,
+        "subset": "test",
+        "github_url": "https://huggingface.co/ginic/vary_individuals_old_only_1_wav2vec2-large-xlsr-buckeye-ipa",
+        "submission_date": "2024-12-05T11:06:07.984825"
+    },
+    {
+        "submission_id": "e3bbf521-cc32-43a6-bf1c-5ddc6bce04ab",
+        "submission_name": "koel labs initial ",
+        "model": "KoelLabs/xlsr-timit-a0",
+        "average_per": 0.24242141955346685,
+        "average_pwed": 0.17395311976938,
+        "subset": "test",
+        "github_url": "https://github.com/KoelLabs/ML/",
+        "submission_date": "2024-12-12T16:07:25.391145"
+    }
+]

queue/results.json

@@ -0,0 +1,370 @@
+[
+    {
+        "task_id": "721b4c64-a825-42d3-bb0a-bdff9ee1ed0f",
+        "model": "facebook/wav2vec2-lv-60-espeak-cv-ft",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.33667301260691423,
+        "average_pwed": 0.1276725657099669,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʃiːhædjɚdɑːɹksuːɾɪnɡɹiːsiwɑːʃwɑːɾɚɹɑːljiː",
+                "per": 0.3939393939393939,
+                "pwed": 0.13888888888888887
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "doʊntæskmiːtəkæɹiɐnoɪliɹæɡlaɪkðæt",
+                "per": 0.32142857142857145,
+                "pwed": 0.13541666666666666
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "hɪzkæptənwʌzθɪnændhæɡɚdændhɪzbjuːɾɪfəlbuːtswɜːwɔːɹnændʃæbi",
+                "per": 0.3617021276595745,
+                "pwed": 0.13915094339622644
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "ðəɹiːzənzfɜːðɪsdaɪvsiːmdfuːlɪʃnaʊ",
+                "per": 0.20689655172413793,
+                "pwed": 0.022988505747126433
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "pɹədʌkʃənmeɪfɔːlfɑːɹbᵻloʊɛkspɛkteɪʃənz",
+                "per": 0.36363636363636365,
+                "pwed": 0.1392857142857143
+            }
+        ],
+        "timestamp": "2024-12-05T07:32:06.849017"
+    },
+    {
+        "task_id": "d6fe0956-b5b4-4105-835e-8dee1872ee4d",
+        "model": "KoelLabs/xlsr-timit-b0",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.12572285528714347,
+        "average_pwed": 0.06476636812791145,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʃihædjɹdɑɹksuɾɪnɡɹisiwɑʃwɔɾɹʔɔljɪɹ",
+                "per": 0.12121212121212122,
+                "pwed": 0.037990196078431376
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "oʊnæskmitikæɹinɔɪliɹæɡlaɪkðæt",
+                "per": 0.14285714285714285,
+                "pwed": 0.10632183908045977
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "hɪzkæpinwəsθɪnhæɡɹdinizbjuɾiflbutswɹwɔɹninʃæbi",
+                "per": 0.10638297872340426,
+                "pwed": 0.0425531914893617
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "ðəɹiznzfɹðistaɪvsimdfuliʃnaʊ",
+                "per": 0.13793103448275862,
+                "pwed": 0.04166666666666667
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "pɹdʌkʃnmeɪfɔlfɑɹbloʊɛkspɛkeɪʃəns",
+                "per": 0.21212121212121213,
+                "pwed": 0.10858585858585859
+            }
+        ],
+        "timestamp": "2024-12-05T08:25:24.980111"
+    },
+    {
+        "task_id": "dbf4642a-fb13-402c-8a74-cc41fc4be599",
+        "model": "speech31/wav2vec2-large-TIMIT-IPA",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.4415425496841929,
+        "average_pwed": 0.18625930002594002,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʃihædjʊrdɑrksutɪngrisiwɑʃwɔtərɔljɪrrrɪrɪrʃ",
+                "per": 0.5757575757575758,
+                "pwed": 0.25
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "doʊntæskmitɪkɛriənɔɪliræglaɪkðəttm",
+                "per": 0.35714285714285715,
+                "pwed": 0.172979797979798
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "hɪzkæptɪnwɑzθɪnəndhægərdəndhɪzbjutəfəlbutswərwɔrnəndʃæbi",
+                "per": 0.40425531914893614,
+                "pwed": 0.17500000000000004
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "ðərizɪənzfərðɪstaɪvsimdfulɪʃnaʊaʊaʊ",
+                "per": 0.3793103448275862,
+                "pwed": 0.18928571428571428
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "prədəkʃənmeɪfɔlfɑrbɪloʊɛkspɛkteɪʃənzd",
+                "per": 0.3939393939393939,
+                "pwed": 0.13626126126126126
+            }
+        ],
+        "timestamp": "2024-12-05T09:36:14.568321"
+    },
+    {
+        "task_id": "912449a4-d7ed-4af4-b5be-5c2c57ec09ff",
+        "model": "Jubliano/wav2vec2-large-xls-r-300m-ipa-INTERNATIONAL1.5",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.6318471187460027,
+        "average_pwed": 0.222932144739126,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʒihɛldjydɑrksydənrisiwɑswadərɑlhir",
+                "per": 0.5454545454545454,
+                "pwed": 0.11764705882352941
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "dɑnraːstɪkmədəkaːrənoːjliralɪkaːn",
+                "per": 0.7857142857142857,
+                "pwed": 0.2341954022988506
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "xisʃktəʋɑstɪnɛnhɛɪɡərdɛnenzbjudəvɔlbutvɔːrʋɔrnənʃaːbi",
+                "per": 0.6595744680851063,
+                "pwed": 0.18382352941176472
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "dərizənsvərdəstajfzimtvuləsna",
+                "per": 0.6206896551724138,
+                "pwed": 0.11781609195402297
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "pːdkəmeːvɑlvɑrbəloɛkspɛkteːʃəns",
+                "per": 0.5454545454545454,
+                "pwed": 0.2171717171717172
+            }
+        ],
+        "timestamp": "2024-12-05T10:17:21.331572"
+    },
+    {
+        "task_id": "c79df17e-2bb2-4253-ae26-f7cc6ab21265",
+        "model": "facebook/wav2vec2-xlsr-53-espeak-cv-ft",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.348845592557092,
+        "average_pwed": 0.1386742019529415,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʃiːhædjɚdksuːtɪnɡɹiːsiwɑːʃwɑːɾɚɑːljɪ",
+                "per": 0.48484848484848486,
+                "pwed": 0.21338383838383837
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "doːntæskmitəkæɹiənoɪliɹæɡlaɪkðæt",
+                "per": 0.32142857142857145,
+                "pwed": 0.12634408602150538
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "hɪzkæptənwʌzθɪnænhæɡɚdændhɪzbjuːɾɪfʊbuːtswɚwoːnəndʃæbi",
+                "per": 0.3617021276595745,
+                "pwed": 0.13095238095238093
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "ðəɹiːzənzfɚðəsdɑːvsiːmdfuːlɪʃnæ",
+                "per": 0.3793103448275862,
+                "pwed": 0.12068965517241376
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "pɹədʌkʃənmeɪfɑːlfɑːbəloʊɛkspɛkteɪʃənz",
+                "per": 0.36363636363636365,
+                "pwed": 0.14404761904761906
+            }
+        ],
+        "timestamp": "2024-12-05T10:34:26.154521"
+    },
+    {
+        "task_id": "f36060e6-a746-44dc-a527-54995b270053",
+        "model": "ginic/hyperparam_tuning_1_wav2vec2-large-xlsr-buckeye-ipa",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.2766466385175833,
+        "average_pwed": 0.10410683992600853,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʃihædjɹ̩dɑɹksuɾɪnɡɹeɪsiwɑʃwɔɾɹ̩ɔljiɹ",
+                "per": 0.24242424242424243,
+                "pwed": 0.09926470588235292
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "doʊndæskmidɪkæɹiɛnɔɪliɹæɡlaɪkðæʔ",
+                "per": 0.32142857142857145,
+                "pwed": 0.14192708333333334
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "hɪzkæptɪnwʌzθɪnɛnhæɡɹ̩dɛnɪzbjuɾʌfl̩butswɹ̩wɔɹnɛnʃæbi",
+                "per": 0.2553191489361702,
+                "pwed": 0.05357142857142857
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "ðʌɹizʌnzfɹ̩ðʌstaɪvsimdfulɪʃnaʊ",
+                "per": 0.20689655172413793,
+                "pwed": 0.01293103448275862
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "pɹʌdʌkʃʌnmeɪfɔlfɑɹbʌloʊɛkspɛkteɪʃʌns",
+                "per": 0.2727272727272727,
+                "pwed": 0.10416666666666667
+            }
+        ],
+        "timestamp": "2024-12-05T11:06:07.981224"
+    },
+    {
+        "task_id": "47d56349-8111-4bda-a47f-e007dbedd36d",
+        "model": "KoelLabs/xlsr-timit-a0",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.24242141955346685,
+        "average_pwed": 0.17395311976938,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʃihædjɹdɑɹksuɾɪnɡɹisiwɑʃwɔɾɹʔɔljɪɹ",
+                "per": 0.12121212121212122,
+                "pwed": 0.037990196078431376
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "ɪoʊnæskmitikæɹinɔɪliɹæɡlaɪkðt",
+                "per": 0.21428571428571427,
+                "pwed": 0.1695402298850575
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "hɪzkæpinwəsθɪninhæɡɹdinhizbjuɾiflbutswɹwɔɹnintʃæbi",
+                "per": 0.1276595744680851,
+                "pwed": 0.06499999999999999
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "ðəɹiznzfɹðistaɪ",
+                "per": 0.5862068965517241,
+                "pwed": 0.4899425287356322
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "ɹidʌkʃinmeɪfɔlfɑɹbəloʊɛkspɛkeɪ",
+                "per": 0.21212121212121213,
+                "pwed": 0.1553030303030303
+            }
+        ],
+        "timestamp": "2024-12-12T15:53:07.584096"
+    },
+    {
+        "task_id": "51dd5735-63bd-4fe5-a588-c0fc079076e0",
+        "model": "KoelLabs/xlsr-timit-a0",
+        "subset": "test",
+        "num_files": 1680,
+        "average_per": 0.24242141955346685,
+        "average_pwed": 0.17395311976938,
+        "detailed_results": [
+            {
+                "file": "data/TEST/DR1/FAKS0/SA1.WAV",
+                "ground_truth": "ʃihædjɹdɑɹksuɾɪŋgɹisiwɑʃwɑɾɹʔɔljiɹ",
+                "prediction": "ʃihædjɹdɑɹksuɾɪnɡɹisiwɑʃwɔɾɹʔɔljɪɹ",
+                "per": 0.12121212121212122,
+                "pwed": 0.037990196078431376
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SA2.WAV",
+                "ground_truth": "oʊnæsmitikɛɹiinɔɪliɹæglaɪkðæt",
+                "prediction": "ɪoʊnæskmitikæɹinɔɪliɹæɡlaɪkðt",
+                "per": 0.21428571428571427,
+                "pwed": 0.1695402298850575
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI1573.WAV",
+                "ground_truth": "hɪzkæpinwəsθɪnænhægɹdinɪzbjuɾuflbutswɹwɔɹninʃæbi",
+                "prediction": "hɪzkæpinwəsθɪninhæɡɹdinhizbjuɾiflbutswɹwɔɹnintʃæbi",
+                "per": 0.1276595744680851,
+                "pwed": 0.06499999999999999
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI2203.WAV",
+                "ground_truth": "ðiɹizənzfɹðɪsdaɪvsimdfuliʃnaʊ",
+                "prediction": "ðəɹiznzfɹðistaɪ",
+                "per": 0.5862068965517241,
+                "pwed": 0.4899425287356322
+            },
+            {
+                "file": "data/TEST/DR1/FAKS0/SI943.WAV",
+                "ground_truth": "ɹdʌkʃinmeɪfɔlfɑɹbəloʊəkspikeɪʃnts",
+                "prediction": "ɹidʌkʃinmeɪfɔlfɑɹbəloʊɛkspɛkeɪ",
+                "per": 0.21212121212121213,
+                "pwed": 0.1553030303030303
+            }
+        ],
+        "timestamp": "2024-12-12T16:07:25.389475"
+    }
+]

queue/tasks.json

@@ -0,0 +1,92 @@
+[
+    {
+        "id": "721b4c64-a825-42d3-bb0a-bdff9ee1ed0f",
+        "model": "facebook/wav2vec2-lv-60-espeak-cv-ft",
+        "subset": "test",
+        "submission_name": "facebook espeak",
+        "github_url": "https://github.com/facebookresearch/fairseq/blob/main/examples/wav2vec/README.md",
+        "status": "completed",
+        "submitted_at": "2024-12-05T07:19:03.076292"
+    },
+    {
+        "id": "d6fe0956-b5b4-4105-835e-8dee1872ee4d",
+        "model": "KoelLabs/xlsr-timit-b0",
+        "subset": "test",
+        "submission_name": "english phoneme model",
+        "github_url": "https://github.com/KoelLabs/",
+        "status": "completed",
+        "submitted_at": "2024-12-05T08:12:40.161444"
+    },
+    {
+        "id": "dbf4642a-fb13-402c-8a74-cc41fc4be599",
+        "model": "speech31/wav2vec2-large-TIMIT-IPA",
+        "subset": "test",
+        "submission_name": "speech 31 model",
+        "github_url": "https://huggingface.co/speech31/wav2vec2-large-TIMIT-IPA2",
+        "status": "completed",
+        "submitted_at": "2024-12-05T09:13:45.315361"
+    },
+    {
+        "id": "4e3b80be-b255-47f2-b4ae-18a12e232e8a",
+        "model": "Jubliano/wav2vec2-large-xls-r-300m-ipa-INTERNATIONAL1.5",
+        "subset": "test",
+        "submission_name": "Jubliano model",
+        "github_url": "https://huggingface.co/Jubliano/wav2vec2-large-xls-r-300m-ipa-INTERNATIONAL1.5WithoutSpaces/tree/d5312009d8e620b183c334dfdd9ffc6b4f06f8c1",
+        "status": "processing",
+        "submitted_at": "2024-12-05T09:36:14.571930"
+    },
+    {
+        "id": "912449a4-d7ed-4af4-b5be-5c2c57ec09ff",
+        "model": "Jubliano/wav2vec2-large-xls-r-300m-ipa-INTERNATIONAL1.5",
+        "subset": "test",
+        "submission_name": "jubiliano model wav2vec2",
+        "github_url": "https://huggingface.co/Jubliano/wav2vec2-large-xls-r-300m-ipa-INTERNATIONAL1.5WithoutSpaces/tree/d5312009d8e620b183c334dfdd9ffc6b4f06f8c1",
+        "status": "completed",
+        "submitted_at": "2024-12-05T10:01:40.502935"
+    },
+    {
+        "id": "c79df17e-2bb2-4253-ae26-f7cc6ab21265",
+        "model": "facebook/wav2vec2-xlsr-53-espeak-cv-ft",
+        "subset": "test",
+        "submission_name": "xlsr 53 model",
+        "github_url": "https://github.com/facebookresearch/fairseq/blob/main/examples/wav2vec/README.md",
+        "status": "completed",
+        "submitted_at": "2024-12-05T10:18:37.408664"
+    },
+    {
+        "id": "f36060e6-a746-44dc-a527-54995b270053",
+        "model": "ginic/hyperparam_tuning_1_wav2vec2-large-xlsr-buckeye-ipa",
+        "subset": "test",
+        "submission_name": "ginic model wav2vec2 finetuned on buckeye",
+        "github_url": "https://huggingface.co/ginic/vary_individuals_old_only_1_wav2vec2-large-xlsr-buckeye-ipa",
+        "status": "completed",
+        "submitted_at": "2024-12-05T10:36:02.340422"
+    },
+    {
+        "id": "abf6c247-9faf-46ef-b0fa-25f2669da922",
+        "model": "KoelLabs/xlsr-timit-a0",
+        "subset": "test",
+        "submission_name": "Koel Labs early version of finetuned model ",
+        "github_url": "https://github.com/KoelLabs/ML",
+        "status": "processing",
+        "submitted_at": "2024-12-05T11:08:23.663553"
+    },
+    {
+        "id": "47d56349-8111-4bda-a47f-e007dbedd36d",
+        "model": "KoelLabs/xlsr-timit-a0",
+        "subset": "test",
+        "submission_name": "koel labs initial ",
+        "github_url": "https://github.com/KoelLabs/ML/",
+        "status": "completed",
+        "submitted_at": "2024-12-12T15:28:12.923626"
+    },
+    {
+        "id": "51dd5735-63bd-4fe5-a588-c0fc079076e0",
+        "model": "KoelLabs/xlsr-timit-a0",
+        "subset": "test",
+        "submission_name": "koel labs initial ",
+        "github_url": "https://github.com/KoelLabs/ML/",
+        "status": "completed",
+        "submitted_at": "2024-12-12T15:53:07.620070"
+    }
+]