Détails de l'erreur

Lors de l'utilisation de ComfyUI avec ZLUDA pour exécuter des modèles sur des GPU AMD, une erreur CUDA peut survenir, indiquant une opération invalide lors des conversions de types de données. Le message d'erreur typique est :

RuntimeError: CUDA error: invalid argument
CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
For debugging consider passing CUDA_LAUNCH_BLOCKING=1.
Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.

Cette erreur se produit généralement dans les fonctions de conversion de poids, comme cast_bias_weight, lorsque ZLUDA ne supporte pas certaines combinaisons de types de données.

Solutions proposées

Méthode 1 : Modification directe de la fonction de conversion

Localisez le fichier comfy/ops.py dans votre installation ComfyUI. Recherchez la fonction cast_bias_weight et appliquez les modifications suivantes pour gérer la compatibilité ZLUDA :

def process_bias_weight(module, input_tensor, can_offload=True):
    # Détection de l'appareil ZLUDA
    device_info = str(input_tensor.device).lower()
    
    if 'zluda' in device_info:
        # Version simplifiée pour ZLUDA
        target_type = input_tensor.dtype
        
        # Conversion du poids avec gestion d'erreur
        weight_data = module.weight.to(device=input_tensor.device)
        if weight_data.dtype != target_type:
            try:
                weight_data = weight_data.to(dtype=target_type)
            except RuntimeError:
                # Fallback : garder le type original si la conversion échoue
                print("[ZLUDA] Échec de conversion de type pour le poids, conservation du type original")
        
        # Traitement du biais
        bias_data = None
        if module.bias is not None:
            bias_data = module.bias.to(device=input_tensor.device)
            if bias_data.dtype != target_type:
                try:
                    bias_data = bias_data.to(dtype=target_type)
                except RuntimeError:
                    print("[ZLUDA] Échec de conversion de type pour le biais, conservation du type original")
        
        return weight_data, bias_data, None
    
    # Comportement par défaut pour les autres appareils
    # ... code original de conversion ...

Méthode 2 : Contournement via la méthode forward

Modifiez la méthode forward_comfy_cast_weights pour intercepter les appels sur ZLUDA :

def adapted_forward_method(self, *args, **kwargs):
    # Vérification de l'appareil ZLUDA
    if args:
        input_data = args[0]
    elif 'input' in kwargs:
        input_data = kwargs['input']
    else:
        input_data = None
    
    if input_data is not None and 'zluda' in str(input_data.device).lower():
        # Exécution directe sans conversion de type
        return torch.nn.Module.forward(self, *args, **kwargs)
    
    # Exécution normale avec conversion
    weight_conv, bias_conv, stream = process_bias_weight(
        self, input_data, can_offload=True
    )
    # ... suite du code ...

Méthode 3 : Utilisation d'environnement de correction

Créez un script de démarrage avec des variables d'environnemnet et un correctif Python :

@echo off
set CUDA_LAUNCH_BLOCKING=1
set ZLUDA_COMPATIBILITY_MODE=1

cd /d chemin/vers/ComfyUI

echo Création du correctif ZLUDA...
(
echo import torch
echo original_conversion = torch.Tensor.to
echo def safe_conversion(self, *args, **kwargs):
echo     try:
echo         if hasattr(self, 'device') and 'zluda' in str(self.device).lower():
echo             if 'dtype' in kwargs and kwargs['dtype'] == self.dtype:
echo                 return self
echo     except Exception:
echo         pass
echo     return original_conversion(self, *args, **kwargs)
echo torch.Tensor.to = safe_conversion
) > zluda_fix.py

python -c "import zluda_fix" && python main.py --cpu-vae --force-fp32 --auto-launch

Méthode 4 : Ajustement des paramètres de précision

Modifiez les paramètres de lancement de ComfyUI pour forcer la cohérence des types :

python main.py --cpu-vae --force-fp32 --use-split-cross-attention --disable-smart-memory

Alternativement, dans les nœuds CLIPLoader, changez le paramètre "device" de "default" à "cpu" pour éviter les conversions sur GPU.

Étapes de débogage supplémentaires

Pour identifier précisément la source de l'erreur, ajoutez des journaux de débogage :

def process_bias_weight(module, input_tensor, can_offload=True):
    # Informations de débogage
    print(f"[DÉBUG] Module: {type(module).__name__}")
    print(f"[DÉBUG] Entrée - forme: {input_tensor.shape}, type: {input_tensor.dtype}, appareil: {input_tensor.device}")
    print(f"[DÉBUG] Poids - appareil: {module.weight.device}, type: {module.weight.dtype}")
    # ... code original ...

Ces modifications devraient résoudre les erreurs CUDA liées aux conversions de types sur les appareils ZLUDA, en particulier lors de l'encodage de texte avec des modèles comme Qwen.