Integrera OpenAI-modellen o1-preview i ett Python-skript med hantering av LaTeX-uttryck

Lär dig hur du integrerar den nya modellen OpenAI o1-preview i ett Python-skript för att berika dina AI‑projekt. Detta skript låter dig interagera med OpenAI:s API med modellen o1-preview, med möjlighet att inkludera webbinnehåll i promptarna tack vare en inbyggd web scraping‑funktion. Dessutom hanterar det matematiska uttryck skrivna i LaTeX i modellens svar genom att konvertera dem till läsbar Unicode‑text i terminalen.

Introduktion

Den 12 september 2024 lanserade OpenAI sin nya serie AI‑modeller kallad OpenAI o1. Dessa modeller är utformade för att utföra djupare resonemang innan de levererar ett svar, vilket gör dem kapabla att lösa komplexa problem inom vetenskap, programmering och matematik. Modellen o1-preview utmärker sig särskilt i dessa områden och överträffar tidigare modeller som gpt-4o.

​Viktiga punkter i skriptet:

• Integration av modellen o1-preview: Skriptet använder modellen o1-preview som standard och erbjuder därmed avancerade resonemangsegenskaper.
• Inbyggd web scraping: Det kan extrahera innehåll från webbsidor för att berika promptens kontext.
• Hantering av LaTeX‑uttryck: Matematiska uttryck i svaren konverteras till Unicode‑text för enkel läsning i terminalen.
• Anpassningsbart: Skriptet låter dig välja OpenAI‑modell och kan anpassas för olika användningsfall.

I den här artikeln kommer jag att gå igenom skriptets kod i detalj, förklara hur det fungerar och genomföra en serie komplexa prompts.

Förutsättningar

Innan du börjar, se till att du har följande:

• Python 3.x installerat på din dator.
• En OpenAI API‑nyckel. Du kan skaffa den genom att registrera dig på OpenAI:s webbplats.
• En Python virtuell miljö (rekommenderas för att isolera beroenden).
• Nödvändiga Python‑moduler.

Konfigurera den virtuella miljön

För att isolera projektets beroenden rekommenderas att använda en virtuell miljö. Så här skapar du en och installerar de krävd beroenden:

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

Ange OpenAI API‑nyckeln

Sätt din OpenAI API‑nyckel som en miljövariabel:

export OPENAI_API_KEY='votre_clé_api_ici'

Byt ut 'votre_clé_api_ici' mot din faktiska API‑nyckel.

Komplett skriptkod

Här är den kompletta Python‑koden för skriptet:

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

Förklaring av koden

Import av nödvändiga moduler

Skriptet börjar med att importera de viktigaste modulerna:

• os, sys, argparse, re: Standardmoduler för att hantera miljövariabler, kommandoradsargument och reguljära uttryck.
• openai: Modul för att interagera med OpenAI API.
• selenium och webdriver_manager: För att utföra web scraping.
• pylatexenc: För att konvertera LaTeX‑uttryck till läsbar Unicode‑text.

Funktion get_web_content

Denna funktion hämtar sidans textinnehåll från en webbsida.

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

Viktiga punkter:

• Chrome‑alternativ: Skriptet använder inte headless‑läge för att undvika verifieringsproblem som vissa sidor kräver för headless‑webbläsare.
• ChromeDriverManager: Hanterar automatiskt installation och uppdatering av ChromeDriver.
• Extraktion av innehåll: Använder JavaScript för att extrahera sidans fullständiga text.
• Felfall: Vid fel returnerar funktionen None.

Funktion convert_latex_to_text

Denna funktion konverterar LaTeX‑uttryck till Unicode‑text.

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

Viktiga punkter:

• Använder biblioteket pylatexenc för att konvertera LaTeX‑uttryck så att matematiska formler blir läsbara i terminalen.

Funktion clean_output

Denna funktion bearbetar modellens svar för att konvertera LaTeX‑uttryck.

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

Viktiga punkter:

• Sökning efter LaTeX‑uttryck: Använder reguljära uttryck för att identifiera formler.
• Konvertering: Varje formel konverteras till Unicode‑text.
• Ersättning: LaTeX‑formler ersätts med deras läsbara motsvarighet.

Funktion get_response

