|
|
|
|
|
|
|
|
|
import os |
|
import gradio as gr |
|
from transformers import AutoModelForCausalLM, AutoTokenizer |
|
from pptx import Presentation |
|
from pptx.util import Inches, Pt |
|
import torch |
|
import time |
|
|
|
|
|
MODEL_PATH = "ibm-granite/granite-3.1-3b-a800m-Instruct" |
|
|
|
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 au format Markdown 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 |
|
|
|
DIAPO 2: |
|
Titre: [Titre de la diapo] |
|
Points: |
|
- Point 1 |
|
- Point 2 |
|
- Point 3 |
|
|
|
[Continuez avec ce format pour chaque diapositive] |
|
|
|
Analysez le texte suivant et créez une présentation professionnelle :""" |
|
|
|
class ExecutionTimer: |
|
def __init__(self): |
|
self.start_time = None |
|
self.last_duration = None |
|
|
|
def start(self): |
|
self.start_time = time.time() |
|
|
|
def get_elapsed(self): |
|
if self.start_time is None: |
|
return 0 |
|
return time.time() - self.start_time |
|
|
|
def stop(self): |
|
if self.start_time is not None: |
|
self.last_duration = self.get_elapsed() |
|
self.start_time = None |
|
return self.last_duration |
|
|
|
def get_status(self): |
|
if self.start_time is not None: |
|
current = self.get_elapsed() |
|
last = f" (précédent: {self.last_duration:.2f}s)" if self.last_duration else "" |
|
return f"En cours... {current:.2f}s{last}" |
|
elif self.last_duration: |
|
return f"Terminé en {self.last_duration:.2f}s" |
|
return "En attente..." |
|
|
|
class PresentationGenerator: |
|
def __init__(self): |
|
print("Initialisation du modèle Granite...") |
|
self.tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH) |
|
self.model = AutoModelForCausalLM.from_pretrained( |
|
MODEL_PATH, |
|
torch_dtype=torch.float32, |
|
device_map="auto" |
|
) |
|
self.model.eval() |
|
print("Modèle initialisé avec succès!") |
|
|
|
def generate_text(self, prompt, temperature=0.7, max_tokens=2048): |
|
try: |
|
chat = [{"role": "user", "content": prompt}] |
|
formatted_prompt = self.tokenizer.apply_chat_template( |
|
chat, |
|
tokenize=False, |
|
add_generation_prompt=True |
|
) |
|
|
|
inputs = self.tokenizer( |
|
formatted_prompt, |
|
return_tensors="pt", |
|
truncation=True, |
|
max_length=4096 |
|
).to(self.model.device) |
|
|
|
with torch.no_grad(): |
|
outputs = self.model.generate( |
|
**inputs, |
|
max_new_tokens=max_tokens, |
|
temperature=temperature, |
|
do_sample=True, |
|
pad_token_id=self.tokenizer.eos_token_id |
|
) |
|
|
|
return self.tokenizer.decode(outputs[0], skip_special_tokens=True) |
|
|
|
except Exception as e: |
|
print(f"Erreur lors de la génération: {str(e)}") |
|
raise |
|
|
|
def parse_presentation_content(self, content): |
|
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': []} |
|
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()) |
|
|
|
if current_slide: |
|
slides.append(current_slide) |
|
|
|
return slides |
|
|
|
def create_presentation(self, slides): |
|
prs = Presentation() |
|
|
|
title_slide = prs.slides.add_slide(prs.slide_layouts[0]) |
|
title_slide.shapes.title.text = slides[0]['title'] |
|
|
|
for slide in slides[1:]: |
|
content_slide = prs.slides.add_slide(prs.slide_layouts[1]) |
|
content_slide.shapes.title.text = slide['title'] |
|
|
|
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 |
|
|
|
return prs |
|
|
|
|
|
timer = ExecutionTimer() |
|
|
|
def generate_skeleton(text, temperature, max_tokens): |
|
"""Génère le squelette de la présentation""" |
|
try: |
|
timer.start() |
|
generator = PresentationGenerator() |
|
|
|
full_prompt = PREPROMPT + "\n\n" + text |
|
generated_content = generator.generate_text(full_prompt, temperature, max_tokens) |
|
|
|
status = timer.get_status() |
|
timer.stop() |
|
|
|
return status, generated_content, gr.update(visible=True) |
|
|
|
except Exception as e: |
|
timer.stop() |
|
error_msg = f"Erreur: {str(e)}" |
|
print(error_msg) |
|
return error_msg, None, gr.update(visible=False) |
|
|
|
def create_presentation_file(generated_content): |
|
"""Crée le fichier PowerPoint à partir du contenu généré""" |
|
try: |
|
timer.start() |
|
generator = PresentationGenerator() |
|
|
|
slides = generator.parse_presentation_content(generated_content) |
|
prs = generator.create_presentation(slides) |
|
|
|
output_path = os.path.join(os.getcwd(), "presentation.pptx") |
|
prs.save(output_path) |
|
|
|
timer.stop() |
|
return output_path |
|
|
|
except Exception as e: |
|
timer.stop() |
|
print(f"Erreur lors de la création du fichier: {str(e)}") |
|
return None |
|
|
|
|
|
with gr.Blocks(theme=gr.themes.Glass()) 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): |
|
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" |
|
) |
|
|
|
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..." |
|
) |
|
|
|
with gr.Row(): |
|
generate_skeleton_btn = gr.Button("Générer le Squelette de la Présentation", variant="primary") |
|
|
|
with gr.Row(): |
|
with gr.Column(): |
|
status_output = gr.Textbox( |
|
label="Statut", |
|
lines=2, |
|
value="En attente..." |
|
) |
|
generated_content = gr.Textbox( |
|
label="Contenu généré", |
|
lines=10, |
|
show_copy_button=True |
|
) |
|
create_presentation_btn = gr.Button("Créer Présentation", visible=False) |
|
output_file = gr.File( |
|
label="Présentation PowerPoint", |
|
type="filepath" |
|
) |
|
|
|
generate_skeleton_btn.click( |
|
fn=generate_skeleton, |
|
inputs=[ |
|
input_text, |
|
temperature, |
|
max_tokens |
|
], |
|
outputs=[ |
|
status_output, |
|
generated_content, |
|
create_presentation_btn |
|
] |
|
) |
|
|
|
create_presentation_btn.click( |
|
fn=create_presentation_file, |
|
inputs=[generated_content], |
|
outputs=[output_file] |
|
) |
|
|
|
if __name__ == "__main__": |
|
demo.launch() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
