glamflow-model / run.py
somoncef
kkjjkj
84f2ef9
Raw History Blame Contribute Delete
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):
@wraps(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"
}
@app.route('/')
@check_origin
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
@app.route('/predict', methods=['POST'])
@check_origin
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
@app.route('/preload', methods=['GET'])
@check_origin
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
@app.route('/health', methods=['GET'])
@check_origin
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)