Het OpenAI-model o1-preview integreren in een Python-script met verwerking van LaTeX-expressies

Ontdek hoe je het nieuwe model OpenAI o1-preview kunt integreren in een Python-script om je AI-projecten te verrijken. Dit script stelt je in staat om met de OpenAI API te communiceren met behulp van het model o1-preview, met de mogelijkheid om webinhoud in prompts op te nemen dankzij een webscraping-functie. Bovendien verwerkt het wiskundige LaTeX-expressies in de reacties van het model correct, door ze om te zetten naar leesbare Unicode-tekst in de terminal.

Inleiding

Op 12 september 2024 heeft OpenAI zijn nieuwe reeks AI-modellen gelanceerd, genaamd OpenAI o1. Deze modellen zijn ontworpen om diepgaander te redeneren voordat ze een antwoord geven, waardoor ze complexe problemen op het gebied van wetenschap, programmeren en wiskunde kunnen oplossen. Het model o1-preview blinkt vooral uit in deze domeinen en overtreft eerdere modellen zoals gpt-4o.

Kernpunten van het script:

Integratie van het o1-preview-model: Het script gebruikt standaard het model o1-preview, wat geavanceerde redeneercapaciteiten biedt.
Geïntegreerde webscraping: Het kan de inhoud van webpagina’s extraheren om de context van de prompt te verrijken.
Verwerking van LaTeX-expressies: Wiskundige uitdrukkingen in de antwoorden worden omgezet naar Unicode-tekst voor eenvoudige weergave in de terminal.
Aanpasbaar: Het script laat je het OpenAI-model kiezen en kan worden aangepast aan verschillende gebruikssituaties.

In dit artikel zal ik de code van het script in detail bespreken, uitleggen hoe het werkt en een reeks complexe prompts uitvoeren.

Vereisten

Voordat je begint, zorg dat je het volgende hebt:

Python 3.x geïnstalleerd op je machine.
Een OpenAI API-sleutel. Je kunt deze verkrijgen door je aan te melden op de website van OpenAI.
Een Python virtuele omgeving (aanbevolen om afhankelijkheden te isoleren).
De benodigde Python-modules.

Configuratie van de virtuele omgeving

Om de afhankelijkheden van dit project te isoleren, is het aan te raden een virtuele omgeving te gebruiken. Zo maak en installeer je de vereiste afhankelijkheden:

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

De OpenAI API-sleutel instellen

Stel je OpenAI API-sleutel in als omgevingsvariabele:

export OPENAI_API_KEY='votre_clé_api_ici'

Vervang 'votre_clé_api_ici' door je echte API-sleutel.

De volledige scriptcode

Hier is de volledige Python-scriptcode:

#!/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()

Uitleg van de code

Importeren van de benodigde modules

Het script begint met het importeren van de essentiële modules:

os, sys, argparse, re: Standaardmodules om omgevingsvariabelen, commandoregelargumenten en reguliere expressies te beheren.
openai: Module om met de OpenAI API te communiceren.
selenium en webdriver_manager: Voor het uitvoeren van webscraping.
pylatexenc: Om LaTeX-expressies naar leesbare Unicode-tekst te converteren.

Functie `get_web_content`

Deze functie haalt de tekstuele inhoud van een webpagina op.

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

Kernpunten:

Chrome-opties: Het script gebruikt niet de headless-modus om problemen met menselijke verificatie op sommige pagina’s te vermijden die headless-browsers blokkeren.
ChromeDriverManager: Beheert automatisch de installatie en bijwerking van ChromeDriver.
Inhoudsextractie: Gebruikt JavaScript om de volledige tekst van de pagina te extraheren.
Foutafhandeling: In geval van een fout geeft de functie None terug.

Functie `convert_latex_to_text`

Deze functie zet LaTeX-expressies om naar Unicode-tekst.

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

Kernpunten:

Maakt gebruik van de bibliotheek pylatexenc om LaTeX-expressies te converteren, waardoor wiskundige formules leesbaar worden in de terminal.

