Ajouter le script Gradio et les dépendances

Dockerfile

@@ -1,8 +0,0 @@
-# Utilisez une image de base pour Qdrant
-FROM qdrant/qdrant
-
-# Exposez le port par défaut de Qdrant
-EXPOSE 6333
-
-# Commande pour démarrer Qdrant
-CMD ["qdrant"]

README.md

@@ -1,12 +0,0 @@
----
-title: Database
-emoji: 🦀
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 4.36.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

database.py

@@ -1,18 +1,34 @@
+import gc
 import hashlib
 import os
 from glob import glob
+from pathlib import Path
 
-import laion_clap
+import librosa
+import torch
 from diskcache import Cache
 from qdrant_client import QdrantClient
 from qdrant_client.http import models
 from tqdm import tqdm
+from transformers import ClapModel, ClapProcessor
 
-# Utiliser les variables d'environnement pour la configuration
-QDRANT_HOST = os.getenv('QDRANT_HOST', 'localhost')
-QDRANT_PORT = int(os.getenv('QDRANT_PORT', 6333))
+from s3_utils import s3_auth, upload_file_to_bucket
+from dotenv import load_dotenv
+load_dotenv()
 
-# Functions utils
+# PARAMETERS #######################################################################################
+CACHE_FOLDER = '/home/arthur/data/music/demo_audio_search/audio_embeddings_cache_individual/'
+KAGGLE_DB_PATH = '/home/arthur/data/kaggle/park-spring-2023-music-genre-recognition/train/train'
+AWS_ACCESS_KEY_ID = os.environ['AWS_ACCESS_KEY_ID']
+AWS_SECRET_ACCESS_KEY = os.environ['AWS_SECRET_ACCESS_KEY']
+S3_BUCKET = "synthia-research"
+S3_FOLDER = "huggingface_spaces_demo"
+AWS_REGION = "eu-west-3"
+
+s3 = s3_auth(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION)
+
+
+# Functions utils ##################################################################################
 def get_md5(fpath):
     with open(fpath, "rb") as f:
         file_hash = hashlib.md5()
@@ -20,73 +36,83 @@ def get_md5(fpath):
             file_hash.update(chunk)
     return file_hash.hexdigest()
 
-# PARAMETERS
-CACHE_FOLDER = '/home/nahia/data/audio/'
-KAGGLE_TRAIN_PATH = '/home/nahia/Documents/audio/actor/Actor_01/'
 
-# Charger le modèle CLAP
+def get_audio_embedding(model, audio_file, cache):
+    # Compute a unique hash for the audio file
+    file_key = f"{model.config._name_or_path}" + get_md5(audio_file)
+    if file_key in cache:
+        # If the embedding for this file is cached, retrieve it
+        embedding = cache[file_key]
+    else:
+        # Otherwise, compute the embedding and cache it
+        y, sr = librosa.load(audio_file, sr=48000)
+        inputs = processor(audios=y, sampling_rate=sr, return_tensors="pt")
+        embedding = model.get_audio_features(**inputs)[0]
+        gc.collect()
+        torch.cuda.empty_cache()
+        cache[file_key] = embedding
+    return embedding
+
+
+
+# ################## Loading the CLAP model ###################
+# loading the model
 print("[INFO] Loading the model...")
-model_name = 'music_speech_epoch_15_esc_89.25.pt'
-model = laion_clap.CLAP_Module(enable_fusion=False)
-model.load_ckpt()  # télécharger le checkpoint préentraîné par défaut
+model_name = "laion/larger_clap_general"
+model = ClapModel.from_pretrained(model_name)
+processor = ClapProcessor.from_pretrained(model_name)
 
-# Initialiser le cache
+# Initialize the cache
 os.makedirs(CACHE_FOLDER, exist_ok=True)
 cache = Cache(CACHE_FOLDER)
 
-# Embarquer les fichiers audio
-audio_files = [p for p in glob(os.path.join(KAGGLE_TRAIN_PATH, '*.wav'))]
-audio_embeddings = []
-chunk_size = 100
-total_chunks = int(len(audio_files) / chunk_size)
-
-# Utiliser tqdm pour une barre de progression
-for i in tqdm(range(0, len(audio_files), chunk_size), total=total_chunks):
-    chunk = audio_files[i:i + chunk_size]  # Obtenir un chunk de fichiers audio
-    chunk_embeddings = []
-
-    for audio_file in chunk:
-        # Calculer un hash unique pour le fichier audio
-        file_key = get_md5(audio_file)
-
-        if file_key in cache:
-            # Si l'embedding pour ce fichier est en cache, le récupérer
-            embedding = cache[file_key]
-        else:
-            # Sinon, calculer l'embedding et le mettre en cache
-            embedding = model.get_audio_embedding_from_filelist(x=[audio_file], use_tensor=False)[
-                0]  # Assumer que le modèle retourne une liste
-            cache[file_key] = embedding
-        chunk_embeddings.append(embedding)
-    audio_embeddings.extend(chunk_embeddings)
-
-# Fermer le cache quand terminé
-cache.close()
-
-# Créer une collection qdrant
-client = QdrantClient(QDRANT_HOST, port=QDRANT_PORT)
+# Creating a qdrant collection #####################################################################
+client = QdrantClient(os.environ['QDRANT_URL'], api_key=os.environ['QDRANT_KEY'])
 print("[INFO] Client created...")
 
 print("[INFO] Creating qdrant data collection...")
