PHPOpenAI Téléchargement - Téléchargement du code source PHPOpenAI

Phpopenai

PHPOpenAI est une bibliothèque entretenue par la communauté qui permet l'utilisation de l'API OpenAI dans PHP.

Le projet est écrit en PHP et peut être utilisé pour intégrer facilement l' OpenAI API dans votre projet PHP existant.

Exigences du système

Ce projet est basé sur PHP version 8.1 afin d'utiliser des fonctionnalités telles que des énumérations. Ce projet ne nécessite aucune dépendance externe. Cependant, vous devez avoir l'installation de l'extension Curl pour qu'il fonctionne correctement.

Version PHP> = 8.1
extension de boucle

Installation

Le projet utilise le compositeur pour gérer les dépendances. Si vous n'avez pas déjà installé Composer, vous pouvez le faire en suivant les instructions sur le site officiel du compositeur.

Installation de packagistes

Pour installer le projet, vous pouvez installer le package à partir de packagist.org en utilisant la commande suivante:

composer require easygithdev/php-openai

Écrire un premier exemple

Pour utiliser l' OpenAI API , vous devez vous inscrire sur leur site Web et obtenir une clé API. Une fois que vous avez votre clé API, vous pouvez l'utiliser dans votre code PHP pour envoyer des demandes à l'API OpenAI.

Pour savoir comment obtenir votre clé, accédez à l'adresse suivante:

https://help.openai.com/en/articles/4936850-where-do-i-find-my-secret-api-key.

Voici un exemple de code qui vous montre comment utiliser l'API OpenAI dans PHP:

 <?php
require_once __DIR__ . ' /vendor/autoload.php ' ;

use EasyGithDev  PHPOpenAI  Helpers  ModelEnum ;
use EasyGithDev  PHPOpenAI  OpenAIClient ;

$ apiKey = getenv ( ' OPENAI_API_KEY ' );

$ response = ( new OpenAIClient ( $ apiKey ))-> Completion ()-> create (
    ModelEnum:: TEXT_DAVINCI_003 ,
    " Say this is a test " ,
)-> toObject ();

// Response as stClass object
echo ' <pre> ' , print_r ( $ response , true ), ' </pre> ' ;

Ce code instancie un nouvel objet OpenAIApi avec une clé API, puis crée un nouvel objet Completion pour effectuer l'achèvement du texte avec le modèle de langue GPT-3 AI fourni par OpenAI.

La méthode create() est appelée sur l'objet Completion pour générer un nouveau texte terminé. Il faut deux paramètres:

Le premier paramètre est l'ID du modèle GPT-3 à utiliser pour l'achèvement. Dans ce cas, il utilise le modèle text_davinci_003.
Le deuxième paramètre est l'invite ou le texte d'entrée pour lequel l'achèvement sera généré. Dans ce cas, l'invite est "dire que c'est un test".

Le résultat de l'achèvement est retourné dans la variable $response . Le résultat peut ensuite être utilisé pour un traitement ultérieur, tel que l'affichage du texte terminé ou l'alimenter dans une autre partie du programme pour un traitement supplémentaire.

Gérer la clé API

Vous pouvez utiliser une variable d'environnement pour stocker votre clé. Vous pouvez ensuite utiliser cette variable comme dans l'exemple suivant:

 export OPENAI_API_KEY= " sk-xxxxxxxxxxx "

Vous pouvez mettre la variable dans le fichier de configuration Apache:

 <VirtualHost hostname:80>
   ...
   SetEnv OPENAI_API_KEY sk-xxxxxxxxxxx
   ...
</VirtualHost>

Puis redémarrez le service.

Maintenant, vous pouvez utiliser la variable d'environnement en appelant la fonction getenv() de PHP.

 <?php
$ response = ( new OpenAIApi ( getenv ( ' OPENAI_API_KEY ' )))-> Completion ()-> create (
    ModelEnum:: TEXT_DAVINCI_003 ,
    " Say this is a test " ,
);

Gérer l'organisation

Si vous souhaitez fournir des informations sur votre organisation, vous devez procéder comme suit.

 <?php
$ apiKey = getenv ( ' OPENAI_API_KEY ' );
$ org = getenv ( ' OPENAI_API_ORG ' );

// Passing the organization to the client
$ response = ( new OpenAIClient ( $ apiKey , $ org ))

Gérer l'URL de l'API

Si vous devez modifier l'URL de l'API, vous pouvez procéder comme suit:

 <?php