Functie `clean_output`

Deze functie verwerkt het antwoord van het model om LaTeX-expressies te converteren.

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

Kernpunten:

Zoeken naar LaTeX-expressies: Gebruikt reguliere expressies om formules te identificeren.
Conversie: Elke formule wordt omgezet naar Unicode-tekst.
Vervanging: De LaTeX-formules worden vervangen door hun leesbare equivalent.

Functie `get_response`

Bereidt de prompt voor, voert webscraping uit indien nodig, roept de OpenAI API aan en reinigt het antwoord.

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}"

Kernpunten:

Omgaan met URL’s: Als de prompt URL’s bevat, wordt de inhoud opgehaald en in de prompt ingevoegd.
API-aanroep naar OpenAI: Verstuurt de gewijzigde prompt naar het opgegeven model.
Opschonen van het antwoord: LaTeX-expressies worden omgezet voor eenvoudige weergave.

Functie `main`

Behandelt de commandoregelargumenten en voert het script uit.

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)

Kernpunten:

Argumenten: Het script accepteert een prompt en een model als argumenten.
API-sleutel: Controleert of de API-sleutel is ingesteld.
Uitvoering: Roept de functie get_response aan en toont het antwoord.

Script uitvoeren

if __name__ == "__main__":
    main()

Gebruikvoorbeelden

Een vraag stellen die redenering vereist

./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."

Om de lengte van de hypotenusa in een rechthoekige driehoek te berekenen waarvan de twee aan de rechte hoek grenzende zijden 3 cm en 4 cm zijn, gebruiken we de stelling van Pythagoras:

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

Door de gegeven waarden te vervangen:

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

Door de vierkantswortel van beide zijden te nemen:

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

Dus, de lengte van de hypotenusa is 5 cm.

De lengte van de hypotenusa is 5 cm.

Een samenvatting van een webpagina genereren

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

OpenAI kondigde op 12 september 2024 de introductie aan van een nieuwe reeks AI-modellen genaamd OpenAI o1, ontworpen om meer tijd te nemen om na te denken voordat ze antwoorden geven. Deze modellen zijn in staat om te redeneren over complexe taken en moeilijkere problemen op te lossen dan eerdere modellen op het gebied van wetenschap, programmeren en wiskunde.

Het eerste model van deze reeks, o1-preview, is nu beschikbaar op ChatGPT en via de OpenAI API. Er is ook een lichtere en goedkopere versie genaamd OpenAI o1-mini, die efficiënte codeerfuncties biedt tegen ongeveer 80% lagere kosten dan o1-preview.

Een eenvoudige vermenigvuldiging oplossen

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

Het resultaat van $15 \times 12$ is 180.

Een eenvoudige vergelijking oplossen

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

Om de vergelijking $2x + 5 = 15$ op te lossen, volg je de volgende stappen:

Trek 5 af van beide kanten van de vergelijking om de term met de variabele te isoleren:

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

Deel beide zijden van de vergelijking door 2 om x op te lossen:

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

Oplossing: $x = 5$ .

Een percentage berekenen

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

$20\%$ van $250$ is gelijk aan 50.

Berekening:

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

De oppervlakte van een cirkel berekenen

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

Om de oppervlakte van een cirkel met straal 5 cm te berekenen, gebruik je de formule voor de oppervlakte van een cirkel:

A = \pi r^2

waarbij:

$A$ de oppervlakte van de cirkel is,
$r$ de straal van de cirkel is.

Door $r$ te vervangen door 5 cm:

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

Dus, de oppervlakte van de cirkel is $25\pi \text{ cm}^2$ .

Als je een benaderde waarde wilt, met $\pi \approx 3,1416$ :

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

Daarom is de oppervlakte van de cirkel ongeveer 78,54 cm².

Een eenvoudige integraal berekenen

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

Om de integraal van 0 tot 1 van de functie $x^2$ te berekenen, integreren we $x^2$ ten opzichte van $x$ en evalueren we de verkregen uitdrukking tussen de grenzen 0 en 1.