Förbereder prompten, hanterar web scraping vid behov, anropar OpenAI API och rensar svaret.

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

Viktiga punkter:

• Hantering av URL:er: Om prompten innehåller URL:er hämtas innehållet och infogas.
• API‑anrop: Skickar den modifierade prompten till angiven modell.
• Rensning av svaret: LaTeX‑uttryck konverteras för att vara lättlästa.

Funktion main

Hantera kommandoradsargument och kör skriptet.

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)

Viktiga punkter:

• Argument: Skriptet tar emot en prompt och en modell som argument.
• API‑nyckel: Kontrollerar att API‑nyckeln är satt.
• Körning: Anropar funktionen get_response och skriver ut svaret.

Körning av skriptet

if __name__ == "__main__":
    main()

Exempel på användning

Ställ en fråga som kräver resonemang

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

För att beräkna längden på hypotenusan i en rätvinklig triangel med kateterna 3 cm och 4 cm använder vi Pythagoras sats:

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

Genom att ersätta med givna värden:

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

Genom att ta kvadratroten på båda sidor:

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

Alltså är hypotenusans längd 5 cm.

Hypotenusans längd är 5 cm.

Generera en sammanfattning av en webbsida

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

OpenAI meddelade den 12 september 2024 introduktionen av en ny serie AI‑modeller kallad OpenAI o1, designade för att ta mer tid på sig att reflektera innan de svarar. Dessa modeller kan resonera genom komplexa uppgifter och lösa svårare problem än tidigare modeller inom vetenskap, programmering och matematik.

Den första modellen i denna serie, o1-preview, finns nu tillgänglig i ChatGPT och via OpenAI:s API. En lättare och billigare variant kallad OpenAI o1‑mini erbjuds också, som ger effektiva kodningsmöjligheter till cirka 80 % lägre kostnad jämfört med o1‑preview.

Utför en enkel multiplikation

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

Resultatet av $15 \times 12$ är 180.

Lös en enkel ekvation

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

För att lösa ekvationen $2x + 5 = 15$, följ dessa steg:

1. Subtrahera 5 från båda sidor för att isolera termerna med variabeln:

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

2. Dividera båda sidor med 2 för att lösa för $x$:

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

Lösning : $x = 5$.

Beräkna en procent

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

$20\%$ av $250$ är lika med 50.

Beräkning :

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

Beräkna arean av en cirkel

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

För att beräkna arean av en cirkel med radien 5 cm, använd formeln för cirkelarea:

$$A = \pi r^2$$

där:

• $A$ är arean av cirkeln,
• $r$ är cirkelns radie.

Genom att ersätta $r$ med 5 cm:

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

Alltså är cirkelns area $25\pi \text{ cm}^2$.

Om du vill ha ett ungefärligt värde, med $\pi \approx 3,1416$:

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

Så arean är ungefär 78,54 cm².

Beräkna ett enkelt integralvärde

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

För att beräkna integralen från 0 till 1 av funktionen $x^2$, integrerar vi $x^2$ med avseende på $x$ och utvärderar uttrycket mellan gränserna 0 och 1.

Steg i beräkningen :

1. Integrera funktionen $x^2$ :

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

där C är integrationskonstanten.

2. Utvärdera mellan 0 och 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. Beräkna gränsvärdena :

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

4. Subtrahera för att få slutresultatet :

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

Slutsats :

Värdet av integralen från 0 till 1 av $x^2 \, dx$ är alltså $1/3$.

Beräkna medelhastighet

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

För att beräkna medelhastigheten hos en bil som färdas 150 km på 3 timmar använder vi formeln för medelhastighet:

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

Genom att sätta in givna värden:

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

Bilens medelhastighet är alltså 50 km/h.

Klassisk mekanik

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

För att beräkna accelerationen av klossen använder vi Newtons andra lag, som säger att den resulterande kraften på ett föremål är lika med massan multiplicerad med accelerationen ($F = m \times a$).

Givet:

• Massa på klossen, $m = 5 \text{ kg}$
• Applicerad kraft, $F = 20 \text{ N}$
• Ingen friktion (så ingen motkraft från friktion)

Genom att omarrangera formeln för att lösa för accelerationen ($a$) får vi:

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

Genom att ersätta värdena:

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

