| | |
| | |
| | |
| |
|
| | 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() |
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
