Utilisez le framework Gin pour implémenter des fonctions d'analyse de texte et d'analyse des sentiments

Ces dernières années, avec la popularité des médias sociaux et le développement de l'Internet mobile, le nombre d'articles et de commentaires partagés et publiés par les personnes sur les plateformes en ligne a explosé. Ces textes couvrent non seulement des sujets variés, mais contiennent également de riches couleurs émotionnelles. .

Il est très important pour les entreprises et les particuliers de comprendre les attitudes et les émotions du public envers leurs marques, produits et services. Par conséquent, il existe un besoin croissant de mettre en œuvre des capacités d’analyse de texte et d’analyse des sentiments. Dans cet article, nous présenterons comment utiliser le framework Gin pour implémenter des fonctions d'analyse de texte et d'analyse des sentiments.

1. Introduction au framework Gin

Le framework Gin est un framework Web écrit en langage Go. Il implémente des services API hautes performances en utilisant une réutilisation efficace de la mémoire. Gin est conçu sur la base des idées du framework Martini, mais il offre de meilleures performances et de meilleures API et peut être utilisé pour créer des applications Web de petite et moyenne taille. Il est également très approprié pour créer des services API RESTful.

2. Installez le framework Gin

Avant de commencer, nous devons installer le framework Gin et les bibliothèques dépendantes associées. Avant l'installation, vous devez installer l'environnement de développement Golang. Entrez la commande suivante dans votre terminal pour installer le framework Gin :

go get -u github.com/gin-gonic/gin

De plus, nous devons également installer les deux bibliothèques dépendantes suivantes :

go get -u gopkg.in/yaml.v2
go get -u github.com/cdipaolo/sentiment

3. Implémenter la fonction d'analyse de texte

Avant d'implémenter l'analyse des sentiments, nous devons implémenter certaines choses d'abord Capacités d'analyse de texte de base.

1. Segmentation de mots

Pour un morceau de texte, nous devons le décomposer en mots individuels. Ce processus est appelé segmentation de mots. Dans le langage Go, nous pouvons utiliser la bibliothèque tierce github.com/blevesearch/go-porterstemmer pour implémenter cette fonction. Voici un exemple de code simple :

import (
    "github.com/blevesearch/go-porterstemmer"
    "strings"
)

func Tokenize(text string) []string {
    // Remove unnecessary characters
    text = strings.ReplaceAll(text, ".", "")
    text = strings.ReplaceAll(text, ",", "")
    text = strings.ReplaceAll(text, "!", "")
    text = strings.ReplaceAll(text, "?", "")
    text = strings.ToLower(text)

    // Split text into words
    words := strings.Fields(text)

    // Stem words using Porter Stemmer algorithm
    for i, w := range words {
        words[i] = porterstemmer.Stem(w)
    }

    return words
}

2. Comptage de la fréquence des mots

Après la segmentation des mots, nous devons compter le nombre de fois que chaque mot apparaît dans le texte. Ce processus est appelé comptage de la fréquence des mots. Voici un exemple de code simple :

func CalculateTermFrequency(words []string) map[string]int {
    frequency := make(map[string]int)

    for _, w := range words {
        _, exists := frequency[w]
        if exists {
            frequency[w]++
        } else {
            frequency[w] = 1
        }
    }

    return frequency
}

4. Implémentez la fonction d'analyse des sentiments

Avant d'implémenter la fonction d'analyse des sentiments, nous devons établir un lexique émotionnel pour stocker les mots colorés émotionnellement et leurs poids émotionnels. Ici, nous utilisons le fichier de dictionnaire de sentiments AFINN-165.txt. Ce qui suit fait partie du fichier :

abandons    -2
abducted    -2
abduction    -2
abductions    -2
abhor    -3
abhorred    -3
abhorrent    -3
abhorring    -3
abhors    -3
abilities    2
...

Nous pouvons utiliser le code suivant pour lire le fichier du dictionnaire de sentiments et le stocker dans une carte :

import (
    "bufio"
    "os"
    "strconv"
    "strings"
)

func LoadSentimentWords(filename string) (map[string]int, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close()

    sentiments := make(map[string]int)

    scanner := bufio.NewScanner(f)
    for scanner.Scan() {
        splitted := strings.Split(scanner.Text(), "    ")
        word := splitted[0]
        value, err := strconv.Atoi(splitted[1])
        if err != nil {
            continue
        }
        sentiments[word] = value
    }

    return sentiments, nil
}

