Utiliser le framework Gin pour implémenter des fonctions de traitement du langage naturel et de reconnaissance vocale

Avec le développement continu de la technologie de l'intelligence artificielle, la technologie de traitement du langage naturel et de reconnaissance vocale reçoit de plus en plus d'attention et d'applications. Aujourd'hui, dans cet article, nous allons présenter comment utiliser le framework Gin pour implémenter des fonctions de traitement du langage naturel et de reconnaissance vocale.

Gin est un framework web écrit en langage Go. Il offre des fonctionnalités faciles à utiliser, efficaces et flexibles. Le framework Gin peut facilement coopérer avec le routage, le middleware et d'autres fonctions. En raison de ses fonctionnalités faciles à apprendre et à démarrer rapidement, le framework Gin est largement utilisé dans des scénarios tels que la création d'applications Web et d'API RESTful. Ci-dessous, nous verrons comment utiliser le framework Gin pour créer des capacités de traitement du langage naturel et de reconnaissance vocale.

Tout d’abord, nous devons installer le langage Go nécessaire et les bibliothèques associées. Assurez-vous d'avoir installé le langage Go et les dépendances associées comme indiqué ci-dessous :

$ go version
$ go get -u github.com/gin-gonic/gin
$ go get -u google.golang.org/api/cloudspeech/v1
$ go get -u cloud.google.com/go/storage
$ go get -u github.com/tidwall/gjson

Avant de commencer, nous devons convertir la parole en texte, ce qui nécessite l'utilisation de l'API Google Cloud Speech. L'API Google Cloud Speech est basée sur la technologie de reconnaissance vocale de Google et peut convertir des flux audio ou des fichiers audio en texte. Étant donné que l'API Google Cloud Speech fait partie de Google Cloud Platform, nous devons utiliser un compte Google Cloud Platform pour accéder à l'API Speech.

Ensuite, nous devons créer un projet Gin et enregistrer l'itinéraire. Dans ce projet, nous devons créer une route de requête POST et une route de socket comme suit :

router.POST("/upload", uploadFile)
router.GET("/ws", func(c *gin.Context) {
    handleWebsocket(c.Writer, c.Request)
})

où la fonction uploadFile gère la requête POST et envoie le fichier audio téléchargé à l'API Google Cloud Speech pour les opérations de conversion de texte. La fonction handleWebsocket gérera l'opération de prise de contact WebSocket et recevra les données texte envoyées via WebSocket.

func uploadFile(c *gin.Context) {
    file, err := c.FormFile("audio")
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    client, err := speech.NewService(context.Background())
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    ctx := context.Background()
    ctx, cancel := context.WithTimeout(ctx, time.Minute*5)
    defer cancel()

    f, err := file.Open()
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    defer f.Close()
    res, err := client.Speech(ctx, speech.Config{
        Encoding:                   encoding,
        SampleRateHertz:            sampleRateHertz,
        LanguageCode:               languageCode,
    }, f)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    var transcript string
    for _, result := range res.Results {
        for _, alt := range result.Alternatives {
            transcript = alt.Transcript
            break
        }
    }
    c.JSON(http.StatusOK, gin.H{"transcript": transcript})
}

Dans la fonction uploadFile, nous récupérons d'abord le fichier audio téléchargé, puis le convertissons en texte à l'aide de l'API Google Cloud Speech. Après conversion, les données texte sont renvoyées au client au format JSON.

Nous pouvons maintenant commencer à traiter les données texte envoyées via WebSocket et les analyser à l'aide de techniques de traitement du langage naturel. Dans cet exemple, nous utiliserons l'API Google Natural Language pour analyser les données textuelles.

Tout d'abord, nous devons configurer le fichier de certification pour l'API Google Natural Language. Accédez à Google Cloud Console et créez-y un nouveau projet. Dans ce projet, vous devez activer l'API Google Natural Language et créer un compte de service. Une fois la création terminée, téléchargez le fichier d'authentification pour le compte de service. Créez un nouveau dossier de certification dans votre projet et placez-y vos fichiers de certification.

Nous pouvons maintenant définir une fonction pour gérer les données texte envoyées via WebSocket. Cette fonction utilisera la bibliothèque gjson pour obtenir le texte et appellera l'API Google Natural Language pour analyse. Une fois l'analyse terminée, nous imprimerons diverses informations sur le texte de la fonction. Enfin, nous renvoyons les résultats de l'analyse au client au format JSON.

func handleWebsocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
        if messageType == websocket.TextMessage {
            text := gjson.GetBytes(p, "text").String()
            client, err := language.NewClient(context.Background(), option.WithCredentialsFile("credentials.json"))
            if err != nil {
                log.Println(err)
                return
            }

            resp, err := client.AnnotateText(context.Background(), &languagepb.AnnotateTextRequest{
                Document: &languagepb.Document{
                    Type:   languagepb.Document_PLAIN_TEXT,
                    Source: &languagepb.Document_Content{Content: text},
                },
                Features: &languagepb.AnnotateTextRequest_Features{
                    ExtractSyntax:          true,
                    ExtractEntities:        true,
                    ExtractDocumentSentiment:    true,
                    ExtractEntitySentiment: true,
                },
            })
            if err != nil {
                log.Println(err)
                return
            }
            s, _ := json.MarshalIndent(resp, "", "    ")
            if err = conn.WriteMessage(websocket.TextMessage, []byte(s)); err != nil {
                log.Println(err)
                return
            }
        }
    }
}

Maintenant, nous avons terminé la mise en œuvre des fonctions de traitement du langage naturel et de reconnaissance vocale. En utilisant le framework Gin, nous pouvons créer rapidement un service Web capable d'interagir entre la synthèse vocale et l'analyse de texte. Parallèlement, nous utilisons également Google Cloud Speech et l'API Google Natural Language pour nous aider à mettre en œuvre ces fonctions. Tout cela est très pratique, efficace et simple, et le framework Gin prouve une fois de plus son importance dans le développement Web.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!