Gunakan rangka kerja Gin untuk melaksanakan analisis teks dan fungsi analisis sentimen

Dalam beberapa tahun kebelakangan ini, dengan populariti media sosial dan perkembangan Internet mudah alih, jumlah artikel dan komen yang dikongsi dan diterbitkan oleh orang di platform dalam talian telah meletupkan teks ini bukan sahaja merangkumi pelbagai topik, tetapi juga mengandungi kandungan yang kaya Warna emosi.

Adalah sangat penting bagi perniagaan dan individu untuk memahami sikap dan emosi orang ramai terhadap jenama, produk dan perkhidmatan mereka. Oleh itu, terdapat keperluan yang semakin meningkat untuk melaksanakan analisis teks dan keupayaan analisis sentimen. Dalam artikel ini, kami akan memperkenalkan cara menggunakan rangka kerja Gin untuk melaksanakan analisis teks dan fungsi analisis sentimen.

1. Pengenalan kepada rangka kerja Gin

Rangka kerja Gin ialah rangka kerja Web yang ditulis dalam bahasa Go Ia melaksanakan perkhidmatan API berprestasi tinggi dengan menggunakan penggunaan semula memori yang cekap. Gin direka bentuk berdasarkan idea rangka kerja Martini, tetapi ia mempunyai prestasi yang lebih baik dan API yang lebih baik serta boleh digunakan untuk membina aplikasi web bersaiz kecil dan sederhana Ia juga sangat sesuai untuk membina perkhidmatan API RESTful.

2. Pasang rangka kerja Gin

Sebelum bermula, kita perlu memasang rangka kerja Gin dan perpustakaan bergantung yang berkaitan. Sebelum pemasangan, anda perlu memasang persekitaran pembangunan Golang. Masukkan arahan berikut dalam terminal anda untuk memasang rangka kerja Gin:

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

Selain itu, kami juga perlu memasang dua perpustakaan bergantung berikut:

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

3. Laksanakan fungsi analisis teks

Sebelum melaksanakan analisis sentimen, kita perlu melaksanakan beberapa fungsi analisis teks asas.

1. Pembahagian Perkataan

Untuk sekeping teks, kita perlu memecahkannya kepada perkataan individu Proses ini dipanggil pembahagian perkataan. Dalam bahasa Go, kita boleh menggunakan perpustakaan pihak ketiga github.com/blevesearch/go-porterstemmer untuk melaksanakan fungsi ini. Berikut ialah contoh kod mudah:

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. Kira kekerapan perkataan

Selepas pembahagian perkataan, kita perlu mengira bilangan kali setiap perkataan muncul dalam teks Ini proses dipanggil statistik Kekerapan perkataan. Berikut ialah contoh kod mudah:

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
}

IV Melaksanakan fungsi analisis sentimen

Sebelum melaksanakan fungsi analisis sentimen, kita perlu mewujudkan perpustakaan perbendaharaan kata emosi untuk menyimpan perkataan yang berwarna-warni dan berat sentimen mereka. Di sini, kami menggunakan fail kamus sentimen AFINN-165.txt. Berikut ialah sebahagian daripada fail:

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

Kami boleh menggunakan kod berikut untuk membaca fail kamus sentimen dan menyimpannya ke dalam peta:

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
}

Selepas membaca fail kamus sentimen, Kami boleh gunakan kod berikut untuk mengira skor sentimen teks:

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
}

Kod di atas menggunakan perpustakaan pihak ketiga github.com/cdipaolo/sentiment untuk melaksanakan analisis sentimen. Pustaka ini ialah pelaksanaan bahasa Go bagi perpustakaan Python berasaskan NLTK VADER, yang boleh mengira secara langsung skor sentimen teks.

5. Membina perkhidmatan API

Kami telah berjaya melaksanakan fungsi analisis teks dan analisis sentimen. Sekarang, kita perlu menyepadukan fungsi ini ke dalam perkhidmatan API RESTful.

Berikut ialah struktur direktori kami:

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

Fail config/config.yaml digunakan untuk menyimpan maklumat konfigurasi, seperti laluan fail pustaka perbendaharaan kata emosi. Berikut ialah contoh fail konfigurasi:

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

fail penganalisis/analyzer.go ialah program analisis utama kami. Ia mengandungi semua fungsi untuk pembahagian perkataan dan pengiraan sentimen. Fail handler/handler.go mengandungi pengendali API kami. Akhir sekali, kami mentakrifkan struktur Sentimen dalam fail model/sentiment.go sebagai jenis pulangan respons API.

Berikut ialah kod utama:

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

Sekarang, kami telah melengkapkan perkhidmatan API kami. Kita boleh menggunakan perintah curl atau posmen untuk mengujinya.

Berikut ialah contoh perintah curl:

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

API ini akan mengembalikan objek JSON:

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

Dalam objek JSON ini, skor ialah skor sentimen. Nilainya berjulat dari -1 hingga 1, di mana -1 adalah negatif sepenuhnya, 0 adalah neutral, dan 1 adalah positif sepenuhnya.

7. Kesimpulan

Dalam artikel ini, kami memperkenalkan cara menggunakan rangka kerja Gin untuk membina perkhidmatan API untuk analisis teks dan analisis sentimen. Kami membangunkan penganalisis sentimen menggunakan bahasa Go, yang boleh membaca perbendaharaan kata sentimen dan mengira skor sentimen teks. Kami juga menunjukkan cara membina penganalisis sentimen ini menjadi perkhidmatan API RESTful menggunakan rangka kerja Gin.

Perlu dinyatakan bahawa walaupun kami menggunakan kamus sentimen AFINN-165.txt dalam artikel ini, ini bukan satu-satunya pilihan. Dalam dunia nyata, terdapat berbilang kamus sentimen untuk dipilih, setiap satunya mempunyai kelebihan dan kekurangannya. Oleh itu, dalam aplikasi praktikal, kita perlu memilih kamus sentimen yang paling sesuai dengan keperluan kita.

Secara amnya, perkhidmatan API analisis teks dan analisis sentimen yang dibina pada rangka kerja Gin adalah sangat berkesan dan praktikal serta boleh membantu kami memahami dengan lebih baik sikap dan emosi orang ramai terhadap jenama, produk dan perkhidmatan kami.

Atas ialah kandungan terperinci Gunakan rangka kerja Gin untuk melaksanakan analisis teks dan fungsi analisis sentimen. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!