$ apiKey = getenv ( ' OPENAI_API_KEY ' );

// Create a new router, with origine url and version
$ route = new OpenAIRoute (
    ' https://api.openai.com ' ,
    ' v1 '
);

// Get a specific Url
echo $ route -> completionCreate () , ' <br> ' ;

// Passing the router to the client
$ response = ( new OpenAIClient ( $ apiKey ))
    -> setRoute ( $ route );

Pour redéfinir un itinéraire, vous devez étendre la classe OpenAIRoute ou implémenter l'interface Route .

Gérer les repres

L'API renvoie les réponses au format JSON. Pour faciliter l'accès aux différentes informations, vous pouvez appeler toObject() ou toArray() des méthodes de l'objet de gestionnaire pour accéder aux données.

 <?php

$ response = ( new OpenAIClient ( $ apiKey ))-> Completion ()-> create (
    ModelEnum:: TEXT_DAVINCI_003 ,
    " Say this is a test " ,
)-> toObject ();

// Response as a stClass object
echo ' <pre> ' , print_r ( $ response , true ), ' </pre> ' ;

$ response = ( new OpenAIClient ( $ apiKey ))-> Completion ()-> create (
    ModelEnum:: TEXT_DAVINCI_003 ,
    " Say this is a test " ,
)-> toArray ();

// Response as an associative array
echo ' <pre> ' , print_r ( $ response , true ), ' </pre> ' ;

Gérer les erreurs

Parfois, l'API renvoie les erreurs. Par conséquent, il est nécessaire de pouvoir identifier ce qui a causé le problème. Pour gérer cette difficulté, vous avez de nombreuses options.

Si vous utilisez un objet de gestionnaire avec des méthodes toObject() ou toArray() , utilisez simplement une structure try-catch .

 try {
    $ response = ( new OpenAIClient ( ' BAD KEY ' ))
        -> Completion ()
        -> create (
            ModelEnum:: TEXT_DAVINCI_003 ,
            " Say this is a test " ,
        )
        -> toObject ();
} catch ( Throwable $ t ) {
    echo nl2br ( $ t -> getMessage ());
    die;
}

Si vous utilisez l'objet CurlResponse , vous pouvez vérifier qu'une erreur s'est produite à l'aide des validateurs.

 $ handler = ( new OpenAIClient ( ' BAD KEY ' ))-> Completion ()-> create (
    ModelEnum:: TEXT_DAVINCI_003 ,
    " Say this is a test " ,
);

$ response = $ handler -> getResponse ();
$ contentTypeValidator = $ handler -> getContentTypeValidator ();

if (!( new StatusValidator ( $ response ))-> validate () or 
    !( new $ contentTypeValidator ( $ response ))-> validate ()) {
    echo $ response -> getBody ();
}

En savoir plus sur les erreurs.

Un exemple d'application

Voici une vidéo montrant une application qui vous permet de créer des images avec un style de peinture défini par l'utilisateur. Cette application est créée à l'aide du projet PHPOPENAI.

playground.mp4

Vous pouvez trouver le code ici:

https://github.com/easygithdev/phpopenai-playground.git.

Échantillons de code

L'intégration d'OpenAI dans votre application est désormais aussi simple que quelques lignes de code.

Vous pouvez trouver tous les codes ici:

https://github.com/easygithdev/phpopenai-examples.

Achèvement du texte à l'aide de chatppt

 $ response = ( new OpenAIClient ( $ apiKey ))-> Chat ()-> create (
    ModelEnum:: GPT_3_5_TURBO ,
    [
        new ChatMessage (ChatMessage:: ROLE_SYSTEM , " You are a helpful assistant. " ),
        new ChatMessage (ChatMessage:: ROLE_USER , " Who won the world series in 2020? " ),
        new ChatMessage (ChatMessage:: ROLE_ASSISTANT , " The Los Angeles Dodgers won the World Series in 2020. " ),
        new ChatMessage (ChatMessage:: ROLE_USER , " Where was it played? " ),
    ]
)-> toObject ();

En savoir plus sur l'achèvement du chat.

Achèvement du texte à l'aide de GPT-3

 $ response = ( new OpenAIClient ( $ apiKey ))-> Completion ()-> create (
    ModelEnum:: TEXT_DAVINCI_003 ,
    " Say this is a test " ,
)-> toObject ();

En savoir plus sur l'achèvement du texte.

Achèvement du texte à l'aide du flux