Svar : Accelerationen är 4 meter per sekund i kvadrat ($4 \text{ m/s}^2$).

Lösning av differentialekvationer

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

För att lösa differentialekvationen:

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

med begynnelsevillkoret $y(0) = 1$, noterar vi att denna ekvation är icke‑linjär och kan inte lösas med elementära metoder som separering av variabler eller standardintegrerande faktorer. Vi kan däremot försöka omvandla ekvationen till en mer hanterbar form.

Steg 1 : Känna igen ekvationens natur

Den givna ekvationen är en Riccati‑ekvation som i allmän form skrivs som:

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

I vårt fall blir den:

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

Steg 2 : Omvandla till en linjär andragradsekvation

För att lösa en Riccati‑ekvation kan vi använda substitutionen:

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

där $u = u(x)$ är en funktion att bestämma och $u'$ är derivatan av $u$ med avseende på $x$.

Beräkning av $y'$ i termer av $u$ :

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

Använd kvotregeln:

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

Steg 3 : Sätt in i ursprungsekvationen

Sätt in $y$ och $y'$ i differentialekvationen:

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

Förenkla:

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

Multiplicera båda sidor med $u^2$ för att eliminera nämnarna:

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

Förenkla vidare:

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

Dividera med $u$ (förutsatt $u \neq 0$):

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

Steg 4 : Lös den linjära andragradsekvationen

Vi får en linjär homogen andragradsekvation:

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

Denna ekvation har variabla koefficienter och är känd i samband med Airy‑typ‑funktioner. Lösningarna kan inte uttryckas med elementära funktioner utan ges i termer av specialfunktioner kallade Airyf‑funktioner.

Ekvationens allmänna lösning:

Lösningarna till $u'' + x^2 u = 0$ är:

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

där $\text{Ai}$ och $\text{Bi}$ är Airy‑funktionerna av första och andra slag, och $i$ är den imaginära enheten med $i^2 = -1$.

Steg 5 : Gå tillbaka till $y(x)$

Kom ihåg att:

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

Genom att känna till $u(x)$ kan vi få $y(x)$ genom att derivera $u$ och ta kvoten.

Steg 6 : Tillämpa begynnelsevillkoret

För att bestämma integrationskonstanterna $C_1$ och $C_2$ måste vi använda villkoret $y(0) = 1$. På grund av komplexiteten hos Airy‑funktioner med komplexa argument blir den explicita beräkningen svår.

Slutsats

Lösningen till differentialekvationen $\frac{dy}{dx} = x^2 + y^2$ med begynnelsevillkoret $y(0) = 1$ uttrycks implicit via specialfunktioner (Airy‑funktioner) och kan inte skrivas i slutna termer med elementära funktioner.

Elektromagnetism

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

Det elektriska fältet $E$ skapat av en punktladdning $Q$ på avståndet $r$ ges av Coulombs lag. Formeln för det elektriska fältet är:

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

där:

• $E$ är det elektriska fältet (i volt per meter, V/m),
• $Q$ är punktladdningen (i coulomb, C),
• $r$ är avståndet till laddningen (i meter, m),
• $\epsilon_0$ är vakuums permittivitet, ungefär $8,854 \times 10^{-12} \text{ C}^2/\text{N}\cdot\text{m}^2$.

Exempelberäkning :

Antag att du har en laddning $Q = 2 \times 10^{-6} \text{ C}$ (2 mikrocoulomb) och vill beräkna det elektriska fältet på avståndet $r = 0,5 \text{ m}$.

1. Beräkna konstanten framför bråket :

$$\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. Applicera formeln :

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

Slutsats :

Det elektriska fältet på avståndet $r = 0,5 \text{ m}$ från en punktladdning $Q = 2 \times 10^{-6} \text{ C}$ är $E = 71\,904 \text{ V/m}$.

Således, för att beräkna det elektriska fältet på ett visst avstånd från en punktladdning, använd formeln ovan och ersätt $Q$ och $r$ med respektive värden.

Kemisk jämvikt

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

Le Chateliers princip säger att när ett system i jämvikt utsätts för en yttre förändring (stress) så reagerar det för att motverka förändringen och etablera ett nytt jämviktstillstånd. Tillämpat på den kemiska jämvikten:

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

