refactor: reorganize proj structure ; remove unused scripts; add dataset configs

.gitignore

@@ -19,7 +19,7 @@ my_env/
 # ╭──────────────────────────────╮
 # │     DADOS IGNORADOS (RAW)    │
 # ╰──────────────────────────────╯
-datasets/FASDD_MERGED/
+datasets/FASDD/
 datasets/FASDD_40PERCENT/
 
 # ╭──────────────────────────────╮

check_upload_status.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-"""Script para monitorar o progresso do upload"""
-
-import time
-import subprocess
-import os
-from pathlib import Path
-
-def check_upload_status():
-    """Verifica o status do upload"""
-    print("Verificando status do upload...")
-    
-    # Verificar se o processo está rodando
-    try:
-        result = subprocess.run(
-            ['tasklist', '/fi', 'imagename eq python.exe'],
-            capture_output=True,
-            text=True
-        )
-        
-        if 'python.exe' in result.stdout:
-            print("✓ Processo Python está rodando")
-        else:
-            print("⚠ Nenhum processo Python encontrado")
-            
-    except Exception as e:
-        print(f"Erro ao verificar processos: {e}")
-    
-    # Verificar se há arquivos de log
-    log_file = Path('upload_log.txt')
-    if log_file.exists():
-        print(f"✓ Arquivo de log encontrado: {log_file.stat().st_size} bytes")
-        
-        # Mostrar últimas linhas do log
-        with open(log_file, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-            if lines:
-                print("Últimas linhas do log:")
-                for line in lines[-10:]:
-                    print(f"  {line.strip()}")
-    else:
-        print("⚠ Arquivo de log não encontrado")
-    
-    return True
-
-if __name__ == "__main__":
-    check_upload_status()

fasdd_40.yaml → fasdd.yaml

@@ -1,4 +1,4 @@
-path: datasets/FASDD_40PERCENT
+path: datasets/FASDD
 train: images/train
 val: images/val
 test: images/test

pipeline/sample_dataset_subset.py

@@ -1,44 +0,0 @@
-import os
-import shutil
-import random
-from pathlib import Path
-from tqdm import tqdm
-
-def sample_split(split, input_dir, output_dir, percent):
-    img_dir = Path(input_dir) / "images" / split
-    label_dir = Path(input_dir) / "labels" / split
-    out_img_dir = Path(output_dir) / "images" / split
-    out_label_dir = Path(output_dir) / "labels" / split
-
-    out_img_dir.mkdir(parents=True, exist_ok=True)
-    out_label_dir.mkdir(parents=True, exist_ok=True)
-
-    images = list(img_dir.glob("*.jpg"))
-    sample_size = int(len(images) * percent)
-    selected_images = random.sample(images, sample_size)
-
-    print(f"📂 {split.upper()}: copiando {sample_size} de {len(images)} imagens...")
-
-    for img_path in tqdm(selected_images):
-        shutil.copy(img_path, out_img_dir / img_path.name)
-
-        label_path = label_dir / f"{img_path.stem}.txt"
-        out_label = out_label_dir / f"{img_path.stem}.txt"
-        if label_path.exists():
-            shutil.copy(label_path, out_label)
-
-def sample_dataset(input_dir, output_dir, percent=0.4):
-    print(f"🚀 Criando subconjunto do dataset: {int(percent*100)}%")
-    for split in ["train", "val", "test"]:
-        sample_split(split, input_dir, output_dir, percent)
-    print("✅ Dataset copiado.")
-
-if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--input", type=str, required=True, help="Caminho do dataset original")
-    parser.add_argument("--output", type=str, default="datasets/FASDD_40PERCENT", help="Destino do novo subset")
-    parser.add_argument("--percent", type=float, default=0.4, help="Porcentagem a copiar (ex: 0.4 para 40%)")
-    args = parser.parse_args()
-
-    sample_dataset(args.input, args.output, args.percent)

check_status.py → scripts/check_status_upload.py

@@ -1,13 +1,10 @@
 #!/usr/bin/env python3
-"""Script para verificar se o upload está funcionando"""
 
 import subprocess
-import time
 import os
 from pathlib import Path
 
-def check_processes():
-    """Verifica processos Python rodando"""
+def find_python_processes():
     try:
         result = subprocess.run(
             ['wmic', 'process', 'where', 'name="python.exe"', 'get', 'processid,commandline'],
@@ -17,25 +14,23 @@ def check_processes():
         
         if result.returncode == 0:
             lines = result.stdout.strip().split('\n')
-            python_processes = []
-            for line in lines[1:]:  # Pular header
-                if line.strip() and 'upload' in line.lower():
-                    python_processes.append(line.strip())
+            upload_processes = [
+                line.strip() for line in lines[1:] if line.strip() and 'upload' in line.lower()
+            ]
             
-            if python_processes:
-                print("✓ Processos de upload encontrados:")
-                for proc in python_processes:
+            if upload_processes:
+                print("✓ Upload processes found:")
+                for proc in upload_processes:
                     print(f"  {proc}")
             else:
-                print("⚠ Nenhum processo de upload encontrado")
+                print("⚠ No upload processes found")
         else:
-            print("✗ Erro ao verificar processos")
+            print("✗ Error checking processes")
             
     except Exception as e:
-        print(f"Erro: {e}")
+        print(f"Error: {e}")
 
 def check_files():
-    """Verifica arquivos criados"""
     files_to_check = [
         'upload_log.txt',
         'test_upload_results.txt',
@@ -46,30 +41,29 @@ def check_files():
         path = Path(file_path)
         if path.exists():
             size = path.stat().st_size
-            print(f"✓ {file_path} existe ({size} bytes)")
+            print(f"✓ {file_path} exists ({size} bytes)")
         else:
-            print(f"⚠ {file_path} não existe")
+            print(f"⚠ {file_path} does not exist")
 
 def main():
-    print("=== Verificação de status do upload ===")
-    print(f"Diretório atual: {os.getcwd()}")
+    print("=== Upload Status Check ===")
+    print(f"Current directory: {os.getcwd()}")
     print()
     
-    print("1. Verificando processos...")
-    check_processes()
+    print("1. Checking processes...")
+    find_python_processes()
     
-    print("\n2. Verificando arquivos...")
+    print("\n2. Checking files...")
     check_files()
-    
-    print("\n3. Testando comando simples...")
+
     try:
         result = subprocess.run(['dagshub', '--help'], capture_output=True, text=True, timeout=5)
         if result.returncode == 0:
-            print("✓ DagsHub CLI funciona")
+            print("✓ DagsHub CLI is working")
         else:
-            print("✗ DagsHub CLI não funciona")
+            print("✗ DagsHub CLI is not working")
     except Exception as e:
-        print(f"✗ Erro ao testar DagsHub: {e}")
+        print(f"✗ Error testing DagsHub CLI: {e}")
 
 if __name__ == "__main__":
     main()

scripts/train.py

@@ -0,0 +1,48 @@
+from ultralytics import YOLO
+
+def train_yolo_model(data_path, model, epochs=10, batch_size=32, imgsz=320):
+    """
+    Train YOLO model with optimized parameters for fastest training (testing purposes)
+    
+    Args:
+        data_path: Path to dataset YAML file
+        model: Model size ('yolov9n.pt' is fastest, 'yolov9s.pt' for better accuracy)
+        epochs: Number of training epochs (10-20 for quick tests)
+        batch_size: Batch size (16-64 depending on GPU memory)
+        imgsz: Image size (320 fastest, 640 standard, 1280 highest quality)
+    """
+    # Load a YOLO model
+    model = YOLO(model)
+
+    # Train the model with optimized parameters for speed
+    results = model.train(
+        data=data_path, 
+        epochs=epochs,
+        batch=batch_size,
+        imgsz=imgsz,
+        device='cpu',  # Change to 'cuda' or '0' if you have a GPU
+        workers=4,     # Number of dataloader workers
+        cache=True,    # Cache images for faster training
+        amp=True,      # Automatic Mixed Precision (faster on modern GPUs)
+        patience=5,    # Early stopping patience
+        save_period=5, # Save checkpoint every 5 epochs
+        plots=False,   # Disable plots to save time
+        verbose=True
+    )
+    
+    return results
+
+if __name__ == "__main__":
+    data_path = "fasdd.yaml"  # Path to the dataset configuration file
+    
+    # For fastest training (testing purposes):
+    train_yolo_model(data_path, model='yolov9s.pt', epochs=5, batch_size=64, imgsz=320)
+
+    # For balanced speed/accuracy (uncomment to use):
+    # train_yolo_model(data_path, epochs=20, batch_size=32, imgsz=480)
+
+    # For full training (uncomment to use):
+    # train_yolo_model(data_path, model='yolov9s.pt', epochs=100, batch_size=16, imgsz=640)
+    
+    # For balanced speed/accuracy (uncomment to use):
+    # train_yolo_model(data_path, epochs=20, batch_size=32, imgsz=480)

{pipeline → scripts}/upload_to_dagshub.py

@@ -4,56 +4,57 @@ from pathlib import Path
 from dotenv import load_dotenv
 import requests
 
-# Carrega o token do .env
+########## Configs ##########
 load_dotenv(dotenv_path=Path(__file__).resolve().parent.parent / ".env")
 DAGSHUB_TOKEN = os.getenv("DAGSHUB_TOKEN")
-USERNAME = "All3yp"
-REPO = "FS_DETECTION"
+USERNAME = os.getenv("USERNAME")
+REPO = os.getenv("REPO")
 REPO_PATH = f"{USERNAME}/{REPO}"
+##############################
 
 if not DAGSHUB_TOKEN:
-    raise ValueError("❌ DAGSHUB_TOKEN não encontrado no .env")
+    raise ValueError("❌ DAGSHUB_TOKEN not found in .env")
 
-def testar_conexao_dagshub(username, repo, token):
-    print("🔐 Testando autenticação com DagsHub...")
-    url = f"https://dagshub.com/api/v1/repos/{username}/{repo}"
-    response = requests.get(url, auth=(username, token))
+def testar_conexao_dagshub(token):
+    print("🔐 Testing DagsHub authentication...")
+    url = f"https://dagshub.com/api/v1/repos/{USERNAME}/{REPO}"
+    response = requests.get(url, auth=(USERNAME, token))
     if response.status_code == 200:
-        print("✅ Conexão com DagsHub OK")
+        print("✅ DagsHub connection OK")
         return True
-    print(f"❌ Falha na autenticação ({response.status_code}): {response.text}")
+    print(f"❌ Authentication failed ({response.status_code}): {response.text}")
     return False
 
 def install_dagshub_client():
-    print("🔧 Verificando cliente DagsHub...")
+    print("🔧 Checking DagsHub client...")
     try:
         subprocess.run(["dagshub", "--help"], capture_output=True, text=True, check=True)
     except (FileNotFoundError, subprocess.CalledProcessError):
-        print("📦 Instalando cliente DagsHub...")
+        print("📦 Installing DagsHub client...")
         subprocess.run(["pip", "install", "dagshub", "--upgrade"], check=True)
 
 def login_dagshub():
-    print("🔐 Realizando login automático no DagsHub via token...")
+    print("🔐 Performing automatic login to DagsHub via token...")
     try:
         subprocess.run(["dagshub", "login", "--token", DAGSHUB_TOKEN], check=True)
-        print("✅ Login realizado com sucesso")
+        print("✅ Login successful")
     except subprocess.CalledProcessError as e:
-        print(f"⚠️  Aviso durante login: {e.stderr}")
+        print(f"⚠️  Warning during login: {e.stderr}")
 
 def upload_datasets():
-    print("📤 Enviando datasets para o bucket do DagsHub...")
+    print("📤 Uploading datasets to DagsHub bucket...")
 
     datasets_to_upload = [
-        "datasets/FASDD_40PERCENT"
+        "datasets/FASDD"
     ]
     
     for dataset_path in datasets_to_upload:
         path_obj = Path(dataset_path)
         if not path_obj.exists():
-            print(f"⚠️  Dataset não encontrado: {dataset_path}, pulando...")
+            print(f"⚠️  Dataset not found: {dataset_path}, skipping...")
             continue
 
-        print(f"📁 Upload: {dataset_path}")
+        print(f"📁 Uploading: {dataset_path}")
         try:
             subprocess.run([
                 "dagshub", "upload",
@@ -62,21 +63,21 @@ def upload_datasets():
                 f"data/{path_obj.name}/",
                 "--bucket", "--update", "-v"
             ], check=True)
-            print(f"✅ Upload concluído: {dataset_path}")
+            print(f"✅ Upload completed: {dataset_path}")
         except subprocess.CalledProcessError as e:
-            print(f"❌ Erro no upload de {dataset_path}: {e.stderr}")
+            print(f"❌ Upload error for {dataset_path}: {e.stderr}")
 
 if __name__ == "__main__":
-    print("🚀 Iniciando upload para o bucket DagsHub...")
+    print("🚀 Starting upload to DagsHub bucket...")
 
-    if not testar_conexao_dagshub(USERNAME, REPO, DAGSHUB_TOKEN):
-        raise SystemExit("⛔ Token inválido ou repositório inacessível.")
+    if not testar_conexao_dagshub(DAGSHUB_TOKEN):
+        raise SystemExit("⛔ Invalid token or repository inaccessible.")
 
     try:
         install_dagshub_client()
         login_dagshub()
         upload_datasets()
-        print("✅ Upload finalizado com sucesso!")
+        print("✅ Upload completed successfully!")
     except Exception as e:
-        print(f"❌ Erro durante o processo: {e}")
+        print(f"❌ Error during process: {e}")
         raise