Integracja modelu OpenAI o1-preview w skrypcie Pythona z obsługą wyrażeń LaTeX

Dowiedz się, jak zintegrować nowy model OpenAI o1-preview w skrypcie Pythona, aby wzbogacić swoje projekty sztucznej inteligencji. Ten skrypt umożliwia interakcję z API OpenAI przy użyciu modelu o1-preview, z możliwością dołączania zawartości stron internetowych do promptów dzięki funkcji web scraping. Dodatkowo poprawnie obsługuje wyrażenia matematyczne LaTeX w odpowiedziach modelu, konwertując je na czytelny tekst Unicode w terminalu.

Wprowadzenie

12 września 2024 roku OpenAI wprowadziło nową serię modeli AI nazwaną OpenAI o1. Modele te są zaprojektowane tak, aby wykonywać głębsze rozumowanie przed udzieleniem odpowiedzi, co pozwala im rozwiązywać złożone problemy w nauce, programowaniu i matematyce. Model o1-preview wyróżnia się szczególnie w tych obszarach, przewyższając wcześniejsze modele, takie jak gpt-4o.

Najważniejsze punkty skryptu:

• Integracja modelu o1-preview: Skrypt domyślnie używa modelu o1-preview, oferując zaawansowane możliwości rozumowania.
• Wbudowany web scraping: Potrafi wydobywać treść stron internetowych, aby wzbogacić kontekst promptu.
• Obsługa wyrażeń LaTeX: Wyrażenia matematyczne w odpowiedziach są konwertowane na tekst Unicode dla wygodnego odczytu w terminalu.
• Możliwość dostosowania: Skrypt pozwala na wybór modelu OpenAI i może być dopasowany do różnych przypadków użycia.

W tym artykule szczegółowo omówię kod skryptu, wyjaśnię jego działanie i przeprowadzę serię złożonych promptów.

Wymagania wstępne

Zanim zaczniesz, upewnij się, że masz:

• Python 3.x zainstalowany na swoim komputerze.
• Klucz API OpenAI. Możesz go uzyskać, rejestrując się na stronie OpenAI.
• Wirtualne środowisko Pythona (zalecane do izolowania zależności).
• Niezbędne moduły Pythona.

Konfiguracja wirtualnego środowiska

Aby odizolować zależności tego projektu, zaleca się użycie wirtualnego środowiska. Oto jak je utworzyć i zainstalować wymagane zależności:

python3 -m venv env
source env/bin/activate  # Sur Windows, utilisez env\Scripts\activate
pip install openai selenium webdriver-manager pylatexenc

Ustawienie klucza API OpenAI

Ustaw swój klucz API OpenAI jako zmienną środowiskową:

export OPENAI_API_KEY='votre_clé_api_ici'

Zastąp 'votre_clé_api_ici' swoim rzeczywistym kluczem API.

Pełny kod skryptu

Oto pełny kod skryptu Pythona:

#!/usr/bin/env python3
import os
import sys
import argparse
import re
from openai import OpenAI
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from webdriver_manager.chrome import ChromeDriverManager
from pylatexenc.latex2text import LatexNodes2Text


def get_web_content(url):
    if not url:
        return ""

    try:
        # Configure les options de Chrome
        chrome_options = Options()
        # Ne pas utiliser le mode headless pour éviter les problèmes de vérification humaine

        # Utilise ChromeDriverManager pour gérer l\'installation de ChromeDriver
        driver = webdriver.Chrome(
            service=Service(ChromeDriverManager().install()), options=chrome_options
        )

        # Charge la page web
        driver.get(url)

        # Récupère le contenu textuel de la page
        web_content = driver.execute_script("return document.documentElement.innerText")

        # Ferme le navigateur
        driver.quit()

        return web_content if web_content else None
    except Exception as e:
        return None


def convert_latex_to_text(latex_str):
    # Convertit les expressions LaTeX en texte Unicode
    return LatexNodes2Text().latex_to_text(latex_str)


def clean_output(content):
    # Trouve toutes les expressions LaTeX dans le contenu et les convertit
    patterns = [r"\\\\[.*?\\\\]", r"\\\(.*?\\\)", r"\$\$.*?\$\$", r"\$.*?\$"]

    for pattern in patterns:
        matches = re.findall(pattern, content, flags=re.DOTALL)
        for match in matches:
            plain_text = convert_latex_to_text(match)
            content = content.replace(match, plain_text)
    return content


