Fonctionnalités techniques de FastSAM

FastSAM est un outil de segmentation d'images basé sur l'apprentissage profond, conçu pour une vitesse et une précision accrues. Il exploite une architecture avec un CNN Backbone optimisé et un FPN (Feature Pyramid Network), ainsi que des branches de détection et de masque pour une segmentation au niveau pixel. Le modèle prend en charge plusieurs modes de prompt : points, boîtes et texte.

Configuration de l'environnement

Pour initialiser FastSAM, clonez le dépôt et installez les dépendances :

git clone https://gitcode.com/gh_mirrors/fa/FastSAM
cd FastSAM
pip install -r requirements.txt

Le modèle préentraîné se téléchargera automatiquement lors de l'exécution.

Traitement par lots avec FastSAM

FastSAM ne dispose pas d'une API intégrée pour le traitement par lots, mais il est possible de créer un script personnalisé pour gérer plusieurs images. Voici un exemple de code qui parcourt un répertoire d'images, applique la segmentation et sauvegarde les résultats :

import os
import glob
from fast_sam import FastSAM as SegmentationModel
import argparse

def process_images_batch(input_folder, output_folder, model_name="FastSAM-x", resolution=1024, confidence_threshold=0.25, overlap_threshold=0.7):
    os.makedirs(output_folder, exist_ok=True)
    model = SegmentationModel(f"{model_name}.pt")
    
    image_files = []
    for extension in ['*.jpg', '*.jpeg', '*.png']:
        image_files.extend(glob.glob(os.path.join(input_folder, extension)))
    
    for file_path in image_files:
        parameters = argparse.Namespace(
            image=file_path,
            output_dir=output_folder,
            use_high_res=True,
            conf=confidence_threshold,
            iou=overlap_threshold,
            random_color=True,
            show_contours=False,
            optimize_quality=False,
            hardware="cuda" if torch.cuda.is_available() else "cpu"
        )
        
        results = model.segment(file_path, size=resolution, retina_masks=parameters.use_high_res, 
                               conf=parameters.conf, iou=parameters.iou)
        model.save_results(results, args=parameters, random_colors=parameters.random_color)

# Exemple d'utilisation
process_images_batch(input_folder="chemin/vers/images", output_folder="chemin/vers/resultats")

Optimisation des performances

Pour accélérer le traitement sur de grands ensembles d'images, utilisez le multithreading :

from concurrent.futures import ThreadPoolExecutor

def handle_single_image(file_path, model, output_dir, parameters):
    # Logique de traitement pour une image
    pass

with ThreadPoolExecutor(max_workers=4) as executor:
    executor.map(handle_single_image, image_files, [model]*len(image_files), 
                [output_folder]*len(image_files), [parameters]*len(image_files))

Paramètres clés à ajuster :

• resolution : Taille de l'image, affecte la vitesse et la précision.
• confidence_threshold : Seuil de confiance pour les détections, recommandé entre 0.2 et 0.3.
• overlap_threshold : Contrôle la fusion des zones segmentées.
• use_high_res : Active une semgentation haute résolution pour de meilleurs résultats.

Résolution des problèmes courants

Consommation mémoire élevée : Réduisez la taille des images ou libérez la mémoire après chaque traitement :

import gc
del results
gc.collect()
torch.cuda.empty_cache()  # Pour les GPU

Vitesce de traitement lente : Utilisez un GPU, choisissez un modèle plus léger comme "FastSAM-s", ou diminuez la résolution.

Qualité de segmentation insuffisante : Augmentez le seuil de confiance, activez l'optimisation de qualité, ou ajustez le seuil de chevauchement.