|
|
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( |
|
|
|
|
|
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 = """ |
|
|
|
|
|
.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; |
|
|
} |
|
|
|
|
|
|
|
|
h1, h2, h3, p, label, .gr-text { |
|
|
color: #ffffff !important; |
|
|
} |
|
|
|
|
|
|
|
|
::-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() |