kan vi analysera hur olika förändringar påverkar jämviktsläge.

1. Ändring i koncentration : - Ökning av reaktanternas koncentration (N₂ eller H₂) : Om man tillsätter kvävgas (N₂) eller vätgas (H₂) till systemet ökar koncentrationen av dessa reaktanter. Enligt Le Chateliers princip kommer jämvikten att förskjutas åt det håll som förbrukar dessa extra reaktanter, det vill säga åt höger, vilket gynnar bildningen av ammoniak (NH₃).

• Minskning av produktkoncentrationen (NH₃) : Om man avlägsnar ammoniak från systemet minskar NH₃-koncentrationen. Jämvikten kommer då att förskjutas åt höger för att kompensera denna minskning, vilket återigen gynnar bildningen av ammoniak.

• Ökning av produktkoncentrationen (NH₃) : Om man tillsätter ammoniak till systemet förskjuts jämvikten åt vänster för att minska överskottet av NH₃, vilket gynnar bildningen av N₂ och H₂.

2. Ändring av trycket :

• Ökning av systemets totala tryck : För gaser gynnar en ökning av trycket (genom minskning av volymen) den reaktion som ger färre mol gas. I denna reaktion går man från 4 mol gas (1 N₂ + 3 H₂) till 2 mol gas (2 NH₃). Därför förskjuter en ökning av trycket jämvikten åt höger och gynnar bildningen av ammoniak.

• Minskning av systemets totala tryck : Omvänt kommer en minskning av trycket att gynna den reaktion som ger flest mol gas, vilket förskjuter jämvikten åt vänster och gynnar dissociationen av NH₃ till N₂ och H₂.

3. Ändring av temperaturen :

• Reaktionens exotermiska natur : Ammoniakssyntesen är en exoterm reaktion ($\Delta H < 0$), det vill säga att den avger värme.

• Ökning av temperaturen : Genom att öka temperaturen tillför man värme till systemet. Enligt Le Chateliers princip förskjuts jämvikten i den riktning som absorberar denna extra värme, alltså åt vänster (endoterm riktning), vilket gynnar dissociationen av NH₃ till N₂ och H₂.

• Minskning av temperaturen : Genom att sänka temperaturen reagerar systemet genom att producera värme för att kompensera denna förlust. Jämvikten förskjuts därför åt höger (exoterm riktning), vilket gynnar bildningen av ammoniak.

4. Närvaro av en katalysator :

• Effekt av katalysatorn : Tillsats av en katalysator (som finfördelat järn med promotorsubstanser) ökar hastigheten med vilken jämvikten uppnås, men ändrar inte jämviktsläget. Den accelererar både fram- och backreaktionen i lika hög grad.

Sammanfattning :

Le Chateliers princip gör det möjligt att förutsäga i vilken riktning en kemisk jämvikt förskjuts som svar på en förändring i systemets villkor. För ammoniaksyntesen:

• Högt tryck gynnar bildningen av NH₃ (färre mol gas).
• Låg temperatur gynnar bildningen av NH₃ (exoterm reaktion).
• Ökning av koncentrationerna av N₂ eller H₂ gynnar bildningen av NH₃.
• Avlägsnande av NH₃ från systemet gynnar bildningen av mer NH₃.

Dessa principer tillämpas i Haber-Bosch-processen för att optimera den industriella produktionen av ammoniak.

Slutsats

Detta Python-skript erbjuder en praktisk integration av modellen OpenAI o1-preview, vilket gör det möjligt att utnyttja dess avancerade resonemangskapaciteter för ett brett spektrum av frågor, från de enklaste till de mest komplexa. Oavsett om du är en nyfiken nybörjare eller en expert som vill testa modellens gränser är detta skript ett bra verktyg för dina projekt inom artificiell intelligens.

Resurser

• Tillkännagivande av modellen OpenAI o1-preview
• Officiell dokumentation för OpenAI-API:et
• Dokumentation för Selenium
• Dokumentation för pylatexenc
• Guide om virtuella miljöer i Python

Detta dokument har översatts från fr-versionen till sv-språket med modellen gpt-5-mini. För mer information om översättningsprocessen, se https://gitlab.com/jls42/ai-powered-markdown-translator