Introduction : Pourquoi le Multimodal Change la Donne
En tant qu'ingénieur spécialisé dans l'intégration d'API IA depuis plus de quatre ans, j'ai testé des dizaines de solutions pour optimiser les flux de travail e-commerce. L'arrivée des modèles multimodaux comme Gemini a véritablement révolutionné notre approche de la création de contenu visuel. Dans ce tutoriel complet, je vais vous partager mon expérience pratique avec HolySheep AI, une plateforme qui simplifie considérablement l'accès aux capacités multimodales avancées.
Nous allons explorer ensemble comment automatiser la génération d'images produits, créer des variations pour vos tests A/B, et mesurer l'impact sur vos conversions. Mon objectif : vous fournir un guide actionnable que vous pourrez déployer en production dès demain.
Tableau Comparatif : HolySheep vs API Officielle vs Services Relais
| Critère | HolySheep AI | API Officielle Google | Autres Services Relais |
|---|---|---|---|
| Prix Gemini 2.5 Flash | $2.50/MTok | $2.50/MTok | $3.50 - $8.00/MTok |
| Latence moyenne | <50ms | 80-150ms | 100-300ms |
| Méthodes de paiement | WeChat, Alipay, Carte | Carte internationale uniquement | Variable |
| Crédits gratuits | Oui, dès l'inscription | Essai limité | Rare |
| Économie vs GPT-4.1 | 68% moins cher | 68% moins cher | 0-50% moins cher |
| Support technique | WeChat/Email en français | Documentation uniquement | Variable |
| Uptime garanti | 99.9% | 99.5% | 95-99% |
Cas d'Usage #1 : Génération Automatique d'Images Produits
La génération d'images produits de qualité est cruciale pour les conversions. Dans mon expérience avec plusieurs boutiques e-commerce chinoises et européennes, j'ai constaté qu'une image produit optimisée peut augmenter le taux de conversion de 15 à 35%. Gemini Flash 2.5 permet de créer des variations réalistes en quelques secondes.
Architecture de la Solution
Notre pipeline fonctionne en trois étapes : d'abord, nous analysons l'image originale du produit pour en extraire les caractéristiques visuelles. Ensuite, nous générons des variations contextuelles (fond, éclairage, angle). Enfin, nous stockons les résultats et les préparer pour les tests A/B.
#!/usr/bin/env python3
"""
Générateur automatique d'images produits avec Gemini Flash 2.5
Optimisé pour HolySheep AI API
"""
import base64
import requests
import json
from pathlib import Path
from typing import List, Dict, Optional
import time
class ProductImageGenerator:
"""Génère des variations d'images produits avec Gemini multimodal"""
def __init__(self, api_key: str):
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
def _encode_image(self, image_path: str) -> str:
"""Encode une image en base64 pour l'API"""
with open(image_path, "rb") as img_file:
return base64.b64encode(img_file.read()).decode('utf-8')
def generate_variations(
self,
product_image_path: str,
variations: List[str],
context: str = "e-commerce fashion"
) -> List[Dict]:
"""
Génère des variations d'images produits
Args:
product_image_path: Chemin vers l'image originale
variations: Liste des types de variations (fond, éclairage, etc.)
context: Contexte commercial pour la génération
Returns:
Liste des variations générées avec métadonnées
"""
image_base64 = self._encode_image(product_image_path)
prompt = f"""Analyse cette image produit et génère {len(variations)} variations
adaptées au contexte e-commerce : {context}.
Variations demandées : {', '.join(variations)}
Pour chaque variation, décris précisément:
1. Le fond recommandé (studio blanc, lifestyle, minimaliste)
2. L'éclairage optimal (naturel, studio, dramatique)
3. L'angle de prise de vue suggéré
4. Les accessoires ou éléments à ajouter
5. La palette de couleurs dominante
Réponds en JSON structuré avec un tableau de variations."""
payload = {
"model": "gemini-2.0-flash-exp",
"contents": [
{
"role": "user",
"parts": [
{"text": prompt},
{
"inline_data": {
"mime_type": "image/jpeg",
"data": image_base64
}
}
]
}
],
"generation_config": {
"temperature": 0.7,
"top_p": 0.9,
"max_output_tokens": 2048,
"response_mime_type": "application/json"
}
}
start_time = time.time()
response = self.session.post(
f"{self.base_url}/chat/completions",
json=payload,
timeout=30
)
latency = time.time() - start_time
if response.status_code != 200:
raise Exception(f"API Error: {response.status_code} - {response.text}")
result = response.json()
content = result['choices'][0]['message']['content']
return {
"variations": json.loads(content),
"latency_ms": round(latency * 1000, 2),
"tokens_used": result.get('usage', {}).get('total_tokens', 0),
"cost_usd": (result.get('usage', {}).get('total_tokens', 0) / 1_000_000) * 2.50
}
Exemple d'utilisation
if __name__ == "__main__":
generator = ProductImageGenerator("YOUR_HOLYSHEEP_API_KEY")
result = generator.generate_variations(
product_image_path="./images/chaussures_blanches.jpg",
variations=[
"fond_studio_blanc",
"lifestyle_extérieur",
"minimaliste_moderne",
"fête_noël",
"été_plage"
],
context="boutique mode premium européenne"
)
print(f"✅ {len(result['variations'])} variations générées")
print(f"⏱️ Latence: {result['latency_ms']}ms")
print(f"💰 Coût: ${result['cost_usd']:.4f}")
Cas d'Usage #2 : Optimisation A/B Testing avec Analyse Multimodale
L'un des aspects les plus intéressants de mon travail avec Gemini a été de développer des systèmes d'analyse automatique pour les tests A/B.传统方法需要数小时的人工审查, mais avec les capacités multimodales, nous pouvons analyser des centaines de variations en quelques minutes.
#!/usr/bin/env python3
"""
Système d'analyse A/B Testing pour images e-commerce
Utilise Gemini pour évaluer et classer les variations
"""
import requests
import json
from dataclasses import dataclass
from typing import List, Dict, Tuple
from datetime import datetime
import hashlib
@dataclass
class ABTestResult:
"""Résultat d'un test A/B pour une variation d'image"""
variation_id: str
image_path: str
scores: Dict[str, float]
recommandations: List[str]
score_global: float
class ABTestingAnalyzer:
"""Analyse les variations d'images pour les tests A/B"""
CRITERES_PONDERATION = {
"吸引注意力": 0.25, # Capacité d'attirer l'attention
"清晰度": 0.20, # Clarté du produit
"专业度": 0.20, # Apparence professionnelle
"情感连接": 0.20, # Connexion émotionnelle
"购买欲望": 0.15 # Désir d'achat
}
def __init__(self, api_key: str):
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
def _encode_image(self, image_path: str) -> str:
"""Encode une image en base64"""
with open(image_path, "rb") as f:
return base64.b64encode(f.read()).decode('utf-8')
def analyser_variation(self, image_path: str, reference_path: str = None) -> Dict:
"""
Analyse une variation d'image produit
Returns:
Dict avec scores par critère et recommandations
"""
image_base64 = self._encode_image(image_path)
prompt = """你是电商图片分析专家。请分析这张产品图片的以下5个维度，
每个维度给出0-100的分数：
1. 吸引注意力 (分数0-100): 图片是否能立即抓住浏览者眼球
2. 清晰度 (分数0-100): 产品展示是否清晰、专业
3. 专业度 (分数0-100): 整体视觉呈现的专业程度
4. 情感连接 (分数0-100): 是否能引起情感共鸣
5. 购买欲望 (分数0-100): 是否能激发购买意愿
然后给出3条具体改进建议。
格式必须是JSON：
{
"scores": {
"吸引注意力": 数字,
"清晰度": 数字,
"专业度": 数字,
"情感连接": 数字,
"购买欲望": 数字
},
"recommandations": ["建议1", "建议2", "建议3"]
}"""
parts = [{"text": prompt}]
if reference_path:
ref_base64 = self._encode_image(reference_path)
parts.append({
"inline_data": {
"mime_type": "image/jpeg",
"data": ref_base64
}
})
parts.append({
"inline_data": {
"mime_type": "image/jpeg",
"data": image_base64
}
})
payload = {
"model": "gemini-2.0-flash-exp",
"contents": [{"role": "user", "parts": parts}],
"generation_config": {
"temperature": 0.3,
"max_output_tokens": 1024,
"response_mime_type": "application/json"
}
}
response = self.session.post(
f"{self.base_url}/chat/completions",
json=payload,
timeout=30
)
if response.status_code != 200:
raise Exception(f"Erreur API: {response.status_code}")
result = response.json()
content = result['choices'][0]['message']['content']
return json.loads(content)
def comparer_variations(
self,
variations: List[str],
reference: str = None
) -> List[ABTestResult]:
"""
Compare plusieurs variations et retourne un classement
Args:
variations: Liste des chemins vers les images
reference: Image de référence pour la comparaison
Returns:
Liste triée des résultats A/B
"""
results = []
for idx, var_path in enumerate(variations):
print(f"📊 Analyse variation {idx + 1}/{len(variations)}...")
analyse = self.analyser_variation(var_path, reference)
# Calcul du score global pondéré
score_global = sum(
analyse['scores'][critere] * poids
for critere, poids in self.CRITERES_PONDERATION.items()
)
results.append(ABTestResult(
variation_id=hashlib.md5(var_path.encode()).hexdigest()[:8],
image_path=var_path,
scores=analyse['scores'],
recommandations=analyse['recommandations'],
score_global=score_global
))
# Tri par score global décroissant
results.sort(key=lambda x: x.score_global, reverse=True)
return results
def generer_rapport(self, results: List[ABTestResult]) -> str:
"""Génère un rapport textuel des résultats"""
rapport = f"""
📈 Rapport A/B Testing - {datetime.now().strftime('%Y-%m-%d %H:%M')}
🏆 Classement des Variations
"""
for idx, result in enumerate(results, 1):
medal = "🥇" if idx == 1 else "🥈" if idx == 2 else "🥉"
rapport += f"""
{medal} Variation #{idx} (ID: {result.variation_id})
**Score Global: {result.score_global:.1f}/100**
#### Scores détaillés:
"""
for critere, score in result.scores.items():
bar = "█" * int(score / 10) + "░" * (10 - int(score / 10))
rapport += f"- {critere}: [{bar}] {score}\n"
rapport += "\n#### 💡 Recommandations:\n"
for rec in result.recommandations:
rapport += f"- {rec}\n"
return rapport
Programme principal
if __name__ == "__main__":
analyzer = ABTestingAnalyzer("YOUR_HOLYSHEEP_API_KEY")
# Chemins vers vos variations d'images
variations = [
"./ab_test/variation_1_hero.jpg",
"./ab_test/variation_2_lifestyle.jpg",
"./ab_test/variation_3_minimal.jpg",
"./ab_test/variation_4_seasonal.jpg"
]
# Analyse comparative
results = analyzer.comparer_variations(
variations=variations,
reference="./ab_test/reference_original.jpg"
)
# Génération et affichage du rapport
rapport = analyzer.generer_rapport(results)
print(rapport)
# Sauvegarde du rapport
with open("rapport_ab_test.md", "w", encoding="utf-8") as f:
f.write(rapport)
# Export JSON pour intégration dashboard
with open("resultats_ab_test.json", "w", encoding="utf-8") as f:
json.dump([{
"variation_id": r.variation_id,
"score_global": r.score_global,
"scores": r.scores,
"classement": idx + 1
} for idx, r in enumerate(results)], f, ensure_ascii=False, indent=2)
Pipeline Complet : De l'Image Originale aux Tests A/B
Dans ma pratique quotidienne, j'ai développé un pipeline complet qui automatise l'ensemble du processus. Ce pipeline intègre la génération d'images, l'analyse automatique, et la préparation des assets pour les plateformes e-commerce.
#!/usr/bin/env python3
"""
Pipeline complet : Génération → Analyse → Export A/B Testing
Optimisé pour Shopify et WooCommerce
"""
import os
import json
import requests
from pathlib import Path
from typing import List, Dict, Optional
from concurrent.futures import ThreadPoolExecutor, as_completed
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
class EcommerceImagePipeline:
"""
Pipeline complet pour la gestion d'images e-commerce
Étapes: Génération → Analyse → Optimisation → Export
"""
def __init__(self, api_key: str, output_dir: str = "./output"):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.output_dir = Path(output_dir)
self.output_dir.mkdir(parents=True, exist_ok=True)
# Création des sous-dossiers
(self.output_dir / "generations").mkdir(exist_ok=True)
(self.output_dir / "analyses").mkdir(exist_ok=True)
(self.output_dir / "ab_tests").mkdir(exist_ok=True)
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
# Modèles et prompts par type de produit
self.templates = {
"vetement": {
"prompt_generation": """Génère des variations d'une image vêtement pour e-commerce.
Contexte: {contexte}
Variations demandées: {variations}
Pour chaque variation, fournis:
- Description détaillée du fond
- Style d'éclairage
- Angle et composition
- Accessoires suggérés
- Palette de couleurs""",
"variations_standard": [
"studio_blanc_pro",
"lifestyle_urbain",
"minimaliste_elegant",
"saisonnier_contexte",
"lookbook_complet"
]
},
"electronique": {
"prompt_generation": """Crée des variations professionnelles pour un produit électronique.
Focus: qualité technique, détails,角度
Variations: {variations}
Contexte: {contexte}""",
"variations_standard": [
"flat_lay_technique",
"utilisation_lifestyle",
"detail_zoom",
"emballage_pro",
"comparaison_taille"
]
},
"alimentaire": {
"prompt_generation": """ Génère des variations appetissantes pour un produit alimentaire.
Emphasis on: couleurs naturelles, fraîcheur, présentation
Variations: {variations}""",
"variations_standard": [
"presentation_table",
"detail_ingredients",
"contexte_lifestyle",
"packaging_minimal",
"comparaison_portion"
]
}
}
def generer_batch(
self,
product_image_path: str,
product_type: str = "vetement",
contexte: str = "e-commerce premium",
custom_variations: List[str] = None
) -> Dict:
"""
Génère un batch de variations pour un produit
Args:
product_image_path: Chemin vers l'image originale
product_type: Type de produit (vetement/electronique/alimentaire)
contexte: Contexte commercial
custom_variations: Liste personnalisée de variations
Returns:
Dict avec toutes les générations et métadonnées
"""
import base64
template = self.templates.get(product_type, self.templates["vetement"])
variations = custom_variations or template["variations_standard"]
# Encodage image
with open(product_image_path, "rb") as f:
image_data = base64.b64encode(f.read()).decode('utf-8')
prompt = template["prompt_generation"].format(
contexte=contexte,
variations=", ".join(variations)
)
payload = {
"model": "gemini-2.0-flash-exp",
"contents": [
{
"role": "user",
"parts": [
{"text": prompt},
{
"inline_data": {
"mime_type": "image/jpeg",
"data": image_data
}
}
]
}
],
"generation_config": {
"temperature": 0.8,
"top_p": 0.95,
"max_output_tokens": 4096
}
}
logger.info(f"🚀 Génération de {len(variations)} variations...")
response = self.session.post(
f"{self.base_url}/chat/completions",
json=payload,
timeout=60
)
if response.status_code != 200:
raise Exception(f"Erreur génération: {response.status_code}")
result = response.json()
content = result['choices'][0]['message']['content']
# Parsing et structuration
generations = {
"metadata": {
"source_image": product_image_path,
"product_type": product_type,
"contexte": contexte,
"timestamp": str(Path(product_image_path).stat().st_mtime),
"variations_requested": variations,
"latency_ms": result.get('usage', {}).get('total_tokens', 0),
"cost_usd": (result.get('usage', {}).get('total_tokens', 0) / 1_000_000) * 2.50
},
"generations": content,
"usage_stats": result.get('usage', {})
}
# Sauvegarde
output_file = self.output_dir / "generations" / f"gen_{Path(product_image_path).stem}.json"
with open(output_file, "w", encoding="utf-8") as f:
json.dump(generations, f, ensure_ascii=False, indent=2)
logger.info(f"✅ Sauvegardé: {output_file}")
return generations
def analyser_batch(self, generations_file: str) -> Dict:
"""
Analyse les générations précédentes pour A/B testing
Returns:
Dict avec scores et recommandations
"""
with open(generations_file, "r", encoding="utf-8") as f:
data = json.load(f)
# Prompt d'analyse pour scores A/B
analyse_prompt = f"""Analyse ces variations d'images e-commerce et évalue-les
pour un test A/B. Pour chaque variation, donne:
1. Score engagement (0-100): Potentiel d'attirer les clics
2. Score conversion (0-100): Capacité à convertir en achat
3. Score brand fit (0-100): Adéquation avec une marque premium
4. Score mobile (0-100): Lisibilité sur mobile
5. Score speed (0-100): Temps de chargement estimé
Contexte: {data['metadata']['contexte']}
Variations à analyser:
{data['generations']}
Réponds en JSON avec un tableau d'analyses."""
payload = {
"model": "gemini-2.0-flash-exp",
"contents": [{"role": "user", "parts": [{"text": analyse_prompt}]}],
"generation_config": {
"temperature": 0.3,
"max_output_tokens": 2048,
"response_mime_type": "application/json"
}
}
logger.info("📊 Lancement de l'analyse A/B...")
response = self.session.post(
f"{self.base_url}/chat/completions",
json=payload,
timeout=30
)
if response.status_code != 200:
raise Exception(f"Erreur analyse: {response.status_code}")
result = response.json()
analyses = json.loads(result['choices'][0]['message']['content'])
# Sauvegarde analyse
output_file = self.output_dir / "analyses" / f"analyse_{Path(generations_file).stem}.json"
with open(output_file, "w", encoding="utf-8") as f:
json.dump({
"source": generations_file,
"analyses": analyses,
"usage_stats": result.get('usage', {})
}, f, ensure_ascii=False, indent=2)
return analyses
def exporter_ab_ready(
self,
analyse_file: str,
platform: str = "shopify"
) -> Dict:
"""
Exporte les variations prêtes pour A/B testing sur plateforme
Supports: shopify, woocommerce, custom
"""
with open(analyse_file, "r", encoding="utf-8") as f:
data = json.load(f)
export_data = {
"platform": platform,
"timestamp": str(Path(analyse_file).stat().st_mtime),
"variations": [],
"instructions": self._get_platform_instructions(platform)
}
for idx, analyse in enumerate(data.get('analyses', [])):
export_data["variations"].append({
"id": f"ab_var_{idx + 1}",
"description": analyse.get('description', f'Variation {idx + 1}'),
"scores": analyse.get('scores', {}),
"rank": idx + 1,
"recommended": idx == 0 # Top recommendation
})
# Export formats
json_file = self.output_dir / "ab_tests" / f"{platform}_export.json"
with open(json_file, "w", encoding="utf-8") as f:
json.dump(export_data, f, ensure_ascii=False, indent=2)
# CSV pour analyse Excel
csv_file = self.output_dir / "ab_tests" / f"{platform}_export.csv"
self._export_csv(export_data, csv_file)
logger.info(f"✅ Export A/B prêt: {json_file}")
return export_data
def _get_platform_instructions(self, platform: str) -> str:
"""Instructions spécifiques par plateforme"""
instructions = {
"shopify": """
Pour Shopify:
1. Allez dans Produits > Variantes
2. Importez le fichier JSON via Shopify API
3. Configurez les tests A/B avec Shopify Experiments
4. Suivez les métriques dans Shopify Analytics
""",
"woocommerce": """
Pour WooCommerce:
1. Installez plugin A/B testing (ex: Nelio A/B Testing)
2. Importez les variations via importateur CSV
3. Créez les tests depuis le dashboard WordPress
4. Analysez les résultats avec Google Analytics
""",
"custom": """
Pour système custom:
1. Intégrez les IDs de variations dans votre tracking
2. Assignez aléatoirement via votre système de routing
3. Collectez events de vue, clic, et conversion
4. Analysez avec votre outil BI preferido
"""
}
return instructions.get(platform, instructions["custom"])
def _export_csv(self, data: Dict, output_path: Path):
"""Exporte en format CSV pour analyse"""
import csv
with open(output_path, "w", newline="", encoding="utf-8") as f:
writer = csv.writer(f)
# Header
writer.writerow([
"Variation ID", "Description", "Rank", "Recommended",
"Engagement Score", "Conversion Score",
"Brand Fit Score", "Mobile Score", "Speed Score"
])
# Data rows
for var in data.get("variations", []):
scores = var.get("scores", {})
writer.writerow([
var["id"],
var.get("description", ""),
var["rank"],
"Yes" if var.get("recommended") else "No",
scores.get("engagement", "N/A"),
scores.get("conversion", "N/A"),
scores.get("brand_fit", "N/A"),
scores.get("mobile", "N/A"),
scores.get("speed", "N/A")
])
Exécution complète du pipeline
if __name__ == "__main__":
# Initialisation
pipeline = EcommerceImagePipeline(
api_key="YOUR_HOLYSHEEP_API_KEY",
output_dir="./ecommerce_pipeline_output"
)
# Étape 1: Génération
print("=" * 60)
print("ÉTAPE 1: Génération des variations")
print("=" * 60)
generations = pipeline.generer_batch(
product_image_path="./products/chaussure_runner.jpg",
product_type="vetement",
contexte="boutique sport premium France",
custom_variations=[
"studio_professionnel",
"action_sport",
"minimaliste_blanc",
"lifestyle_urbain",
"comparaison_taille"
]
)
print(f"\n📦 {len(generations['metadata']['variations_requested'])} variations générées")
print(f"💰 Coût estimé: ${generations['metadata']['cost_usd']:.4f}")
# Étape 2: Analyse A/B
print("\n" + "=" * 60)
print("ÉTAPE 2: Analyse A/B Testing")
print("=" * 60)
analyses = pipeline.analyser_batch(
generations_file="./ecommerce_pipeline_output/generations/gen_chaussure_runner.json"
)
print(f"\n📊 {len(analyses.get('analyses', []))} variations analysées")
# Étape 3: Export pour plateformes
print("\n" + "=" * 60)
print("ÉTAPE 3: Export multi-platformes")
print("=" * 60)
for platform in ["shopify", "woocommerce", "custom"]:
export = pipeline.exporter_ab_ready(
analyse_file="./ecommerce_pipeline_output/analyses/analyse_gen_chaussure_runner.json",
platform=platform
)
print(f"✅ Export {platform}: {len(export['variations'])} variations")
print("\n🎉 Pipeline complété avec succès!")
Calculateur de ROI et Optimisation des Coûts
Un aspect crucial que j'ai appris au fil des années : comprendre le coût réel de vos opérations multimodales. Avec HolySheep AI facturant Gemini Flash 2.5 à $2.50 par million de tokens (contre $2.50 également pour l'API officielle, mais avec des frais cachés et des restrictions de paiement), l'économie est significative quand on utilise les bons patterns.
| Modèle | Prix officiel | HolySheep | Économie |
|---|---|---|---|
| GPT-4.1 | $8.00/MTok | - | - |
| Claude Sonnet 4.5 | $15.00/MTok | - | - |
| Gemini 2.5 Flash | $2.50/MTok | $2.50/MTok | Same price + WeChat/Alipay |
| DeepSeek V3.2 | $0.42/MTok | $0.42/MTok | Same + no restrictions |
Erreurs courantes et solutions
1. Erreur 400: Invalid Image Format
Symptôme : L'API retourne une erreur 400 avec le message "Invalid image format or size".
Cause : Le format de l'image n'est pas supporté ou la taille dépasse la limite de 20MB.
# ❌ MAUVAIS - Erreur fréquente
payload = {
"contents": [{
"parts": [{
"inline_data": {
"mime_type": "image/png", # ou "image/webp", etc.
"data": base64_encoded_string
}
}]
}]
}
✅ CORRECT - Conversion préalable
from PIL import Image
import io
def prepare_image(image_path, max_size_mb=4, target_format="JPEG"):
"""Convertit et optimise l'image pour l'API Gemini"""
img = Image.open(image_path)
# Conversion en RGB si nécessaire
if img.mode in ('RGBA', 'P'):
img = img.convert('RGB')
# Redimensionnement si trop grand
max_dim = 2048
if max(img.size) > max_dim:
ratio = max_dim / max(img.size)
img = img.resize((int(img.width * ratio), int(img.height * ratio)))
# Compression
output = io.BytesIO()
img.save(output, format=target_format, quality=85, optimize=True)
# Vérification taille
size_mb = len(output.getvalue()) / (1024 * 1024)
if size_mb > max_size_mb:
# Réduction supplémentaire
quality =