Integrar o modelo OpenAI o1-preview em um script Python com gerenciamento de expressões LaTeX

Descubra como integrar o novo modelo OpenAI o1-preview em um script Python para enriquecer seus projetos de inteligência artificial. Este script permite que você interaja com a API OpenAI usando o modelo o1-preview, com a possibilidade de incluir conteúdo da web nos prompts por meio de uma funcionalidade de web scraping. Além disso, ele lida corretamente com expressões matemáticas LaTeX nas respostas do modelo, convertendo-as em texto Unicode legível no terminal.

Introdução

Em 12 de setembro de 2024, a OpenAI lançou sua nova série de modelos de IA, chamada OpenAI o1. Esses modelos foram projetados para realizar um raciocínio aprofundado antes de fornecer uma resposta, o que lhes permite resolver problemas complexos em ciência, programação e matemática. O modelo o1-preview se destaca particularmente nesses domínios, superando modelos anteriores como gpt-4o.

Pontos-chave do script:

Integração do modelo o1-preview: O script usa o modelo o1-preview por padrão, oferecendo assim capacidades avançadas de raciocínio.
Web scraping integrado: Pode extrair o conteúdo de páginas web para enriquecer o contexto do prompt.
Gerenciamento de expressões LaTeX: As expressões matemáticas nas respostas são convertidas em texto Unicode para uma leitura fácil no terminal.
Personalizável: O script permite escolher o modelo OpenAI e pode ser adaptado a vários casos de uso.

Neste artigo, vou detalhar o código do script, explicar como ele funciona e realizar uma série de prompts complexos.

Pré-requisitos

Antes de começar, certifique-se de ter os seguintes itens:

Python 3.x instalado na sua máquina.
Uma chave de API OpenAI. Você pode obtê-la inscrevendo-se no site da OpenAI.
Um ambiente virtual Python (recomendado para isolar as dependências).
Os módulos Python necessários.

Configuração do ambiente virtual

Para isolar as dependências deste projeto, é recomendável usar um ambiente virtual. Aqui está como criar um e instalar as dependências necessárias :

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

Definir a chave API OpenAI

Defina sua chave de API OpenAI como uma variável de ambiente:

export OPENAI_API_KEY='votre_clé_api_ici'

Substitua 'votre_clé_api_ici' pela sua chave API real.

O código completo do script

Aqui está o código completo do script Python:

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

Explicação do código

Importação dos módulos necessários

O script começa importando os módulos essenciais:

os, sys, argparse, re: Módulos padrão para gerenciar variáveis de ambiente, argumentos de linha de comando e expressões regulares.
openai: Módulo para interagir com a API OpenAI.
selenium e webdriver_manager: Para realizar web scraping.
pylatexenc: Para converter expressões LaTeX em texto Unicode legível.

Função `get_web_content`

Esta função recupera o conteúdo textual de uma página web.

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

Pontos-chave:

Opções do Chrome: O script não usa o modo headless para evitar problemas de verificação humana que algumas páginas impõem a navegadores em modo headless.
ChromeDriverManager: Gerencia automaticamente a instalação e atualização do ChromeDriver.
Extração do conteúdo: Usa JavaScript para extrair o texto completo da página.
Tratamento de exceções: Em caso de erro, a função retorna None.

Função `convert_latex_to_text`

Esta função converte expressões LaTeX em texto Unicode.

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

Pontos-chave:

Usa a biblioteca pylatexenc para converter as expressões LaTeX, tornando as fórmulas matemáticas legíveis no terminal.

Função `clean_output`

Esta função processa a resposta do modelo para converter as expressões 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

Pontos-chave:

Busca de expressões LaTeX: Usa expressões regulares para identificar as fórmulas.
Conversão: Cada fórmula é convertida em texto Unicode.
Substituição: As fórmulas LaTeX são substituídas pelo seu equivalente legível.

Função `get_response`

Prepara o prompt, realiza o web scraping se necessário, chama a API OpenAI e limpa a resposta.

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

Pontos-chave:

Gerenciamento de URLs: Se o prompt contiver URLs, o conteúdo é extraído e inserido.
Chamada à API OpenAI: Envia o prompt modificado ao modelo especificado.
Limpeza da resposta: As expressões LaTeX são convertidas para facilitar a leitura.

Função `main`

Gerencia os argumentos de linha de comando e executa o script.

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)

Pontos-chave:

Argumentos: O script aceita um prompt e um modelo como argumentos.
Chave API: Verifica se a chave API está definida.
Execução: Chama a função get_response e exibe a resposta.

Execução do script

if __name__ == "__main__":
    main()

Exemplos de uso

Fazer uma pergunta que exija raciocínio

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

Para calcular o comprimento da hipotenusa em um triângulo retângulo cujos lados adjacentes ao ângulo reto medem 3 cm e 4 cm, usamos o teorema de Pitágoras:

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

Substituindo pelos valores dados:

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

Ao tirar a raiz quadrada dos dois lados:

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

Portanto, o comprimento da hipotenusa é 5 cm.

O comprimento da hipotenusa é 5 cm.

Gerar um resumo de uma página web

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

A OpenAI anunciou em 12 de setembro de 2024 a introdução de uma nova série de modelos de IA chamada OpenAI o1, projetada para levar mais tempo para refletir antes de responder. Esses modelos são capazes de raciocinar em tarefas complexas e resolver problemas mais difíceis do que os modelos anteriores em ciência, programação e matemática.

O primeiro modelo desta série, o1-preview, já está disponível no ChatGPT e via API da OpenAI. Uma versão mais leve e econômica, chamada OpenAI o1-mini, também é oferecida, oferecendo capacidades de codificação eficazes a um custo reduzido de 80% em relação ao o1-preview.

Resolver uma multiplicação simples

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

O resultado de $15 \times 12$ é 180.

Resolver uma equação simples

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

Para resolver a equação $2x + 5 = 15$ , siga os passos a seguir:

Subtrair 5 dos dois lados da equação para isolar o termo com a variável:

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

Dividir os dois lados da equação por 2 para resolver para $x$ :

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

Solução : $x = 5$ .

Calcular uma porcentagem

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

$20\%$ de $250$ é igual a 50.

Cálculo :

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

Calcular a área de um círculo

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

Para calcular a área de um círculo de raio 5 cm, use a fórmula da área de um círculo:

A = \pi r^2

onde:

$A$ é a área do círculo,
$r$ é o raio do círculo.

Substituindo $r$ por 5 cm:

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

Portanto, a área do círculo é $25\pi \text{ cm}^2$ .

Se você quiser um valor aproximado, usando $\pi \approx 3,1416$ :

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

Assim, a área do círculo é aproximadamente 78,54 cm².

Calcular uma integral simples

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

Para calcular a integral de 0 a 1 da função $x^2$ , vamos integrar $x^2$ em relação a $x$ e avaliar a expressão obtida entre os limites 0 e 1.

Passos do cálculo :

Integração da função $x^2$ :

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

onde C é a constante de integração.

Avaliação entre os limites 0 e 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)

Cálculo dos valores nos limites :

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

Subtração dos valores para obter o resultado final :

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

Conclusão :

O valor da integral de 0 a 1 de $x^2 \, dx$ é portanto $1/3$ .

Calcular uma velocidade média

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

Para calcular a velocidade média de um carro que percorre 150 km em 3 horas, usamos a fórmula da velocidade média :

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

Aplicando os valores dados :

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

A velocidade média do carro é portanto 50 km/h.

Mecânica clássica

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

Para calcular a aceleração do bloco, usamos a segunda lei de Newton, que afirma que a força resultante atuando sobre um objeto é igual à massa do objeto multiplicada pela sua aceleração ( $F = m \times a$ ).

Dado:

Massa do bloco, $m = 5 \text{ kg}$
Força aplicada, $F = 20 \text{ N}$
Superfície sem atrito (portanto nenhuma força oposta devido ao atrito)

Ao rearranjar a fórmula para resolver a aceleração ( $a$ ), obtemos:

a = \frac{F}{m}

Substituindo os valores dados:

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

Resposta : A aceleração do bloco é de 4 metros por segundo ao quadrado ( $4 \text{ m/s}^2$ ).

Resolução de equações diferenciais

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

Para resolver a equação diferencial :

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

com a condição inicial $y(0) = 1$ , observamos que esta equação é não linear e não pode ser resolvida pelos métodos elementares como separação de variáveis ou fatores integrantes padrão. Contudo, podemos tentar transformar a equação em uma forma mais solúvel.

Passo 1 : Reconhecer a natureza da equação

A equação dada é uma equação diferencial de Riccati que tem a forma geral :

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