L'attribut de flux dans l'API OpenAI est un paramètre facultatif que vous pouvez utiliser pour contrôler le flux de données renvoyé par l'API. Si vous définissez cette option sur true, l'API renvoie une réponse en tant que données de streaming plutôt qu'une seule réponse.

Cela signifie que vous pouvez récupérer les résultats de l'API à mesure qu'ils deviennent disponibles, plutôt que d'attendre la réponse complète avant de les traiter. Cette option peut être utile pour les applications qui nécessitent un traitement en temps réel de grandes quantités de données.

openai-completion-stream.mp4

 <?php
header ( ' Content-Type: text/event-stream ' );
header ( ' Cache-Control: no-cache ' );

. . .

( new OpenAIClient ( $ apiKey ))-> Completion ()-> create (
    model: " text-davinci-003 " ,
    prompt: " Translate this into 1. French, 2. Spanish and 3. Japanese: nn What rooms do you have available? nn 1. " ,
    temperature: 0.3 ,
    max_tokens: 100 ,
    top_p: 1.0 ,
    frequency_penalty: 0.0 ,
    presence_penalty: 0.0 ,
    stream: true
)-> getResponse ();

 < html >

< body >
    < div id =" result " > </ div >
    < script >
        function nl2br ( str , replaceMode , isXhtml ) {
            var breakTag = ( isXhtml ) ? '<br />' : '<br>' ;
            var replaceStr = ( replaceMode ) ? '$1' + breakTag : '$1' + breakTag + '$2' ;
            return ( str + '' ) . replace ( / ([^>rn]?)(rn|nr|r|n) / g , replaceStr ) ;
        }

        if ( typeof ( EventSource ) !== 'undefined' ) {
            console . info ( 'Starting connection...' ) ;
            var source = new EventSource ( 'stream.php' ) ;
            source . addEventListener ( 'open' , function ( e ) {
                console . info ( 'Connection was opened.' ) ;
            } , false ) ;

            source . addEventListener ( 'error' , function ( e ) {
                var txt ;
                switch ( event . target . readyState ) {
                    // if reconnecting
                    case EventSource . CONNECTING :
                        txt = 'Reconnecting...' ;
                        break ;
                    // if error was fatal
                    case EventSource . CLOSED :
                        txt = 'Connection failed. Will not retry.' ;
                        break ;
                }
                console . error ( 'Connection error: ' + txt ) ;
            } , false ) ;

            source . addEventListener ( 'message' , function ( e ) {
                if ( e . data == "[DONE]" ) {
                    source . close ( ) ;
                    return ;
                }
                document . getElementById ( 'result' ) . innerHTML += nl2br ( JSON . parse ( e . data ) . choices [ 0 ] . text ) ;

            } , false ) ;
        } else {
            alert ( 'Your browser does not support Server-sent events! Please upgrade it!' ) ;
            console . error ( 'Connection aborted' ) ;
        }
    </ script >
</ body >

</ html >

Modifier le texte

 $ response = ( new OpenAIClient ( $ apiKey ))-> Edit ()-> create (
    " What day of the wek is it? " ,
    ModelEnum:: TEXT_DAVINCI_EDIT_001 ,
    " Fix the spelling mistakes " ,
)-> toObject ();

En savoir plus sur l'édition de texte.

Génération d'images à l'aide de Dall · E

 function displayUrl ( $ url )
{
    return ' <img src=" ' . $ url . ' " /> ' ;
}

$ response = ( new OpenAIClient ( $ apiKey ))-> Image ()-> create (
    " a rabbit inside a beautiful garden, 32 bit isometric " ,
    n: 2 ,
    size: ImageSizeEnum::is256,
)-> toObject ();

 < ?php foreach ($response- > data as $image) : ? >
    < div > < ?= displayUrl($image- > url) ? > </ div >
< ?php endforeach; ? >

rabit-32bits

En savoir plus sur la génération d'images.

Variation d'image à l'aide de Dall · E

 $ response = ( new OpenAIClient ( $ apiKey ))-> Image ()-> createVariation (
        __DIR__ . ' /../../assets/image_variation_original.png ' ,
        n: 2 ,
        size: ImageSizeEnum::is256
    )-> toObject ();

variation-1

En savoir plus sur la variation de l'image.

Édition d'image à l'aide de Dall · E

 $ response = ( new OpenAIClient ( $ apiKey ))-> Image ()-> createEdit (
        image: __DIR__ . ' /../../assets/image_edit_original.png ' ,
        mask: __DIR__ . ' /../../assets/image_edit_mask2.png ' ,
        prompt: ' a sunlit indoor lounge area with a pool containing a flamingo ' ,
        size: ImageSizeEnum::is512,
    )-> toObject ();