Berekeningsstappen:

Integratie van de functie $x^2$ :

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

waarbij C de integratieconstante is.

Evaluatie tussen de grenzen 0 en 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)

Berekening van de waarden op de grenzen:

\frac{1^3}{3} = \frac{1}{3} \quad \text{en} \quad \frac{0^3}{3} = 0

Aftrekken van de waarden om het eindresultaat te krijgen:

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

Conclusie:

De waarde van de integraal van 0 tot 1 van $x^2 \, dx$ is dus $1/3$ .

Gemiddelde snelheid berekenen

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

Om de gemiddelde snelheid van een auto te berekenen die 150 km aflegt in 3 uur, gebruiken we de formule voor gemiddelde snelheid:

\text{Gemiddelde snelheid} = \frac{\text{Totale afstand}}{\text{Totale tijd}}

Toegepast op de gegeven waarden:

\text{Gemiddelde snelheid} = \frac{150 \text{ km}}{3 \text{ uur}} = 50 \text{ km/h}

De gemiddelde snelheid van de auto is dus 50 km/h.

Klassieke mechanica

./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."

Om de versnelling van een blok te berekenen gebruiken we de tweede wet van Newton, die stelt dat de resulterende kracht op een object gelijk is aan de massa van het object maal zijn versnelling ( $F = m \times a$ ).

Gegeven:

Massa van het blok, $m = 5 \text{ kg}$
Toegepaste kracht, $F = 20 \text{ N}$
Vlak zonder wrijving (dus geen tegenwerkende kracht door wrijving)

Door de formule te herschikken om de versnelling ( $a$ ) op te lossen, krijgen we:

a = \frac{F}{m}

Door de gegeven waarden te vervangen:

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

Antwoord: De versnelling van het blok is 4 meter per seconde in het kwadraat ( $4 \text{ m/s}^2$ ).

Differentiaalvergelijkingen oplossen

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

Om de differentiaalvergelijking op te lossen:

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

met de begintoestand $y(0) = 1$ , merken we op dat deze vergelijking niet-lineair is en niet kan worden opgelost met elementaire methoden zoals scheiding van variabelen of standaard integrerende factoren. We kunnen echter proberen de vergelijking om te zetten naar een beter oplosbare vorm.

Stap 1: De aard van de vergelijking herkennen

De gegeven vergelijking is een Riccati-vergelijking met de algemene vorm:

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

In ons geval is dit:

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

Stap 2: De vergelijking transformeren naar een lineaire tweede-orde vergelijking

Om een Riccati-vergelijking op te lossen, kan men de volgende substitutie gebruiken:

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

waarbij $u = u(x)$ een te bepalen functie is, en $u'$ de afgeleide van $u$ naar $x$ .

Berekening van $y'$ in termen van $u$ :

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

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

Toepassing van de quotiëntregel geeft:

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

Stap 3: Vervangen in de oorspronkelijke vergelijking

Vervang $y$ en $y'$ in de oorspronkelijke differentiaalvergelijking:

y' = x^2 + y^2

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

Vereenvoudig de vergelijking:

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

Vermenigvuldig beide leden met $u^2$ om de noemers te verwijderen:

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

Vereenvoudig:

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

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

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

Deel door $u$ (ervan uitgaande dat $u \neq 0$ ):

u'' = -x^2 u

Stap 4: De lineaire tweede-orde vergelijking oplossen

We krijgen een lineaire homogene tweede-orde differentiaalvergelijking:

u'' + x^2 u = 0

Deze vergelijking heeft variabele coëfficiënten en staat bekend als een variant die gerelateerd is aan Airy-achtige vergelijkingen. De oplossingen kunnen niet worden uitgedrukt in elementaire functies, maar worden gegeven in termen van speciale functies zoals Airy-functies.

Oplossingen van de vergelijking:

De algemene oplossingen van $u'' + x^2 u = 0$ zijn:

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