No nosso caso, ela se escreve :

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

Passo 2 : Transformar a equação em uma equação linear de segunda ordem

Para resolver uma equação de Riccati, podemos usar a substituição seguinte :

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

onde $u = u(x)$ é uma função a determinar, e $u'$ é a derivada de $u$ em relação a $x$ .

Cálculo de $y'$ em função de $u$ :

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

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

Aplicando a regra do quociente :

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

Passo 3 : Substituir na equação inicial

Substituímos $y$ e $y'$ na equação diferencial original :

y' = x^2 + y^2

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

Simplificamos a equação :

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

Agora, multiplicamos ambos os lados por $u^2$ para eliminar os denominadores :

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

Simplificamos :

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

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

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

Dividindo por $u$ (assumindo $u \neq 0$ ) :

u'' = -x^2 u

Passo 4 : Resolver a equação linear de segunda ordem

Obtemos então uma equação diferencial linear homogênea de segunda ordem :

u'' + x^2 u = 0

Esta equação é uma equação diferencial linear com coeficientes variáveis. Ela é conhecida como uma forma relacionada à equação de Airy. As soluções desta equação não são expressáveis em termos de funções elementares, mas são dadas em termos de funções especiais chamadas funções de Airy.

Soluções da equação :

As soluções gerais da equação $u'' + x^2 u = 0$ são :

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

onde $\text{Ai}$ e $\text{Bi}$ são as funções de Airy de primeira e segunda espécie, e $i$ é a unidade imaginária tal que $i^2 = -1$ .

Passo 5 : Voltar para $y(x)$

Lembrando que :

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

Conhecendo $u(x)$ , podemos encontrar $y(x)$ calculando a derivada de $u$ e efetuando o quociente.

Passo 6 : Aplicar a condição inicial

Para determinar as constantes de integração $C_1$ e $C_2$ , devemos aplicar a condição inicial $y(0) = 1$ . No entanto, dada a complexidade das funções de Airy com argumentos complexos, o cálculo explícito é delicado.

Conclusão

A solução da equação diferencial dada com a condição inicial $y(0) = 1$ é expressa em termos de funções especiais (funções de Airy). Não pode ser escrita em termos de funções elementares como polinômios, exponenciais, senos ou cossenos.

Resposta final :

A solução da equação diferencial $\frac{dy}{dx} = x^2 + y^2$ com $y(0) = 1$ é dada implicitamente em termos das funções de Airy, e não pode ser expressa explicitamente com funções elementares.

Eletromagnetismo

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

O campo elétrico $E$ criado por uma carga pontual $Q$ a uma distância $r$ é dado pela lei de Coulomb. A fórmula para calcular o campo elétrico é :

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

onde :

$E$ é o campo elétrico (em volts por metro, V/m),
$Q$ é a carga pontual (em coulombs, C),
$r$ é a distância até a carga (em metros, m),
$\epsilon_0$ é a permissividade do vácuo, com valor aproximado de $8,854 \times 10^{-12} \text{ C}^2/\text{N}\cdot\text{m}^2$ .

Exemplo de cálculo :

Suponha que você tenha uma carga $Q = 2 \times 10^{-6} \text{ C}$ (2 microcoulombs) e deseje calcular o campo elétrico a uma distância $r = 0,5 \text{ m}$ .

Calcule a constante na frente da fração :

\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

Aplique a fórmula :

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}

Conclusão :

O campo elétrico a uma distância de $r = 0,5 \text{ m}$ de uma carga pontual de $Q = 2 \times 10^{-6} \text{ C}$ é $E = 71\,904 \text{ V/m}$ .

Assim, para calcular o campo elétrico a uma distância dada de uma carga pontual, use a fórmula acima substituindo $Q$ e $r$ pelos valores específicos do problema.

Equilíbrio químico

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

O princípio de Le Chatelier afirma que, quando um sistema em equilíbrio é submetido a uma modificação (estresse) externa, ele reage de forma a minimizar essa perturbação e estabelecer um novo equilíbrio. Aplicado ao equilíbrio químico seguinte :

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

podemos analisar como diferentes modificações influenciam a posição do equilíbrio.

1. Variação da concentração : - Aumento da concentração de reagentes (N₂ ou H₂) : Se for introduzido azoto (N₂) ou hidrogénio (H₂) no sistema, a concentração desses reagentes aumenta. Segundo o Princípio de Le Chatelier, o equilíbrio deslocar-se-á no sentido que consome esses reagentes adicionais, ou seja, para a direita, favorecendo a formação de amónia (NH₃).