-client.create_collection(
-     collection_name="demo_db7",
-     vectors_config=models.VectorParams(
-         size=audio_embeddings[0].shape[0],
-         distance=models.Distance.COSINE
-     ),
- )
-
-# Créer des enregistrements Qdrant à partir des embeddings
-records = []
-for idx, (audio_path, embedding) in enumerate(zip(audio_files, audio_embeddings)):
-    record = models.PointStruct(
-        id=idx,
-        vector=embedding,
-        payload={"audio_path": audio_path, "style": audio_path.split('/')[-2]}
+if not client.collection_exists("demo_spaces_db"):
+    client.create_collection(
+        collection_name="demo_spaces_db",
+        vectors_config=models.VectorParams(
+            size=model.config.projection_dim,
+            distance=models.Distance.COSINE
+        ),
     )
-    records.append(record)
 
-# Téléverser les enregistrements dans la collection Qdrant
-print("[INFO] Uploading data records to data collection...")
-client.upload_points(collection_name="demo_db7", points=records)
+# Embed the audio files !
+audio_files = [p for p in glob(os.path.join(KAGGLE_DB_PATH, '*/*.wav'))]
+chunk_size, idx = 1, 0
+total_chunks = int(len(audio_files) / chunk_size)
+
+# Use tqdm for a progress bar
+print("Uploading on DB + S3")
+for i in tqdm(range(0, len(audio_files), chunk_size),
+              desc="[INFO] Uploading data records to data collection..."):
+    chunk = audio_files[i:i + chunk_size]  # Get a chunk of audio files
+    records = []
+    for audio_file in chunk:
+        embedding = get_audio_embedding(model, audio_file, cache)
+        file_obj = open(audio_file, 'rb')
+        s3key = f'{S3_FOLDER}/{Path(audio_file).name}'
+        upload_file_to_bucket(s3, file_obj, S3_BUCKET, s3key)
+        records.append(
+            models.PointStruct(
+                id=idx, vector=embedding,
+                payload={
+                    "audio_path": audio_file,
+                    "audio_s3url": f"https://{S3_BUCKET}.s3.amazonaws.com/{s3key}",
+                    "style": audio_file.split('/')[-1]}
+            )
+        )
+        f"Uploaded s3 file : {idx}"
+        idx += 1
+    client.upload_points(
+        collection_name="demo_spaces_db",
+        points=records
+    )
 print("[INFO] Successfully uploaded data records to data collection!")
+
+
+# It's a good practice to close the cache when done
+cache.close()

docker-compose.yml

@@ -1,6 +0,0 @@
-version: '3.8'
-services:
-  qdrant:
-    build: .
-    ports:
-      - "6333:6333"

s3_utils.py

@@ -0,0 +1,66 @@
+import hashlib
+from enum import Enum
+
+import boto3
+from botocore.client import BaseClient
+
+
+# S3 HANDLING ######################################################################################
+def get_md5(fpath):
+    with open(fpath, "rb") as f:
+        file_hash = hashlib.md5()
+        while chunk := f.read(8192):
+            file_hash.update(chunk)
+    return file_hash.hexdigest()
+
+
+def upload_file_to_bucket(s3_client, file_obj, bucket, s3key):
+    """Upload a file to an S3 bucket
+    :param file_obj: File to upload
+    :param bucket: Bucket to upload to
+    :param s3key: s3key
+    :param object_name: S3 object name. If not specified then file_name is used
+    :return: True if file was uploaded, else False
+    """
+    # Upload the file
+    return s3_client.upload_fileobj(
+        file_obj, bucket, s3key,
+        ExtraArgs={"ACL": "public-read", "ContentType": "Content-Type: audio/mpeg"}
+    )
+
+
+def s3_auth(aws_access_key_id, aws_secret_access_key, region_name) -> BaseClient:
+    s3 = boto3.client(
+        service_name='s3',
+        aws_access_key_id=aws_access_key_id,
+        aws_secret_access_key=aws_secret_access_key,
+        region_name=region_name
+    )
+    return s3
+
+
+def get_list_of_buckets(s3: BaseClient):
+    response = s3.list_buckets()
+    buckets = {}
+
+    for buckets in response['Buckets']:
+        buckets[response['Name']] = response['Name']
+
+    BucketName = Enum('BucketName', buckets)
+    return BucketName
+
+
+if __name__ == '__main__':
+    import os
+
+    AWS_ACCESS_KEY_ID = os.environ['AWS_ACCESS_KEY_ID']
+    AWS_SECRET_ACCESS_KEY = os.environ['AWS_SECRET_ACCESS_KEY']
+    S3_BUCKET = "synthia-research"
+    S3_FOLDER = "huggingface_spaces_demo"
+    AWS_REGION = "eu-west-3"
+
+    s3 = s3_auth(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION)
+    print(s3.list_buckets())
+
+    s3key = f'{S3_FOLDER}/015.WAV'
+    print(upload_file_to_bucket(s3, file_obj, S3_BUCKET, s3key))

setup.sh

@@ -1,2 +0,0 @@
-python database.py
-python app.py