waar $\text{Ai}$ en $\text{Bi}$ de Airy-functies van de eerste en tweede soort zijn, en $i$ de imaginaire eenheid is met $i^2 = -1$ .

Stap 5: Terugkeren naar $y(x)$

Herinner dat:

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

Als we $u(x)$ kennen, kunnen we $y(x)$ vinden door de afgeleide van $u$ te berekenen en de breuk te vormen.

Stap 6: De beginwaarde toepassen

Om de integratieconstanten $C_1$ en $C_2$ te bepalen, moeten we de beginwaarde $y(0) = 1$ gebruiken. Aangezien het werk met Airy-functies met complexe argumenten ingewikkeld is, is een expliciete berekening echter lastig.

Conclusie

De oplossing van de differentiaalvergelijking $\frac{dy}{dx} = x^2 + y^2$ met de begintoestand $y(0) = 1$ wordt uitgedrukt in termen van speciale functies (Airy-functies) en kan niet expliciet worden geschreven met elementaire functies.

Elektromagnetisme

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

Het elektrische veld $E$ dat door een puntlading $Q$ op een afstand $r$ wordt gecreëerd, wordt gegeven door de wet van Coulomb. De formule om het elektrische veld te berekenen is:

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

waarbij:

$E$ het elektrische veld is (in volt per meter, V/m),
$Q$ de puntlading is (in coulomb, C),
$r$ de afstand tot de lading is (in meters, m),
$\epsilon_0$ de permittiviteit van het vacuüm is, met een benaderde waarde van $8,854 \times 10^{-12} \text{ C}^2/\text{N}\cdot\text{m}^2$ .

Voorbeeldberekening:

Stel dat je een lading $Q = 2 \times 10^{-6} \text{ C}$ (2 microcoulomb) hebt en je wilt het elektrische veld berekenen op een afstand $r = 0,5 \text{ m}$ .

Bereken de constante voor de breuk:

\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

Pas de formule toe:

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}

Conclusie:

Het elektrische veld op een afstand van $r = 0,5 \text{ m}$ van een puntlading van $Q = 2 \times 10^{-6} \text{ C}$ is $E = 71\,904 \text{ V/m}$ .

Gebruik voor het berekenen van het elektrische veld op een gegeven afstand van een puntlading de bovenstaande formule en vervang $Q$ en $r$ door de specifieke waarden van het probleem.

Chemisch evenwicht

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

Het principe van Le Chatelier stelt dat wanneer een systeem in evenwicht wordt blootgesteld aan een externe wijziging (stress), het zal reageren op een manier die die verstoring minimaliseert en een nieuw evenwicht instelt. Toegepast op het volgende chemische evenwicht:

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

kunnen we analyseren hoe verschillende wijzigingen de positie van het evenwicht beïnvloeden.

1. Verandering van concentratie: - Toename van de concentratie van reactanten (N₂ of H₂) : Als er stikstof (N₂) of waterstof (H₂) aan het systeem wordt toegevoegd, neemt de concentratie van deze reactanten toe. Volgens het principe van Le Chatelier zal het evenwicht verschuiven in de richting die deze extra reactanten verbruikt, dat wil zeggen naar rechts, waardoor de vorming van ammoniak (NH₃) wordt bevorderd.

Afname van de concentratie van producten (NH₃) : Als er ammoniak uit het systeem wordt verwijderd, neemt de concentratie van NH₃ af. Het evenwicht zal dan naar rechts verschuiven om deze afname te compenseren, waardoor opnieuw de vorming van ammoniak wordt bevorderd.
Toename van de concentratie van producten (NH₃) : Als er ammoniak aan het systeem wordt toegevoegd, zal het evenwicht naar links verschuiven om het overschot aan NH₃ te verminderen, wat de vorming van N₂ en H₂ bevordert.

2. Verandering van de druk :