def get_response(prompt, client, model="o1-preview"):
    urls = re.findall(r"(https?://\S+)", prompt)
    for url in urls:
        web_content = get_web_content(url)
        if web_content:
            prompt = prompt.replace(url, web_content)
        else:
            return f"Erreur: Le contenu web pour {url} ne peut être récupéré."

    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {
                    "role": "user",
                    "content": prompt,
                },
            ],
        )
        first_choice_message = response.choices[0].message
        content = first_choice_message.content
        # Convertit les expressions LaTeX en texte lisible
        cleaned_content = clean_output(content)
        return cleaned_content
    except Exception as e:
        return f"Une erreur est survenue : {e}"


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("prompt", nargs="?", help="Le prompt contenant des URLs")
    parser.add_argument(
        "--model",
        default="o1-preview",
        choices=["gpt-4o", "o1-preview", "o1-mini"],
        help="Le modèle OpenAI à utiliser (par défaut o1-preview)",
    )
    args = parser.parse_args()

    openai_api_key = os.getenv("OPENAI_API_KEY")
    if not openai_api_key:
        raise ValueError(
            "La clé API OPENAI_API_KEY n'est pas définie dans les variables d\'environnement."
        )

    with OpenAI(api_key=openai_api_key) as client:
        prompt = args.prompt or sys.stdin.read()
        response = get_response(prompt, client, model=args.model)
        print(response)


if __name__ == "__main__":
    main()

Wyjaśnienie kodu

Importowanie niezbędnych modułów

Skrypt zaczyna się od zaimportowania podstawowych modułów:

• os, sys, argparse, re: Moduły standardowe do obsługi zmiennych środowiskowych, argumentów linii poleceń i wyrażeń regularnych.
• openai: Moduł do interakcji z API OpenAI.
• selenium i webdriver_manager: Do wykonywania web scrapingu.
• pylatexenc: Do konwersji wyrażeń LaTeX na czytelny tekst Unicode.

Funkcja get_web_content

Ta funkcja pobiera tekstową zawartość strony internetowej.

def get_web_content(url):
    if not url:
        return ""

    try:
        # Configure les options de Chrome
        chrome_options = Options()
        # Ne pas utiliser le mode headless pour éviter les problèmes de vérification humaine

        # Utilise ChromeDriverManager pour gérer l\'installation de ChromeDriver
        driver = webdriver.Chrome(
            service=Service(ChromeDriverManager().install()), options=chrome_options
        )

        # Charge la page web
        driver.get(url)

        # Récupère le contenu textuel de la page
        web_content = driver.execute_script("return document.documentElement.innerText")

        # Ferme le navigateur
        driver.quit()

        return web_content if web_content else None
    except Exception as e:
        return None

Najważniejsze punkty:

• Opcje Chrome: Skrypt nie używa trybu headless, aby uniknąć problemów z weryfikacją ludzką, które niektóre strony narzucają przeglądarkom w trybie headless.
• ChromeDriverManager: Automatycznie zarządza instalacją i aktualizacją ChromeDriver.
• Ekstrakcja treści: Używa JavaScript do wydobycia pełnego tekstu ze strony.
• Obsługa wyjątków: W przypadku błędu funkcja zwraca None.

Funkcja convert_latex_to_text

Ta funkcja konwertuje wyrażenia LaTeX na tekst Unicode.

def convert_latex_to_text(latex_str):
    # Convertit les expressions LaTeX en texte Unicode
    return LatexNodes2Text().latex_to_text(latex_str)

Najważniejsze punkty:

• Używa biblioteki pylatexenc do konwersji wyrażeń LaTeX, dzięki czemu formuły matematyczne są czytelne w terminalu.

Funkcja clean_output

Ta funkcja przetwarza odpowiedź modelu, aby skonwertować wyrażenia LaTeX.

def clean_output(content):
    # Trouve toutes les expressions LaTeX dans le contenu et les convertit
    patterns = [r"\\\\[.*?\\\\]", r"\\\(.*?\\\)", r"\$\$.*?\$\$", r"\$.*?\$"]

    for pattern in patterns:
        matches = re.findall(pattern, content, flags=re.DOTALL)
        for match in matches:
            plain_text = convert_latex_to_text(match)
            content = content.replace(match, plain_text)
    return content