Après avoir lu le fichier du dictionnaire de sentiments, nous pouvons utiliser le code suivant pour calculer le score de sentiment d'un texte :

import (
    "github.com/cdipaolo/sentiment"
    "github.com/ryangxx/go-sentiment-analysis/text"
)

func CalculateSentimentScore(text string, sentiments map[string]int) (float64, error) {
    words := text.Tokenize(text)
    wordCount := len(words)

    score := 0
    for _, w := range words {
        value, exists := sentiments[w]
        if exists {
            score += value
        }
    }

    return float64(score) / float64(wordCount), nil
}

Le code ci-dessus utilise la bibliothèque tierce github.com/cdipaolo/sentiment pour effectuer une analyse des sentiments. Cette bibliothèque est une implémentation en langage Go de la bibliothèque Python VADER basée sur NLTK, qui peut calculer directement le score de sentiment d'un texte.

5. Créer un service API

Nous avons implémenté avec succès les fonctions d'analyse de texte et d'analyse des sentiments. Nous devons maintenant intégrer ces fonctions dans un service API RESTful.

Voici notre structure de répertoires :

- main.go
- config/
  - config.yaml
- internal/
  - analyzer/
    - analyzer.go
  - handler/
    - handler.go
  - model/
    - sentiment.go

Le fichier config/config.yaml est utilisé pour stocker les informations de configuration, telles que le chemin du fichier de la bibliothèque de vocabulaire des sentiments. Voici un exemple de fichier de configuration : le fichier

analyzer:
  sentimentFile: "data/AFINN-165.txt"
  tokenizing:
    remove:
      - "."
      - ","
      - "!"
      - "?"
    toLowercase: true

analyzer/analyzer.go est notre programme d'analyse principal. Il contient toutes les fonctions de segmentation de mots et de calcul de sentiments. Le fichier handler/handler.go contient notre gestionnaire API. Enfin, nous avons défini une structure Sentiment dans le fichier model/sentiment.go comme type de retour de la réponse API.

Voici le code principal :

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/ryangxx/go-sentiment-analysis/analyzer"
    "github.com/ryangxx/go-sentiment-analysis/handler"
)

func main() {
    router := gin.Default()

    sentimentAnalyzer := analyzer.NewSentimentAnalyzer()
    sentimentHandler := handler.NewSentimentHandler(sentimentAnalyzer)

    router.GET("/analysis", sentimentHandler.GetSentimentAnalysis)

    router.Run(":8080")
}

6. Tests API

Maintenant, nous avons terminé notre service API. Nous pouvons utiliser la commande curl ou postman pour le tester.

Ce qui suit est un exemple de commande curl :

curl --location --request GET 'http://localhost:8080/analysis?text=I%20love%20Golang'

Cette API renverra un objet JSON :

{
    "message": "OK",
    "sentiment": {
        "score": 0.6
    }
}

Dans cet objet JSON, le score est le score de sentiment. Sa valeur varie de -1 à 1, où -1 est complètement négatif, 0 est neutre et 1 est complètement positif.

7. Conclusion

Dans cet article, nous avons présenté comment utiliser le framework Gin pour créer des services API pour l'analyse de texte et l'analyse des sentiments. Nous avons développé un analyseur de sentiments utilisant le langage Go, capable de lire un vocabulaire de sentiments et de calculer le score de sentiment d'un texte. Nous montrons également comment intégrer cet analyseur de sentiments dans un service API RESTful à l'aide du framework Gin.

Il convient de souligner que même si nous utilisons le dictionnaire de sentiments AFINN-165.txt dans cet article, ce n'est pas la seule option. Dans le monde réel, il existe plusieurs dictionnaires de sentiments parmi lesquels choisir, chacun ayant ses avantages et ses inconvénients. Par conséquent, dans les applications pratiques, nous devons choisir le dictionnaire de sentiments qui correspond le mieux à nos besoins.

En général, les services API d'analyse de texte et d'analyse des sentiments construits sur le framework Gin sont très efficaces et pratiques et peuvent nous aider à mieux comprendre les attitudes et les émotions du public envers nos marques, produits et services.

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!