Toename van de totale druk van het systeem : Voor gassen bevordert een toename van de druk (door vermindering van het volume) de reactie die het minste aantal gasmollen oplevert. In deze reactie gaat men van 4 mol gas (1 N₂ + 3 H₂) naar 2 mol gas (2 NH₃). Dus een toename van de druk verschuift het evenwicht naar rechts en bevordert de vorming van ammoniak.
Afname van de totale druk van het systeem : Omgekeerd zal een afname van de druk de reactie bevorderen die het meeste aantal gasmollen produceert, waardoor het evenwicht naar links verschuift en de dissociatie van NH₃ in N₂ en H₂ wordt bevorderd.

3. Verandering van de temperatuur :

Exotherme aard van de reactie : De synthese van ammoniak is een exotherme reactie ( $\Delta H < 0$ ), dat wil zeggen dat ze warmte vrijgeeft.
Toename van de temperatuur : Door de temperatuur te verhogen, wordt er warmte aan het systeem toegevoegd. Volgens het principe van Le Chatelier zal het evenwicht verschuiven in de richting die deze extra warmte absorbeert, dus naar links (endotherme reactie), wat de dissociatie van NH₃ in N₂ en H₂ bevordert.
Afname van de temperatuur : Door de temperatuur te verlagen reageert het systeem door warmte te produceren om dit verlies te compenseren. Het evenwicht verschuift dus naar rechts (exotherme reactie), wat de vorming van ammoniak bevordert.

4. Aanwezigheid van een katalysator :

Effect van de katalysator : Het toevoegen van een katalysator (zoals fijnverdeeld ijzer met promoterstoffen) verhoogt de snelheid waarmee het evenwicht wordt bereikt, maar verandert de positie van het evenwicht niet. Hij versnelt zowel de directe als de omgekeerde reactie in gelijke mate.

Samenvatting :

Het principe van Le Chatelier maakt het mogelijk te voorspellen in welke richting een chemisch evenwicht zal verschuiven als reactie op een verandering van de omstandigheden van het systeem. Voor de synthese van ammoniak:

Hoge druk bevordert de vorming van NH₃ (minder gasmollen).
Lage temperatuur bevordert de vorming van NH₃ (exotherme reactie).
Toename van de concentraties van N₂ of H₂ bevordert de vorming van NH₃.
Verwijdering van NH₃ uit het systeem bevordert de vorming van meer NH₃.

Deze principes worden toegepast in het Haber-Bosch-proces om de industriële productie van ammoniak te optimaliseren.

Conclusie

Dit Python-script biedt een praktische integratie van het model OpenAI o1-preview, waarmee je de geavanceerde redeneercapaciteiten kunt benutten voor een breed scala aan vragen, van het eenvoudigste tot het meest complexe. Of je nu een nieuwsgierige beginner bent of een expert die de grenzen van het model wil testen, dit script is een handig hulpmiddel voor je projecten op het gebied van kunstmatige intelligentie.

Bronnen

Dit document is vertaald van de versie fr naar de taal nl met behulp van het model gpt-5-mini. Voor meer informatie over het vertaalproces, raadpleeg https://gitlab.com/jls42/ai-powered-markdown-translator

Het OpenAI-model o1-preview integreren in een Python-script met verwerking van LaTeX-expressies

Inleiding

Vereisten

Configuratie van de virtuele omgeving

De OpenAI API-sleutel instellen

De volledige scriptcode

Uitleg van de code

Importeren van de benodigde modules

Functie get_web_content

Functie convert_latex_to_text

Functie clean_output

Functie get_response

Functie main

Script uitvoeren

Gebruikvoorbeelden

Een vraag stellen die redenering vereist

Een samenvatting van een webpagina genereren

Een eenvoudige vermenigvuldiging oplossen

Een eenvoudige vergelijking oplossen

Een percentage berekenen

De oppervlakte van een cirkel berekenen

Een eenvoudige integraal berekenen

Gemiddelde snelheid berekenen

Klassieke mechanica

Differentiaalvergelijkingen oplossen

Elektromagnetisme

Chemisch evenwicht

Conclusie

Bronnen

Functie `get_web_content`

Functie `convert_latex_to_text`

Functie `clean_output`

Functie `get_response`

Functie `main`