Najważniejsze punkty:

• Wyszukiwanie wyrażeń LaTeX: Korzysta z wyrażeń regularnych do identyfikacji formuł.
• Konwersja: Każda formuła jest konwertowana na tekst Unicode.
• Zastępowanie: Wyrażenia LaTeX są zastępowane ich czytelnymi odpowiednikami.

Funkcja get_response

Przygotowuje prompt, obsługuje web scraping jeśli to konieczne, wywołuje API OpenAI i oczyszcza odpowiedź.

def get_response(prompt, client, model="o1-preview"):
    urls = re.findall(r"(https?://\S+)", prompt)
    for url in urls:
        web_content = get_web_content(url)
        if web_content:
            prompt = prompt.replace(url, web_content)
        else:
            return f"Erreur: Le contenu web pour {url} ne peut être récupéré."

    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {
                    "role": "user",
                    "content": prompt,
                },
            ],
        )
        first_choice_message = response.choices[0].message
        content = first_choice_message.content
        # Convertit les expressions LaTeX en texte lisible
        cleaned_content = clean_output(content)
        return cleaned_content
    except Exception as e:
        return f"Une erreur est survenue : {e}"

Najważniejsze punkty:

• Obsługa URL-i: Jeśli prompt zawiera URL-e, ich zawartość jest wydobywana i wstawiana.
• Wywołanie API OpenAI: Wysyła zmodyfikowany prompt do określonego modelu.
• Oczyszczanie odpowiedzi: Wyrażenia LaTeX są konwertowane dla łatwiejszego odczytu.

Funkcja main

Obsługuje argumenty linii poleceń i uruchamia skrypt.

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("prompt", nargs="?", help="Le prompt contenant des URLs")
    parser.add_argument(
        "--model",
        default="o1-preview",
        choices=["gpt-4o", "o1-preview", "o1-mini"],
        help="Le modèle OpenAI à utiliser (par défaut o1-preview)",
    )
    args = parser.parse_args()

    openai_api_key = os.getenv("OPENAI_API_KEY")
    if not openai_api_key:
        raise ValueError(
            "La clé API OPENAI_API_KEY n'est pas définie dans les variables d\'environnement."
        )

    with OpenAI(api_key=openai_api_key) as client:
        prompt = args.prompt or sys.stdin.read()
        response = get_response(prompt, client, model=args.model)
        print(response)

Najważniejsze punkty:

• Argumenty: Skrypt akceptuje prompt i model jako argumenty.
• Klucz API: Sprawdza, czy klucz API jest ustawiony.
• Wykonanie: Wywołuje funkcję get_response i wyświetla odpowiedź.

Uruchomienie skryptu

if __name__ == "__main__":
    main()

Przykłady użycia

Zadanie wymagające rozumowania

./openai_poc.py "Dans un triangle rectangle, si les côtés adjacents à l'angle droit mesurent 3 cm et 4 cm, calcule la longueur de l'hypoténuse."

Aby obliczyć długość przeciwprostokątnej w trójkącie prostokątnym, którego przyprostokątne mają długości 3 cm i 4 cm, używamy twierdzenia Pitagorasa:

$$\text{Hypoténuse}^2 = (\text{Côté 1})^2 + (\text{Côté 2})^2$$

Podstawiając wartości:

$$\text{Hypoténuse}^2 = 3^2 + 4^2 = 9 + 16 = 25$$

Biorąc pierwiastek kwadratowy z obu stron:

$$\text{Hypoténuse} = \sqrt{25} = 5 \text{ cm}$$

Zatem długość przeciwprostokątnej wynosi 5 cm.

Długość przeciwprostokątnej to 5 cm.

Wygenerowanie streszczenia strony internetowej

./openai_poc.py "Fais-moi un résumé de cette page : https://openai.com/index/introducing-openai-o1-preview/"

OpenAI ogłosiło 12 września 2024 wprowadzenie nowej serii modeli AI o nazwie OpenAI o1, zaprojektowanej tak, aby poświęcać więcej czasu na przemyślenie odpowiedzi. Modele te potrafią rozumować nad złożonymi zadaniami i rozwiązywać trudniejsze problemy niż wcześniejsze modele w dziedzinach nauki, kodowania i matematyki.