Diminuição da concentração de produtos (NH₃) : Se for removida amónia do sistema, a concentração de NH₃ diminui. O equilíbrio deslocar-se-á então para a direita para compensar essa diminuição, favorecendo novamente a formação de amónia.
Aumento da concentração de produtos (NH₃) : Se for adicionada amónia ao sistema, o equilíbrio deslocar-se-á para a esquerda para reduzir o excesso de NH₃, favorecendo a formação de N₂ e H₂.

2. Variação da pressão :

Aumento da pressão total do sistema : Para os gases, um aumento da pressão (por diminuição do volume) favorece a reacção que produz menos moles gasosos. Nesta reacção, passa-se de 4 moles de gás (1 N₂ + 3 H₂) para 2 moles de gás (2 NH₃). Portanto, o aumento da pressão desloca o equilíbrio para a direita, favorecendo a formação de amónia.
Diminuição da pressão total do sistema : Inversamente, uma diminuição da pressão favorecerá a reacção que produz mais moles gasosos, deslocando o equilíbrio para a esquerda e favorecendo a dissociação de NH₃ em N₂ e H₂.

3. Variação da temperatura :

Natureza exotérmica da reacção : A síntese da amónia é uma reacção exotérmica ( $\Delta H < 0$ ), ou seja, liberta calor.
Aumento da temperatura : Ao aumentar a temperatura, fornece-se calor ao sistema. Segundo o Princípio de Le Chatelier, o equilíbrio deslocar-se-á no sentido que absorve esse calor adicional, portanto para a esquerda (reacção endotérmica), favorecendo a dissociação de NH₃ em N₂ e H₂.
Diminuição da temperatura : Ao baixar a temperatura, o sistema reage produzindo calor para compensar essa perda. O equilíbrio desloca-se assim para a direita (reacção exotérmica), favorecendo a formação de amónia.

4. Presença de um catalisador :

Efeito do catalisador : A adição de um catalisador (como ferro finamente dividido com promotores) aumenta a velocidade com que o equilíbrio é atingido, mas não altera a posição do equilíbrio. Acelera tanto as reacções directa como inversa de forma igual.

Resumo :

O Princípio de Le Chatelier permite prever a direcção em que um equilíbrio químico se moverá em resposta a uma alteração das condições do sistema. Para a síntese da amónia :

Pressão elevada favorece a formação de NH₃ (menos moles gasosos).
Temperatura baixa favorece a formação de NH₃ (reacção exotérmica).
Aumento das concentrações de N₂ ou H₂ favorece a formação de NH₃.
Remoção de NH₃ do sistema favorece a formação de mais NH₃.

Estes princípios são aplicados no processo Haber-Bosch para optimizar a produção industrial de amónia.

Conclusão

Este script Python oferece uma integração prática do modelo OpenAI o1-preview, permitindo explorar as suas capacidades de raciocínio avançado para uma vasta gama de questões, do mais simples ao mais complexo. Quer seja um principiante curioso ou um especialista a tentar testar os limites do modelo, este script é uma ferramenta útil para os seus projectos em inteligência artificial.

Recursos

Este documento foi traduzido da versão fr para a língua pt usando o modelo gpt-5-mini. Para mais informações sobre o processo de tradução, consulte https://gitlab.com/jls42/ai-powered-markdown-translator

Integrar o modelo OpenAI o1-preview em um script Python com gerenciamento de expressões LaTeX

Introdução

Pré-requisitos

Configuração do ambiente virtual

Definir a chave API OpenAI

O código completo do script

Explicação do código

Importação dos módulos necessários

Função get_web_content

Função convert_latex_to_text

Função clean_output

Função get_response

Função main

Execução do script

Exemplos de uso

Fazer uma pergunta que exija raciocínio

Gerar um resumo de uma página web

Resolver uma multiplicação simples

Resolver uma equação simples

Calcular uma porcentagem

Calcular a área de um círculo

Calcular uma integral simples

Calcular uma velocidade média

Mecânica clássica

Resolução de equações diferenciais

Eletromagnetismo

Equilíbrio químico

Conclusão

Recursos

Função `get_web_content`

Função `convert_latex_to_text`

Função `clean_output`

Função `get_response`

Função `main`