IMG-Edit

En savoir plus sur l'image Edit.

Intégration

 $ response = ( new OpenAIClient ( $ apiKey ))-> Embedding ()-> create (
    ModelEnum:: TEXT_EMBEDDING_ADA_002 ,
    " The food was delicious and the waiter... " ,
)-> toObject ();

En savoir plus sur l'intégration.

Transcription audio (discours au texte) en utilisant un chuchotement

 $ response = ( new OpenAIClient ( $ apiKey ))-> Audio ()
    -> addCurlParam ( ' timeout ' , 30 )
    -> transcription (
        __DIR__ . ' /../../assets/openai.mp3 ' ,
        ModelEnum:: WHISPER_1 ,
        response_format: AudioResponseEnum:: SRT
    )-> toObject ();

En savoir plus sur la transcription audio.

Traduction audio (discours au texte) en utilisant Whisper

 $ response = ( new OpenAIClient ( $ apiKey ))-> Audio ()
    -> addCurlParam ( ' timeout ' , 30 )
    -> translation (
        __DIR__ . ' /../../assets/openai_fr.mp3 ' ,
        ' whisper-1 ' ,
        response_format: AudioResponseEnum:: TEXT
    )-> toObject ();

En savoir plus sur la traduction audio.

Liste de modèles

 $ response = ( new OpenAIClient ( $ apiKey ))
    -> Model ()
    -> list ()
    -> toObject ();

En savoir plus sur le modèle.

Modèle de récupération

 $ response = ( new OpenAIClient ( $ apiKey ))
    -> Model ()
    -> retrieve ( ' text-davinci-001 ' )
    -> toObject ();

En savoir plus sur le modèle.

Modèle de suppression

 $ response = ( new OpenAIClient ( $ apiKey ))
    -> Model ()
    -> delete (
        $ _POST [ ' model ' ]
    )-> toObject ();

En savoir plus sur le modèle.

Liste de fichiers

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> File ()
    -> list ()
    -> toObject ();

En savoir plus sur le fichier.

Téléchargement de fichiers

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> File ()
    -> create (
        __DIR__ . ' /../../assets/mydata.jsonl ' ,
        ' fine-tune ' ,
    )
    -> toObject ();

En savoir plus sur le fichier.

Supprimer le fichier

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> File ()
    -> delete ( ' file-xxxx ' )
    -> toObject ();

En savoir plus sur le fichier.

Récupération de fichiers

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> File ()
    -> retrieve ( ' file-xxxx ' )
    -> toObject ();

En savoir plus sur le modèle.

Fichier Récupérer le contenu

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> File ()
    -> download ( ' file-xxxx ' )
    -> toObject ();

En savoir plus sur le modèle.

Liste d'adaptation

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> FineTune ()
    -> list ()
    -> toObject ();

En savoir plus sur Fine-tune.

Affiner la création

 $ response = ( new OpenAIApi ( $ apiKey ))
        -> FineTune ()
        -> create (
            ' file-xxxx '
        )
        -> toObject ();

En savoir plus sur Fine-tune.

Récupérer

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> FineTune ()
    -> retrieve ( ' ft-xxx ' )
    -> toObject ();

En savoir plus sur Fine-tune.

Événements de liste affinés

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> FineTune ()
    -> listEvents ( ' ft-xxx ' )
    -> toObject ();

En savoir plus sur Fine-tune.

Annuler d'adaptation

 $ response = ( new OpenAIApi ( $ apiKey ))
    -> FineTune ()
    -> Cancel ( ' ft-xxx ' )
    -> toObject ();

En savoir plus sur Fine-tune.

Modération

 $ response = ( new OpenAIClient ( $ apiKey ))
    -> Moderation ()
    -> create ( ' I want to kill them. ' )
    -> toObject ();

En savoir plus sur la modération.

Essai

Pour exécuter tous les tests:

composer test tests

Pour exécuter un seul test:

composer test tests/[NAME]Test.php

Résumé

Phpopenai est un projet utile pour les développeurs PHP qui souhaitent intégrer facilement l'API OpenAI dans leurs projets. Avec une installation simple et l'utilisation du compositeur, la classification du texte, la génération d'images et la reconnaissance de l'entité nommée dans votre application PHP.

Développer