Pierwszy model z tej serii, o1-preview, jest już dostępny w ChatGPT i przez API OpenAI. Oferowana jest też lżejsza i tańsza wersja, nazwana OpenAI o1-mini, która zapewnia wydajne możliwości kodowania przy obniżonym koszcie o około 80% w porównaniu z o1-preview.

Rozwiązanie prostego mnożenia

./openai_poc.py "Quel est le résultat de 15 x 12 ?"

Wynik $15 \times 12$ to 180.

Rozwiązanie prostej równania

./openai_poc.py "Résous l'équation 2x + 5 = 15."

Aby rozwiązać równanie $2x + 5 = 15$, wykonaj następujące kroki:

1. Odejmij 5 od obu stron równania, aby odizolować wyraz z niewiadomą:

$$\begin{aligned} 2x + 5 - 5 &= 15 - 5 \\ 2x &= 10 \end{aligned}$$

2. Podziel obie strony równania przez 2, aby rozwiązać dla $x$:

$$\begin{aligned} \frac{2x}{2} &= \frac{10}{2} \\ x &= 5 \end{aligned}$$

Rozwiązanie: $x = 5$.

Obliczanie procentu

./openai_poc.py "Quel est 20% de 250 ?"

$20\%$ z $250$ to 50.

Obliczenia:

$$20\% \times 250 = \left( \frac{20}{100} \right) \times 250 = 0,2 \times 250 = 50$$

Obliczanie pola koła

./openai_poc.py "Calcule l'aire d'un cercle de rayon 5 cm."

Aby obliczyć pole koła o promieniu 5 cm, użyjemy wzoru na pole koła:

$$A = \pi r^2$$

gdzie:

• $A$ to pole koła,
• $r$ to promień koła.

Podstawiając $r = 5 \text{ cm}$:

$$\begin{aligned} A &= \pi (5 \text{ cm})^2 \\ &= \pi (25 \text{ cm}^2) \\ &= 25\pi \text{ cm}^2 \end{aligned}$$

Zatem pole koła wynosi $25\pi \text{ cm}^2$.

Jeśli chcesz wartość przybliżoną, przyjmując $\pi \approx 3{,}1416$:

$$\begin{aligned} A &≈ 25 \times 3{,}1416 \text{ cm}^2 \u2248 78{,}54 \text{ cm}^2 \end{aligned}$$

Tak więc pole koła wynosi w przybliżeniu 78,54 cm².

Obliczanie prostej całki

./openai_poc.py "Calcule l'intégrale de 0 à 1 de x^2 dx."

Aby obliczyć całkę od 0 do 1 funkcji $x^2$, całkujemy $x^2$ względem $x$ i oceniamy wynik pomiędzy granicami 0 i 1.

Kroki obliczeń:

1. Całkowanie funkcji $x^2$:

$$\int x^2 \, dx = \frac{x^3}{3} + C$$

gdzie C jest stałą całkowania.

2. Ocena pomiędzy granicami 0 i 1:

$$\int_0^1 x^2 \, dx = \left[ \frac{x^3}{3} \right]_0^1 = \left( \frac{1^3}{3} \right) - \left( \frac{0^3}{3} \right)$$

3. Obliczenia wartości na granicach:

$$\frac{1^3}{3} = \frac{1}{3} \quad \text{oraz} \quad \frac{0^3}{3} = 0$$

4. Odejmowanie wartości, aby uzyskać wynik końcowy:

$$\int_0^1 x^2 \, dx = \frac{1}{3} - 0 = \frac{1}{3}$$

Wniosek:

Wartość całki od 0 do 1 z $x^2 \, dx$ wynosi $1/3$.

Obliczanie średniej prędkości

./openai_poc.py "Si une voiture parcourt 150 km en 3 heures, quelle est sa vitesse moyenne ?"

Aby obliczyć średnią prędkość samochodu, który pokonuje 150 km w 3 godziny, używamy wzoru na prędkość średnią:

$$\text{Vitesse moyenne} = \frac{\text{Distance totale}}{\text{Temps total}}$$

Podstawiając dane:

$$\text{Vitesse moyenne} = \frac{150 \text{ km}}{3 \text{ heures}} = 50 \text{ km/h}$$

Średnia prędkość samochodu wynosi zatem 50 km/h.

Mechanika klasyczna

./openai_poc.py "Un bloc de 5 kg est tiré sur une surface sans frottement par une force de 20 N. Calcule son accélération."

