Verwenden Sie das Gin-Framework, um Textanalyse- und Stimmungsanalysefunktionen zu implementieren

Mit der Popularität der sozialen Medien und der Entwicklung des mobilen Internets ist die Zahl der von Menschen auf Online-Plattformen geteilten und veröffentlichten Artikel und Kommentare explodiert. Diese Texte decken nicht nur verschiedene Themen ab, sondern enthalten auch reiche emotionale Farben. .

Für Unternehmen und Einzelpersonen ist es sehr wichtig, die Einstellungen und Emotionen der Öffentlichkeit gegenüber ihren Marken, Produkten und Dienstleistungen zu verstehen. Daher besteht ein zunehmender Bedarf an der Implementierung von Textanalyse- und Stimmungsanalysefunktionen. In diesem Artikel stellen wir vor, wie Sie das Gin-Framework zum Implementieren von Textanalyse- und Stimmungsanalysefunktionen verwenden.

1. Einführung in das Gin-Framework

Gin-Framework ist ein in der Go-Sprache geschriebenes Web-Framework. Es implementiert leistungsstarke API-Dienste durch effiziente Speicherwiederverwendung. Gin basiert auf den Ideen des Martini-Frameworks, verfügt jedoch über eine bessere Leistung und bessere APIs und kann zum Erstellen kleiner und mittlerer Webanwendungen verwendet werden. Es eignet sich auch sehr gut zum Erstellen von RESTful-API-Diensten.

2. Installieren Sie das Gin-Framework

Bevor wir beginnen, müssen wir das Gin-Framework und die zugehörigen abhängigen Bibliotheken installieren. Vor der Installation müssen Sie die Golang-Entwicklungsumgebung installieren. Geben Sie den folgenden Befehl in Ihr Terminal ein, um das Gin-Framework zu installieren:

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

Darüber hinaus müssen wir auch die folgenden zwei abhängigen Bibliotheken installieren:

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

3. Textanalysefunktion implementieren

Bevor wir die Stimmungsanalyse implementieren, müssen wir sie implementieren Einige Dinge zuerst Grundlegende Textanalysefunktionen.

1. Wortsegmentierung

Für einen Text müssen wir ihn in einzelne Wörter zerlegen. Dieser Vorgang wird als Wortsegmentierung bezeichnet. In der Go-Sprache können wir die Drittanbieterbibliothek github.com/blevesearch/go-porterstemmer verwenden, um diese Funktion zu implementieren. Das Folgende ist ein einfaches Codebeispiel:

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. Worthäufigkeit zählen

Nach der Wortsegmentierung müssen wir zählen, wie oft jedes Wort im Text vorkommt. Dieser Vorgang wird als Worthäufigkeit zählen bezeichnet. Das Folgende ist ein einfaches Codebeispiel:

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. Implementieren Sie die Stimmungsanalysefunktion

Bevor wir die Stimmungsanalysefunktion implementieren, müssen wir ein emotionales Lexikon erstellen, um emotional gefärbte Wörter und ihre emotionalen Gewichte zu speichern. Hier verwenden wir die Sentiment-Wörterbuchdatei AFINN-165.txt. Folgendes ist Teil der Datei:

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

Wir können den folgenden Code verwenden, um die Sentiment-Wörterbuchdatei zu lesen und in einer Karte zu speichern:

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
}

Nach dem Lesen der Sentiment-Wörterbuchdatei können wir den folgenden Code verwenden, um den Sentiment-Score zu berechnen eines Textes:

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
}

Der obige Code verwendet die Drittanbieterbibliothek github.com/cdipaolo/sentiment, um eine Stimmungsanalyse durchzuführen. Diese Bibliothek ist eine Go-Sprachimplementierung der NLTK-basierten Python-Bibliothek VADER, die den Sentiment-Score eines Textes direkt berechnen kann.

5. API-Dienst erstellen

Wir haben erfolgreich Textanalyse- und Stimmungsanalysefunktionen implementiert. Jetzt müssen wir diese Funktionen in einen RESTful-API-Dienst integrieren.

Das Folgende ist unsere Verzeichnisstruktur:

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

Die Datei config/config.yaml wird zum Speichern von Konfigurationsinformationen verwendet, z. B. dem Dateipfad der Sentiment-Vokabularbibliothek. Hier ist eine Beispielkonfigurationsdatei: Die Datei

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

analyzer/analyzer.go ist unser Hauptanalyseprogramm. Es enthält alle Funktionen zur Wortsegmentierung und Stimmungsberechnung. Die Datei handler/handler.go enthält unseren API-Handler. Schließlich haben wir in der Datei model/sentiment.go eine Sentiment-Struktur als Rückgabetyp der API-Antwort definiert.

Das Folgende ist der Hauptcode:

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. API-Tests

Jetzt haben wir unseren API-Service abgeschlossen. Wir können es mit dem Curl-Befehl oder Postman testen.

Das Folgende ist ein Beispiel für einen Curl-Befehl:

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

Diese API gibt ein JSON-Objekt zurück:

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

In diesem JSON-Objekt ist „Score“ der Sentiment-Score. Sein Wert reicht von -1 bis 1, wobei -1 vollständig negativ, 0 neutral und 1 vollständig positiv ist.

7. Fazit

In diesem Artikel haben wir vorgestellt, wie man das Gin-Framework zum Erstellen von API-Diensten für die Textanalyse und Stimmungsanalyse verwendet. Wir haben einen Sentiment-Analysator mithilfe der Go-Sprache entwickelt, der ein Sentiment-Vokabular lesen und den Sentiment-Score eines Textes berechnen kann. Wir zeigen auch, wie Sie diesen Stimmungsanalysator mithilfe des Gin-Frameworks in einen RESTful-API-Dienst integrieren.

Es ist erwähnenswert, dass wir in diesem Artikel zwar das Stimmungswörterbuch AFINN-165.txt verwenden, dies jedoch nicht die einzige Option ist. In der realen Welt stehen mehrere Stimmungswörterbücher zur Auswahl, von denen jedes seine Vor- und Nachteile hat. Daher müssen wir in praktischen Anwendungen das Stimmungswörterbuch auswählen, das unseren Anforderungen am besten entspricht.

Im Allgemeinen sind die auf dem Gin-Framework basierenden Textanalyse- und Stimmungsanalyse-API-Dienste sehr effektiv und praktisch und können uns helfen, die Einstellungen und Emotionen der Öffentlichkeit gegenüber unseren Marken, Produkten und Dienstleistungen besser zu verstehen.

Das obige ist der detaillierte Inhalt vonVerwenden Sie das Gin-Framework, um Textanalyse- und Stimmungsanalysefunktionen zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!