Analyse d’images avec un Raspberry PI5

La présentation suivante et le programme présenté ont été réalisés à l’aide de Chat Gpt. L’application a été expérimentée sur un raspberry pi5 possédant 8 GO de ram. Les temps de réponse sont de l’ordre de quelques dizaines de secondes pour décrire une image et d’une dizaine de secondes pour répondre à une question.

Présentation du Programme d’Analyse Interactive d’Images

Le programme présenté est une application interactive développée avec Tkinter, conçue pour analyser des images à l’aide de modèles d’intelligence artificielle. Il offre deux fonctionnalités principales : la génération de descriptions d’images et la réponse à des questions posées en rapport avec ces images. Voici un aperçu détaillé des modules d’intelligence artificielle utilisés dans ce programme ainsi que les modules nécessaires à installer.

Modules d’Intelligence Artificielle Utilisés

BLIP (Bootstrapping Language Image Pre-training)
- Modules : BlipProcessor, BlipForConditionalGeneration, BlipForQuestionAnswering
- Description : BLIP est utilisé pour deux tâches distinctes. D’une part, le modèle BlipForConditionalGeneration génère des descriptions d’images. D’autre part, le modèle BlipForQuestionAnswering répond à des questions spécifiques posées sur les images.
MarianMT (Marian Machine Translation)
- Modules : MarianMTModel, MarianTokenizer
- Description : MarianMT est utilisé pour la traduction automatique entre l’anglais et le français. Les modèles Helsinki-NLP/opus-mt-en-fr et Helsinki-NLP/opus-mt-fr-en permettent de traduire les descriptions générées et les réponses des questions de l’anglais vers le français et vice versa.

Modules Python à Installer

Pour faire fonctionner ce programme, vous devez installer les modules suivants via pip :

certifi==2024.7.4
charset-normalizer==3.3.2
click==8.1.7
Cython==3.0.11
filelock==3.15.4
fsspec==2024.6.1
huggingface_hub==0.24.5
idna==3.7
Jinja2==3.1.4
joblib==1.4.2
MarkupSafe==2.1.5
mpmath==1.3.0
networkx==3.3
numpy==2.1.0
opencv-python-headless==4.10.0.84
packaging==24.1
pillow==10.4.0
PyYAML==6.0.2
regex==2024.7.24
requests==2.32.3
sacremoses==0.1.1
safetensors==0.4.4
sentencepiece==0.2.0
sympy==1.13.2
tokenizers==0.19.1
torch==2.4.0
torchaudio==2.4.0
torchvision==0.19.0
tqdm==4.66.5
transformers==4.44.0
typing_extensions==4.12.2
urllib3==2.2.2

Python

import tkinter as tk
from tkinter import filedialog, messagebox
from transformers import BlipProcessor, BlipForConditionalGeneration, BlipForQuestionAnswering, MarianMTModel, MarianTokenizer
from PIL import Image, ImageTk
import torch,threading,time

# Charger les modèles et processeurs
blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
vqa_processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
vqa_model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")

en_to_fr_model_name = 'Helsinki-NLP/opus-mt-en-fr'
en_to_fr_tokenizer = MarianTokenizer.from_pretrained(en_to_fr_model_name)
en_to_fr_model = MarianMTModel.from_pretrained(en_to_fr_model_name)

fr_to_en_model_name = 'Helsinki-NLP/opus-mt-fr-en'
fr_to_en_tokenizer = MarianTokenizer.from_pretrained(fr_to_en_model_name)
fr_to_en_model = MarianMTModel.from_pretrained(fr_to_en_model_name)

class CaptionAndVQAApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Analyse interactive d'images")

        # Section de génération de description d'image
        self.label = tk.Label(root, text="Sélectionnez une image pour commencer")
        self.label.pack(pady=10)

        self.image_label = tk.Label(root)
        self.image_label.pack(pady=10)

        # Frame pour la description en français
        self.fr_caption_frame = tk.Frame(root)
        self.fr_caption_frame.pack(pady=10)

        self.fr_caption_label = tk.Label(self.fr_caption_frame, text="Description")
        self.fr_caption_label.grid(row=0, column=0, sticky="w", padx=10)

        self.fr_caption_text = tk.Text(self.fr_caption_frame, height=5, width=50)
        self.fr_caption_text.grid(row=0, column=1)

        # Frame pour la question en français
        self.question_frame = tk.Frame(root)
        self.question_frame.pack(pady=5)

        self.question_label = tk.Label(self.question_frame, text="Question")
        self.question_label.grid(row=0, column=0, sticky="w", padx=10)

        self.question_entry = tk.Entry(self.question_frame, width=50)
        self.question_entry.grid(row=0, column=1)

        # Frame pour la réponse en français
        self.answer_frame = tk.Frame(root)
        self.answer_frame.pack(pady=5)

        self.answer_label = tk.Label(self.answer_frame, text="Réponse")
        self.answer_label.grid(row=0, column=0, sticky="w", padx=10)

        self.answer_text = tk.Text(self.answer_frame, height=3, width=50)
        self.answer_text.grid(row=0, column=1)

        # Frame pour les boutons
        self.button_frame = tk.Frame(root)
        self.button_frame.pack(pady=10)

        button_width = 20
        self.select_button = tk.Button(self.button_frame, text="Sélectionner une image", command=self.open_image, width=button_width)
        self.select_button.grid(row=0, column=0, padx=5)

        self.generate_caption_button = tk.Button(self.button_frame, text="Générer une description", command=self.start_caption_generation, width=button_width)
        self.generate_caption_button.grid(row=0, column=1, padx=5)

        self.ask_button = tk.Button(self.button_frame, text="Poser la question", command=self.start_processing, width=button_width)
        self.ask_button.grid(row=0, column=2, padx=5)

        self.clear_button = tk.Button(self.button_frame, text="Effacer", command=self.clear_text, width=button_width)
        self.clear_button.grid(row=0, column=3, padx=5)

        self.image = None
        self.animation_running = False
        self.animation_step = 0

    def open_image(self):
        file_path = filedialog.askopenfilename()
        if file_path:
            self.image = Image.open(file_path)
            self.image.thumbnail((400, 400))
            img = ImageTk.PhotoImage(self.image)
            self.image_label.config(image=img)
            self.image_label.image = img

    def animate(self, button):
        if self.animation_running:
            self.animation_step = (self.animation_step + 1) % 4
            animation_text = "." * self.animation_step
            button.config(text=f"Je réfléchis {animation_text}")
            self.root.after(500, self.animate, button)

    def start_caption_generation(self):
        if not self.image:
            messagebox.showerror("Erreur", "Veuillez sélectionner une image d'abord.")
            return

        # Effacer la zone de texte avant de commencer
        self.fr_caption_text.delete(1.0, tk.END)

        # Démarrer l'animation
        self.animation_running = True
        self.animate(self.generate_caption_button)

        # Exécuter la génération de la légende dans un thread séparé
        threading.Thread(target=self.generate_caption).start()

    def generate_caption(self):
        start_time = time.time()  # Démarrer le chronomètre

        # Préparer l'image pour le modèle BLIP
        inputs = blip_processor(self.image, return_tensors="pt")

        # Générer la légende en anglais
        out = blip_model.generate(
            **inputs,
            min_length=50,
            max_length=100,
            temperature=1.0,
            repetition_penalty=1.2,
            no_repeat_ngram_size=2,
            top_k=50
        )

        caption = blip_processor.decode(out[0], skip_special_tokens=True)

        # Traduire la description en français
        translated = en_to_fr_model.generate(**en_to_fr_tokenizer(caption, return_tensors="pt", padding=True))
        translated_text = en_to_fr_tokenizer.decode(translated[0], skip_special_tokens=True)

        # Arrêter l'animation
        self.animation_running = False
        self.generate_caption_button.config(text="Générer Description")

        # Calculer et afficher le temps écoulé
        elapsed_time = time.time() – start_time
        translated_text += f"\n(Temps de réflexion : {elapsed_time:.2f} secondes)"

        # Afficher la description en français
        self.fr_caption_text.insert(tk.END, translated_text)

    def start_processing(self):
        if not self.image:
            messagebox.showerror("Erreur", "Veuillez sélectionner une image d'abord.")
            return

        question_fr = self.question_entry.get()
        if not question_fr:
            messagebox.showerror("Erreur", "Veuillez entrer une question en français.")
            return

        self.answer_text.delete(1.0, tk.END)
        self.animation_running = True
        self.animate(self.ask_button)

        threading.Thread(target=self.ask_question, args=(question_fr,)).start()

    def ask_question(self, question_fr):
        start_time = time.time()

        # Traduire la question en anglais
        inputs_fr_to_en = fr_to_en_tokenizer(question_fr, return_tensors="pt", padding=True)
        question_en = fr_to_en_model.generate(**inputs_fr_to_en)
        question_en_text = fr_to_en_tokenizer.decode(question_en[0], skip_special_tokens=True)

        # Préparer les inputs pour le modèle VQA
        inputs = vqa_processor(self.image, question_en_text, return_tensors="pt")

        # Générer la réponse en anglais
        with torch.no_grad():
            outputs = vqa_model.generate(**inputs)
            answer_en = vqa_processor.decode(outputs[0], skip_special_tokens=True)

        # Traduire la réponse en français
        inputs_en_to_fr = en_to_fr_tokenizer(answer_en, return_tensors="pt", padding=True)
        answer_fr = en_to_fr_model.generate(**inputs_en_to_fr)
        answer_fr_text = en_to_fr_tokenizer.decode(answer_fr[0], skip_special_tokens=True)

        self.animation_running = False
        self.ask_button.config(text="Poser la question")

        elapsed_time = time.time() – start_time
        answer_fr_text += f"\n(Temps de réflexion : {elapsed_time:.2f} secondes)"

        self.answer_text.insert(tk.END, answer_fr_text)

    def clear_text(self):
        self.fr_caption_text.delete(1.0, tk.END)
        self.question_entry.delete(0, tk.END)
        self.answer_text.delete(1.0, tk.END)

# Créer l'application Tkinter
root = tk.Tk()
app = CaptionAndVQAApp(root)
root.mainloop()

Grimeco

Analyse d’images avec un Raspberry PI5

Présentation du Programme d’Analyse Interactive d’Images

Modules d’Intelligence Artificielle Utilisés

Modules Python à Installer

A DECOUVRIR EGALEMENT

Redimensionnement de vidéos en Python

Gestion d’un ruban de leds

Raspberry PI5 Leds WS2812b

Laisser un commentaire Annuler la réponse