Spaces:
Runtime error
Runtime error
Download run.py from somoncef/glamflow-model: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/spaces/somoncef/glamflow-model/resolve/main/run.py
- Command line
-
hf download hf://spaces/somoncef/glamflow-model/run.py
-
curl -L -o run.py https://huggingface.co/spaces/somoncef/glamflow-model/resolve/main/run.py
10.3 kB
| from flask import Flask, request, jsonify | |
| from flask_cors import CORS | |
| import numpy as np | |
| import tensorflow.lite as tflite # REMARQUE: tf.lite.Interpreter sera supprimé dans TF 2.20, voir migration: https://ai.google.dev/edge/litert/migration | |
| import cv2 | |
| from PIL import Image | |
| import io | |
| import os | |
| from functools import wraps | |
| import requests | |
| from dotenv import load_dotenv | |
| app = Flask(__name__) | |
| # Configuration CORS spécifique pour le frontend déployé | |
| CORS(app, resources={r"/*": {"origins": ["https://app.glamflow.ma", "https://analysepeaux.vercel.app"]}}) | |
| # Middleware pour vérifier l'origine des requêtes | |
| def check_origin(f): | |
| def decorated_function(*args, **kwargs): | |
| # Ignorer toutes les vérifications en mode debug | |
| if app.debug: | |
| return f(*args, **kwargs) | |
| origin = request.headers.get('Origin', '') | |
| referer = request.headers.get('Referer', '') | |
| # Autoriser les requêtes provenant des domaines autorisés | |
| if any(domain in origin or domain in referer for domain in ['https://app.glamflow.ma', 'https://analysepeaux.vercel.app']): | |
| return f(*args, **kwargs) | |
| else: | |
| return jsonify({'error': 'Unauthorized origin'}), 403 | |
| return decorated_function | |
| # Charger les variables d'environnement | |
| load_dotenv() | |
| GROQ_API_KEY = os.getenv('GROQ_API_KEY') | |
| # Image Size | |
| IMG_SIZE = (150, 150) | |
| # Load TFLite models globally | |
| models_dir = os.path.join(os.path.dirname(__file__), "saved_models") | |
| interpreter_type = tflite.Interpreter(model_path=os.path.join(models_dir, "skin_type_model.tflite")) | |
| interpreter_disease = tflite.Interpreter(model_path=os.path.join(models_dir, "skin_disease_model.tflite")) | |
| interpreter_type.allocate_tensors() | |
| interpreter_disease.allocate_tensors() | |
| # Label mappings | |
| skin_type_labels = {0: 'Sèche', 1: 'Normale', 2: 'Grasse'} | |
| skin_disease_labels = {0: 'Acné', 1: 'Mélanome', 2: 'Psoriasis', 3: 'Rosacée', 4: 'Vitiligo'} | |
| # Recommendations pour les différents types de peau | |
| skin_type_recommendations = { | |
| "Sèche": "💧 Hydratez bien, évitez les douches chaudes et utilisez une crème hydratante épaisse.", | |
| "Grasse": "🧴 Utilisez des soins légers et sans huile. Nettoyez deux fois par jour.", | |
| "Normale": "🌿 Maintenez une routine équilibrée, utilisez un écran solaire et hydratez bien." | |
| } | |
| # Recommendations pour les différentes maladies de peau | |
| disease_treatment = { | |
| "Acné": "🔬 Utilisez de l'acide salicylique, évitez de toucher votre visage et nettoyez bien.", | |
| "Mélanome": "🛀 Utilisez des crèmes sans parfum, évitez les allergènes et gérez votre stress.", | |
| "Psoriasis": "🩺 Hydratez souvent, utilisez des traitements médicamenteux et évitez les déclencheurs.", | |
| "Rosacée": "☀️ Évitez les aliments épicés, utilisez des soins doux et portez un écran solaire.", | |
| "Vitiligo": "🌞 Utilisez des sérums éclaircissants, évitez l'exposition au soleil et appliquez un SPF 50+." | |
| } | |
| # Charger le détecteur de visage Haar Cascade | |
| face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') | |
| def detect_face(image_array): | |
| """Détecte si l'image contient un visage""" | |
| gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY) | |
| faces = face_cascade.detectMultiScale(gray, 1.1, 4) | |
| return len(faces) > 0 | |
| def predict_skin_condition(image_array): | |
| img = cv2.resize(image_array, IMG_SIZE) | |
| img = img / 255.0 | |
| img = np.expand_dims(img, axis=0).astype(np.float32) | |
| # Skin Type Prediction | |
| input_tensor_index = interpreter_type.get_input_details()[0]['index'] | |
| interpreter_type.set_tensor(input_tensor_index, img) | |
| interpreter_type.invoke() | |
| output_tensor_index = interpreter_type.get_output_details()[0]['index'] | |
| type_pred = interpreter_type.get_tensor(output_tensor_index) | |
| # Skin Disease Prediction | |
| input_tensor_index = interpreter_disease.get_input_details()[0]['index'] | |
| interpreter_disease.set_tensor(input_tensor_index, img) | |
| interpreter_disease.invoke() | |
| output_tensor_index = interpreter_disease.get_output_details()[0]['index'] | |
| disease_pred = interpreter_disease.get_tensor(output_tensor_index) | |
| # Results processing | |
| skin_type = skin_type_labels[np.argmax(type_pred)] | |
| skin_disease = skin_disease_labels[np.argmax(disease_pred)] | |
| type_confidence = float(np.max(type_pred) * 100) | |
| disease_confidence = float(np.max(disease_pred) * 100) | |
| type_probabilities = {skin_type_labels[i]: float(prob * 100) for i, prob in enumerate(type_pred[0])} | |
| disease_probabilities = {skin_disease_labels[i]: float(prob * 100) for i, prob in enumerate(disease_pred[0])} | |
| return { | |
| 'skin_type': { | |
| 'prediction': skin_type, | |
| 'confidence': round(type_confidence, 2), | |
| 'probabilities': {k: round(v, 2) for k, v in type_probabilities.items()} | |
| }, | |
| 'skin_disease': { | |
| 'prediction': skin_disease, | |
| 'confidence': round(disease_confidence, 2), | |
| 'probabilities': {k: round(v, 2) for k, v in disease_probabilities.items()} | |
| }, | |
| 'recommendations': { | |
| 'skin_type': skin_type_recommendations[skin_type], | |
| 'skin_disease': disease_treatment[skin_disease] | |
| } | |
| } | |
| def get_ai_analysis(analysis_results): | |
| """Obtenir une analyse détaillée via Groq LLM""" | |
| headers = { | |
| "Content-Type": "application/json", | |
| "Authorization": f"Bearer {GROQ_API_KEY}" | |
| } | |
| prompt = f"""Analyse ces résultats dermatologiques et fournis une réponse structurée avec exactement les 3 sections suivantes, séparées par [SECTION]: | |
| Type de peau: {analysis_results['skin_type']['prediction']} (confiance: {analysis_results['skin_type']['confidence']}%) | |
| Condition détectée: {analysis_results['skin_disease']['prediction']} (confiance: {analysis_results['skin_disease']['confidence']}%) | |
| Distributions des probabilités: | |
| Types de peau: {analysis_results['skin_type']['probabilities']} | |
| Conditions: {analysis_results['skin_disease']['probabilities']} | |
| Réponds en utilisant exactement ce format: | |
| [SECTION] | |
| Interprétation détaillée des résultats dermatologiques | |
| [SECTION] | |
| Conseils supplémentaires personnalisés | |
| [SECTION] | |
| Recommandations pour une routine quotidienne""" | |
| try: | |
| response = requests.post( | |
| "https://api.groq.com/openai/v1/chat/completions", | |
| headers=headers, | |
| json={ | |
| "model": "llama-3.3-70b-versatile", | |
| "messages": [{ | |
| "role": "user", | |
| "content": prompt | |
| }] | |
| } | |
| ) | |
| if response.status_code == 200: | |
| content = response.json()["choices"][0]["message"]["content"] | |
| # Diviser la réponse en sections | |
| sections = content.split("[SECTION]") | |
| sections = [s.strip() for s in sections if s.strip()] # Nettoyer les sections | |
| # Structurer la réponse | |
| if len(sections) >= 3: | |
| return { | |
| "interpretation": sections[0], | |
| "conseils": sections[1], | |
| "routine": sections[2] | |
| } | |
| else: | |
| return { | |
| "interpretation": "Analyse non disponible", | |
| "conseils": "Conseils non disponibles", | |
| "routine": "Routine non disponible" | |
| } | |
| else: | |
| return { | |
| "interpretation": "Analyse non disponible", | |
| "conseils": "Conseils non disponibles", | |
| "routine": "Routine non disponible" | |
| } | |
| except Exception as e: | |
| print(f"Erreur lors de l'appel à Groq: {str(e)}") | |
| return { | |
| "interpretation": "Erreur lors de l'analyse", | |
| "conseils": "Conseils non disponibles", | |
| "routine": "Routine non disponible" | |
| } | |
| def home(): | |
| return jsonify({ | |
| "message": "GlamFlow AI API - Services disponibles:", | |
| "endpoints": [ | |
| "/predict - Analyse complète de la peau (type et maladie)", | |
| "/health - Vérification de l'état des modèles", | |
| "/preload - Préchargement des modèles" | |
| ] | |
| }), 200 | |
| def predict(): | |
| if 'file' not in request.files: | |
| return jsonify({'error': 'Aucun fichier fourni'}), 400 | |
| file = request.files['file'] | |
| if file.filename == '': | |
| return jsonify({'error': 'Aucun fichier sélectionné'}), 400 | |
| if file: | |
| try: | |
| # Lire l'image et la convertir en format compatible | |
| image_bytes = file.read() | |
| image = Image.open(io.BytesIO(image_bytes)).convert("RGB") | |
| image_array = np.array(image) | |
| # Vérifier la présence d'un visage | |
| if not detect_face(image_array): | |
| return jsonify({ | |
| 'error': 'Aucun visage n\'est détecté dans l\'image. Veuillez choisir une photo claire de votre visage pour effectuer l\'analyse.' | |
| }), 400 | |
| # Analyser l'image avec les deux modèles | |
| results = predict_skin_condition(image_array) | |
| # Obtenir l'analyse IA supplémentaire | |
| ai_analysis = get_ai_analysis(results) | |
| results['ai_analysis'] = ai_analysis | |
| return jsonify(results), 200 | |
| except Exception as e: | |
| return jsonify({'error': str(e)}), 500 | |
| def preload_models(): | |
| """Précharge les modèles pour éviter les délais lors de la première prédiction""" | |
| return jsonify({'status': 'Models preloaded successfully'}), 200 | |
| def health_check(): | |
| models_loaded = { | |
| 'skin_type_model': True, | |
| 'skin_disease_model': True | |
| } | |
| return jsonify({ | |
| 'status': 'healthy', | |
| 'models': models_loaded | |
| }), 200 | |
| if __name__ == '__main__': | |
| app.run(host='0.0.0.0', port=5000, debug=True) |