Aby obliczyć przyspieszenie bloku, używamy drugiej zasady dynamiki Newtona, która mówi, że wypadkowa siła działająca na ciało równa się masie tego ciała pomnożonej przez przyspieszenie ($F = m \times a$).

Dane:

• Masa bloku, $m = 5 \text{ kg}$
• Przyłożona siła, $F = 20 \text{ N}$
• Powierzchnia bez tarcia (czyli brak siły przeciwnej z tarcia)

Przekształcając wzór, aby rozwiązać dla przyspieszenia ($a$), otrzymujemy:

$$a = \frac{F}{m}$$

Podstawiając wartości:

$$a = \frac{20 \text{ N}}{5 \text{ kg}} = 4 \text{ m/s}^2$$

Odpowiedź: Przyspieszenie bloku wynosi 4 metry na sekundę do kwadratu ($4 \text{ m/s}^2$).

Rozwiązywanie równań różniczkowych

./openai_poc.py "Résous l'équation différentielle dy/dx = x^2 + y^2 avec la condition initiale y(0) = 1."

Aby rozwiązać równanie różniczkowe:

$$\frac{dy}{dx} = x^2 + y^2$$

z warunkiem początkowym $y(0) = 1$, zauważamy, że równanie to jest nieliniowe i nie można go rozwiązać za pomocą podstawowych metod takich jak separacja zmiennych czy standardowe czynniki całkujące. Możemy jednak spróbować przekształcić równanie do formy łatwiejszej do analizy.

Krok 1: Rozpoznanie typu równania

Podane równanie jest równaniem Riccatiego o ogólnej postaci:

$$\frac{dy}{dx} = q_0(x) + q_1(x) y + q_2(x) y^2$$

W naszym przypadku ma postać:

$$\frac{dy}{dx} = x^2 + 0 \cdot y + 1 \cdot y^2$$

Krok 2: Przekształcenie do liniowego równania drugiego rzędu

Aby rozwiązać równanie Riccatiego, można zastosować podstawienie:

$$y = -\frac{u'}{u}$$

gdzie $u = u(x)$ jest funkcją do wyznaczenia, a $u'$ oznacza pochodną $u$ względem $x$.

Obliczenie $y'$ w funkcji $u$:

$$y = -\frac{u'}{u}$$ $$y' = -\frac{d}{dx}\left( \frac{u'}{u} \right)$$

Stosujemy regułę różniczkowania ilorazu:

$$y' = -\left( \frac{u'' \cdot u - (u')^2}{u^2} \right)$$

Krok 3: Podstawienie do równania początkowego

Podstawiamy $y$ i $y'$ do oryginalnego równania:

$$y' = x^2 + y^2$$ $$-\left( \frac{u'' u - (u')^2}{u^2} \right) = x^2 + \left( -\frac{u'}{u} \right)^2$$

Uprośćmy równanie:

$$-\left( \frac{u'' u - (u')^2}{u^2} \right) = x^2 + \frac{(u')^2}{u^2}$$

Mnożymy obie strony przez $u^2$, aby pozbyć się mianowników:

$$-( u'' u - (u')^2 ) = x^2 u^2 + (u')^2$$

Uproszczenia:

$$-u'' u + (u')^2 = x^2 u^2 + (u')^2$$ $$-u'' u = x^2 u^2$$ $$u'' u = -x^2 u^2$$

Dzielimy przez $u$ (zakładając $u \neq 0$):

$$u'' = -x^2 u$$

Krok 4: Rozwiązanie liniowego równania drugiego rzędu

Otrzymujemy liniowe jednorodne równanie drugiego rzędu:

$$u'' + x^2 u = 0$$

Jest to równanie różniczkowe liniowe z zmiennymi współczynnikami, znane jako zmodyfikowane równanie Airy. Rozwiązania tego równania nie są wyrażalne za pomocą funkcji elementarnych, lecz za pomocą funkcji specjalnych zwanych funkcjami Airy.

Rozwiązania ogólne:

Rozwiązania ogólne równania $u'' + x^2 u = 0$ mają postać:

$$u(x) = C_1 \cdot \text{Ai}(i x) + C_2 \cdot \text{Bi}(i x)$$

gdzie $\text{Ai}$ i $\text{Bi}$ to funkcje Airy pierwszego i drugiego rodzaju, a $i$ to jednostka urojona, dla której $i^2 = -1$.

Krok 5: Powrót do $y(x)$

Przypomnijmy, że:

$$y = -\frac{u'}{u}$$

Znając $u(x)$, możemy znaleźć $y(x)$, obliczając pochodną $u$ i wykonując iloraz.

Krok 6: Zastosowanie warunku początkowego

Aby wyznaczyć stałe całkowania $C_1$ i $C_2$, należy zastosować warunek początkowy $y(0) = 1$. Jednak ze względu na złożoność funkcji Airy o argumentach zespolonych, wyprowadzenie jawnego rozwiązania jest skomplikowane.

Wniosek

Rozwiązanie równania różniczkowego

$$\frac{dy}{dx} = x^2 + y^2$$

z warunkiem początkowym $y(0) = 1$ jest wyrażone za pomocą funkcji specjalnych (funkcji Airy) i nie da się go zapisać w postaci funkcji elementarnych.

Ostateczna odpowiedź:

Rozwiązanie równania różniczkowego $\frac{dy}{dx} = x^2 + y^2$ z $y(0) = 1$ jest określone w sposób pośredni za pomocą funkcji Airy i nie może być zapisane explicite przy użyciu standardowych funkcji elementarnych.

Elektromagnetyzm

./openai_poc.py "Calcule le champ électrique à une distance r d'une charge ponctuelle Q."

Pole elektryczne $E$ wytwarzane przez ładunek punktowy $Q$ w odległości $r$ jest dane prawem Coulomba. Wzór na pole elektryczne to:

$$E = \frac{1}{4\pi\epsilon_0} \times \frac{Q}{r^2}$$

gdzie:

• $E$ to pole elektryczne (w woltach na metr, V/m),
• $Q$ to ładunek punktowy (w kulombach, C),
• $r$ to odległość od ładunku (w metrach, m),
• $\epsilon_0$ to przenikalność próżni, z wartością przybliżoną $8{,}854 \times 10^{-12} \text{ C}^2/\text{N}\cdot\text{m}^2$.

Przykład obliczeń:

Załóżmy, że mamy ładunek $Q = 2 \times 10^{-6} \text{ C}$ (2 mikroculomby) i chcemy obliczyć pole elektryczne w odległości $r = 0{,}5 \text{ m}$.

1. Oblicz stałą przed ułamkiem:

$$\frac{1}{4\pi\epsilon_0} = \frac{1}{4\pi \times 8{,}854 \times 10^{-12}} \approx 8{,}988 \times 10^9 \text{ N}\cdot\text{m}^2/\text{C}^2$$

2. Zastosuj wzór:

$$E = (8{,}988 \times 10^9) \times \frac{2 \times 10^{-6}}{(0{,}5)^2}$$ $$E = (8{,}988 \times 10^9) \times \frac{2 \times 10^{-6}}{0{,}25}$$ $$E = (8{,}988 \times 10^9) \times 8 \times 10^{-6}$$ $$E = 71\,904 \text{ V/m}$$

Wniosek:

Pole elektryczne w odległości $r = 0{,}5 \text{ m}$ od ładunku punktowego $Q = 2 \times 10^{-6} \text{ C}$ wynosi $E = 71\,904 \text{ V/m}$.

Tak więc, aby obliczyć pole elektryczne w określonej odległości od ładunku punktowego, użyj powyższego wzoru, podstawiając konkretne wartości $Q$ i $r$.

Równowaga chemiczna

./openai_poc.py "Explique comment le principe de Le Chatelier s'applique à l'équilibre suivant : N2 + 3H2 ⇌ 2NH3."

Zasada Le Chateliera mówi, że kiedy układ w stanie równowagi jest poddany zewnętrznej zmianie (zakłóceniu), układ reaguje w sposób minimalizujący to zakłócenie i dąży do ustanowienia nowej równowagi. Zastosowana do reakcji równowagi:

$$N_2(g) + 3H_2(g) \rightleftharpoons 2NH_3(g)$$

można przeanalizować, jak różne zmiany wpływają na położenie równowagi.

1. Zmiana stężenia: - Zwiększenie stężenia reagentów (N₂ lub H₂) : Jeśli do układu dodamy azot (N₂) lub wodór (H₂), stężenie tych reagentów wzrośnie. Zgodnie z zasadą Le Chateliera, równowaga przesunie się w kierunku zużywającym dodatkowe reagentów, czyli w prawo, sprzyjając tworzeniu amoniaku (NH₃).

• Zmniejszenie stężenia produktów (NH₃) : Jeśli usuniemy amoniak z układu, stężenie NH₃ zmaleje. Równowaga przesunie się wtedy w prawo, aby skompensować to zmniejszenie, ponownie sprzyjając tworzeniu amoniaku.

• Zwiększenie stężenia produktów (NH₃) : Jeśli dodamy amoniak do układu, równowaga przesunie się w lewo, aby zmniejszyć nadmiar NH₃, sprzyjając tworzeniu N₂ i H₂.

2. Zmiana ciśnienia :

• Zwiększenie całkowitego ciśnienia układu : Dla gazów zwiększenie ciśnienia (przez zmniejszenie objętości) sprzyja reakcji, która produkuje najmniej moli gazowych. W tej reakcji przechodzimy od 4 moli gazów (1 N₂ + 3 H₂) do 2 moli gazów (2 NH₃). Zatem zwiększenie ciśnienia przesuwa równowagę w prawo, sprzyjając tworzeniu amoniaku.

• Zmniejszenie całkowitego ciśnienia układu : Odwrotnie, zmniejszenie ciśnienia będzie sprzyjać reakcji produkującej najwięcej moli gazowych, przesuwając równowagę w lewo i sprzyjając dysocjacji NH₃ do N₂ i H₂.

3. Zmiana temperatury :

• Egzotermiczny charakter reakcji : Synteza amoniaku jest reakcją egzotermiczną ($\Delta H < 0$), czyli wydziela ciepło.

• Zwiększenie temperatury : Zwiększając temperaturę dostarczamy ciepło do układu. Zgodnie z zasadą Le Chateliera, równowaga przesunie się w kierunku pochłaniającym to dodatkowe ciepło, czyli w lewo (reakcja endotermiczna), sprzyjając dysocjacji NH₃ do N₂ i H₂.

• Zmniejszenie temperatury : Obniżając temperaturę, układ reaguje przez wytwarzanie ciepła, aby skompensować jego utratę. Równowaga przesunie się więc w prawo (reakcja egzotermiczna), sprzyjając tworzeniu amoniaku.

4. Obecność katalizatora :

• Wpływ katalizatora : Dodanie katalizatora (takiego jak drobno podzielone żelazo z promotorami) zwiększa szybkość osiągnięcia równowagi, ale nie zmienia położenia równowagi. Przyspiesza zarówno reakcję prostą, jak i odwrotną w równym stopniu.

Podsumowanie :

Zasada Le Chateliera pozwala przewidzieć kierunek, w którym przesunie się równowaga chemiczna w odpowiedzi na zmianę warunków układu. Dla syntezy amoniaku:

• Wysokie ciśnienie sprzyja tworzeniu NH₃ (mniej moli gazowych).
• Niska temperatura sprzyja tworzeniu NH₃ (reakcja egzotermiczna).
• Zwiększenie stężeń N₂ lub H₂ sprzyja tworzeniu NH₃.
• Usuwanie NH₃ z układu sprzyja tworzeniu większej ilości NH₃.

Zasady te są stosowane w procesie Habera-Boscha w celu optymalizacji przemysłowej produkcji amoniaku.

Wnioski

Ten skrypt Pythona oferuje praktyczną integrację modelu OpenAI o1-preview, umożliwiając wykorzystanie jego zaawansowanych zdolności rozumowania do szerokiego zakresu pytań, od najprostszych po najbardziej złożone. Niezależnie od tego, czy jesteś ciekawskim początkującym, czy ekspertem chcącym przetestować granice modelu, ten skrypt jest przydatnym narzędziem dla Twoich projektów w dziedzinie sztucznej inteligencji.

Zasoby

• Ogłoszenie modelu OpenAI o1-preview
• Oficjalna dokumentacja API OpenAI
• Dokumentacja Selenium
• Dokumentacja pylatexenc
• Przewodnik po środowiskach wirtualnych w Pythonie

Ten dokument został przetłumaczony z wersji fr na język pl przy użyciu modelu gpt-5-mini. Aby uzyskać więcej informacji na temat procesu tłumaczenia, zobacz https://gitlab.com/jls42/ai-powered-markdown-translator