import os
import gradio as gr
from huggingface_hub import hf_hub_download, login
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.enum.text import PP_ALIGN
import torch
from llama_cpp import Llama
import time
from PIL import Image
import io
import requests
from diffusers import FluxPipeline
# Configuration des modèles disponibles
TEXT_MODELS = {
"Mistral Nemo 2407 (GGUF)": "MisterAI/Bartowski_MistralAI_Mistral-Nemo-Instruct-2407-IQ4_XS.gguf",
"Mixtral 8x7B": "mistralai/Mixtral-8x7B-v0.1",
"Lucie 7B": "OpenLLM-France/Lucie-7B"
}
IMAGE_MODELS = {
"FLUX.1": "black-forest-labs/FLUX.1-schnell",
"ArtifyAI": "ImageInception/ArtifyAI-v1.1"
}
# Préprompt amélioré pour une meilleure structuration
PREPROMPT = """Vous êtes un assistant IA expert en création de présentations PowerPoint professionnelles.
Générez une présentation structurée et détaillée en suivant ce format EXACT:
TITRE: [Titre principal de la présentation]
DIAPO 1:
Titre: [Titre de la diapo]
Points:
- Point 1
- Point 2
- Point 3
Image: [Description détaillée de l'image souhaitée pour cette diapo. Soyez très précis dans la description pour permettre
une génération d'image de qualité. Par exemple : "Une illustration professionnelle montrant un concept clé de cybersécurité
avec des éléments visuels modernes, un style épuré et des couleurs corporate (fond noir, couleurs bleu electrique, rouge, gris, blanc).
L'image doit être claire, minimaliste et adaptée à une présentation professionnelle."]
DIAPO 2:
Titre: [Titre de la diapo]
Points:
- Point 1
- Point 2
- Point 3
Image: [Description détaillée de l'image souhaitée pour cette diapo]
[Continuez avec ce format pour chaque diapositive]
Analysez le texte suivant et créez une présentation professionnelle avec des descriptions d'images pertinentes :"""
class PresentationGenerator:
def __init__(self):
self.token = os.getenv('Authentification_HF')
if not self.token:
raise ValueError("Token d'authentification HuggingFace non trouvé")
login(self.token)
self.text_model = None
self.text_tokenizer = None
self.image_pipeline = None
def load_text_model(self, model_name):
"""Charge le modèle de génération de texte"""
model_id = TEXT_MODELS[model_name]
if model_id.endswith('.gguf'):
# Configuration pour les modèles GGUF
model_path = hf_hub_download(
repo_id=model_id.split('/')[0] + '/' + model_id.split('/')[1],
filename=model_id.split('/')[-1],
token=self.token
)
self.text_model = Llama(
model_path=model_path,
n_ctx=4096,
n_batch=512,
verbose=False
)
else:
# Configuration pour les modèles Transformers standards
self.text_tokenizer = AutoTokenizer.from_pretrained(model_id, token=self.token)
self.text_model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.bfloat16,
device_map="auto",
token=self.token
)
# def load_image_model(self, model_name):
# """Charge le modèle de génération d'images"""
# model_id = IMAGE_MODELS[model_name]
# self.image_pipeline = pipeline(
# "text-to-image",
# model=model_id,
# token=self.token
# )
##Modif01 : Correction Pour Flux Non Chargé sur HFSpace
# def load_image_model(self, model_name):
# """Charge le modèle de génération d'images"""
# model_id = IMAGE_MODELS[model_name]
# if model_id == "black-forest-labs/FLUX.1-schnell":
# self.image_pipeline = FluxPipeline.from_pretrained(
# model_id,
# torch_dtype=torch.bfloat16
# )
# self.image_pipeline.enable_model_cpu_offload() # Économise de la VRAM en déchargeant le modèle sur le CPU
# print(f"Modèle d'image FLUX chargé : {model_id}")
# else:
# self.image_pipeline = pipeline(
# "text-to-image",
# model=model_id,
# token=self.token
# )
# print(f"Modèle d'image chargé : {model_id}")
##Modif02 : Correction Pour Flux Blocage Chargement a 71% sur HFSpace
#Loading pipeline components...: 71%|███████▏ | 5/7 [00:05<00:01, 1.07it/s]You set `add_prefix_space`.
#The tokenizer needs to be converted from the slow tokenizers
#Loading pipeline components...: 71%|███████▏ | 5/7 [00:05<00:02, 1.15s/it]
def load_image_model(self, model_name):
"""Charge le modèle de génération d'images"""
model_id = IMAGE_MODELS[model_name]
if model_id == "black-forest-labs/FLUX.1-schnell":
self.image_pipeline = FluxPipeline.from_pretrained(
model_id,
revision="refs/pr/1", # Utiliser une révision spécifique
torch_dtype=torch.bfloat16
)
self.image_pipeline.enable_model_cpu_offload() # Économise de la VRAM en déchargeant le modèle sur le CPU
self.image_pipeline.tokenizer.add_prefix_space = False # Désactive add_prefix_space
print(f"Modèle d'image FLUX chargé : {model_id}")
else:
self.image_pipeline = pipeline(
"text-to-image",
model=model_id,
token=self.token
)
print(f"Modèle d'image chargé : {model_id}")
def generate_text(self, prompt, temperature=0.7, max_tokens=4096):
"""Génère le texte de la présentation"""
if isinstance(self.text_model, Llama):
response = self.text_model(
prompt,
max_tokens=max_tokens,
temperature=temperature,
echo=False
)
return response['choices'][0]['text']
else:
inputs = self.text_tokenizer.apply_chat_template(
[{"role": "user", "content": prompt}],
return_tensors="pt",
return_dict=True
)
outputs = self.text_model.generate(
**inputs,
max_new_tokens=max_tokens,
temperature=temperature
)
return self.text_tokenizer.decode(outputs[0], skip_special_tokens=True)
# def generate_image(self, prompt, negative_prompt="", num_inference_steps=30):
# """Génère une image pour la diapositive"""
# try:
# image = self.image_pipeline(
# prompt=prompt,
# negative_prompt=negative_prompt,
# num_inference_steps=num_inference_steps
# )[0] # Pipeline retourne une liste d'images, on prend la première
# return image
# except Exception as e:
# print(f"Erreur lors de la génération de l'image: {str(e)}")
# return None
##Modif01 : Correction Pour Flux Non Chargé sur HFSpace
def generate_image(self, prompt, negative_prompt="", num_inference_steps=30):
"""Génère une image pour la diapositive"""
try:
if isinstance(self.image_pipeline, FluxPipeline):
image = self.image_pipeline(
prompt=prompt,
guidance_scale=0.0,
num_inference_steps=num_inference_steps,
max_sequence_length=256,
generator=torch.Generator("cpu").manual_seed(0)
).images[0]
else:
image = self.image_pipeline(
prompt=prompt,
negative_prompt=negative_prompt,
num_inference_steps=num_inference_steps
)[0] # Pipeline retourne une liste d'images, on prend la première
return image
except Exception as e:
print(f"Erreur lors de la génération de l'image: {str(e)}")
return None
def parse_presentation_content(self, content):
"""Parse le contenu généré en sections pour les diapositives"""
slides = []
current_slide = None
for line in content.split('\n'):
line = line.strip()
if line.startswith('TITRE:'):
slides.append({'type': 'title', 'title': line[6:].strip()})
elif line.startswith('DIAPO'):
if current_slide:
slides.append(current_slide)
current_slide = {'type': 'content', 'title': '', 'points': [], 'image_prompt': ''}
elif line.startswith('Titre:') and current_slide:
current_slide['title'] = line[6:].strip()
elif line.startswith('- ') and current_slide:
current_slide['points'].append(line[2:].strip())
elif line.startswith('Image:') and current_slide:
current_slide['image_prompt'] = line[6:].strip()
if current_slide:
slides.append(current_slide)
return slides
def create_presentation(self, slides):
"""Crée la présentation PowerPoint avec texte et images"""
prs = Presentation()
# Première diapo (titre)
title_slide = prs.slides.add_slide(prs.slide_layouts[0])
title_slide.shapes.title.text = slides[0]['title']
# Autres diapos
for slide in slides[1:]:
content_slide = prs.slides.add_slide(prs.slide_layouts[1])
content_slide.shapes.title.text = slide['title']
# Ajout du texte
if slide['points']:
body = content_slide.shapes.placeholders[1].text_frame
body.clear()
for point in slide['points']:
p = body.add_paragraph()
p.text = point
p.level = 0
# Ajout de l'image si disponible
if slide.get('image_prompt'):
image = self.generate_image(slide['image_prompt'])
if image:
# Sauvegarde temporaire de l'image
img_path = f"temp_slide_{slides.index(slide)}.png"
image.save(img_path)
# Ajout de l'image à la diapositive
left = Inches(1)
top = Inches(2.5)
content_slide.shapes.add_picture(img_path, left, top, height=Inches(4))
# Suppression du fichier temporaire
os.remove(img_path)
return prs
def generate_presentation_with_progress(text, text_model_name, image_model_name, temperature, max_tokens, negative_prompt):
"""Fonction principale de génération avec suivi de progression"""
try:
start_time = time.time()
generator = PresentationGenerator()
# Chargement des modèles
yield "Chargement des modèles...", None, None
generator.load_text_model(text_model_name)
generator.load_image_model(image_model_name)
# Génération du contenu
yield "Génération du contenu de la présentation...", None, None
full_prompt = PREPROMPT + "\n\n" + text
generated_content = generator.generate_text(full_prompt, temperature, max_tokens)
# Création de la présentation
yield "Création de la présentation PowerPoint...", generated_content, None
slides = generator.parse_presentation_content(generated_content)
prs = generator.create_presentation(slides)
# Sauvegarde
output_path = "presentation.pptx"
prs.save(output_path)
execution_time = time.time() - start_time
status = f"Présentation générée avec succès en {execution_time:.2f} secondes!"
return status, generated_content, output_path
except Exception as e:
return f"Erreur: {str(e)}", None, None
# CSS personnalisé pour un thème sombre amélioré
css = """
/* Thème sombre personnalisé */
.gradio-container {
background-color: #000000 !important;
}
.gr-form, .gr-box, .gr-panel {
border-radius: 8px !important;
background-color: #1a1a1a !important;
border: 1px solid #333333 !important;
}
.gr-input, .gr-textarea, .gr-dropdown {
background-color: #2d2d2d !important;
color: #ffffff !important;
border: 1px solid #404040 !important;
}
.gr-button {
background-color: #2d2d2d !important;
color: #ffffff !important;
border: 1px solid #404040 !important;
transition: all 0.3s ease !important;
}
.gr-button:hover {
background-color: #404040 !important;
transform: translateY(-2px) !important;
}
/* Textes et labels */
h1, h2, h3, p, label, .gr-text {
color: #ffffff !important;
}
/* Scrollbar */
::-webkit-scrollbar {
width: 8px;
height: 8px;
}
::-webkit-scrollbar-track {
background: #1a1a1a;
}
::-webkit-scrollbar-thumb {
background: #404040;
border-radius: 4px;
}
::-webkit-scrollbar-thumb:hover {
background: #4a4a4a;
}
"""
with gr.Blocks(theme=gr.themes.Default(), css=css) as demo:
gr.Markdown(
"""
# 🎯 Générateur de Présentations PowerPoint IA
Créez des présentations professionnelles automatiquement avec l'aide de l'IA.
"""
)
with gr.Row():
with gr.Column(scale=1):
text_model_choice = gr.Dropdown(
choices=list(TEXT_MODELS.keys()),
value=list(TEXT_MODELS.keys())[0],
label="Modèle de génération de texte"
)
image_model_choice = gr.Dropdown(
choices=list(IMAGE_MODELS.keys()),
value=list(IMAGE_MODELS.keys())[0],
label="Modèle de génération d'images"
)
temperature = gr.Slider(
minimum=0.1,
maximum=1.0,
value=0.7,
step=0.1,
label="Température"
)
max_tokens = gr.Slider(
minimum=1000,
maximum=4096,
value=2048,
step=256,
label="Tokens maximum"
)
negative_prompt = gr.Textbox(
lines=2,
label="Prompt négatif pour les images",
placeholder="Ce que vous ne voulez pas voir dans les images..."
)
with gr.Row():
with gr.Column(scale=2):
input_text = gr.Textbox(
lines=10,
label="Votre texte",
placeholder="Décrivez le contenu que vous souhaitez pour votre présentation..."
)
# Modification du composant File pour supprimer l'argument multiple
file_upload = gr.File(
label="Documents de référence (PDF, Images)",
file_types=["pdf", "png", "jpg", "jpeg"]
)
with gr.Row():
generate_btn = gr.Button("🚀 Générer la présentation", variant="primary")
with gr.Row():
with gr.Column():
status_output = gr.Textbox(
label="Statut",
lines=2
)
generated_content = gr.Textbox(
label="Contenu généré",
lines=10,
show_copy_button=True
)
output_file = gr.File(
label="Présentation PowerPoint"
)
generate_btn.click(
fn=generate_presentation_with_progress,
inputs=[
input_text,
text_model_choice,
image_model_choice,
temperature,
max_tokens,
negative_prompt
],
outputs=[
status_output,
generated_content,
output_file
]
)
if __name__ == "__main__":
demo.launch()