Gunakan rangka kerja Gin untuk melaksanakan pemprosesan bahasa semula jadi dan fungsi pengecaman pertuturan

Dengan pembangunan berterusan teknologi kecerdasan buatan, pemprosesan bahasa semula jadi dan teknologi pengecaman pertuturan semakin mendapat perhatian dan aplikasi. Hari ini, dalam artikel ini, kami akan memperkenalkan cara menggunakan rangka kerja Gin untuk melaksanakan pemprosesan bahasa semula jadi dan fungsi pengecaman pertuturan.

Gin ialah rangka kerja web yang ditulis dalam bahasa Go. Ia menyediakan ciri yang mudah digunakan, cekap dan fleksibel. Rangka kerja Gin boleh bekerjasama dengan mudah dengan penghalaan, perisian tengah dan fungsi lain. Oleh kerana cirinya yang mudah dipelajari dan cepat dimulakan, rangka kerja Gin digunakan secara meluas dalam senario seperti membina aplikasi web dan API RESTful. Di bawah, kita akan melihat cara menggunakan rangka kerja Gin untuk membina pemprosesan bahasa semula jadi dan keupayaan pengecaman pertuturan.

Pertama, kita perlu memasang bahasa Go yang diperlukan dan perpustakaan berkaitan. Pastikan anda memasang bahasa Go dan kebergantungan yang berkaitan, seperti yang ditunjukkan di bawah:

$ 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

Sebelum kita bermula, kita perlu menukar pertuturan kepada teks, yang memerlukan penggunaan API Google Cloud Speech. API Pertuturan Awan Google dibina pada teknologi pengecaman pertuturan Google dan boleh menukar strim audio atau fail audio kepada teks. Memandangkan API Google Cloud Speech adalah sebahagian daripada Google Cloud Platform, kami perlu menggunakan akaun Google Cloud Platform untuk mengakses Speech API.

Seterusnya, kita perlu membuat projek Gin dan mendaftarkan laluan. Dalam projek ini, kita perlu mencipta laluan permintaan POST dan laluan soket seperti berikut:

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

di mana fungsi muat naikFail mengendalikan permintaan POST dan menghantar fail audio yang dimuat naik ke API Pertuturan Awan Google untuk memproses penukaran Teks operasi. Fungsi handleWebsocket akan mengendalikan operasi jabat tangan WebSocket dan menerima data teks yang dihantar melalui 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})
}

Dalam fungsi muat naikFail, kami mula-mula mendapatkan fail audio yang dimuat naik dan kemudian menukarnya kepada teks menggunakan API Google Cloud Speech. Selepas penukaran, data teks dikembalikan kepada klien dalam format JSON.

Kini kita boleh mula memproses data teks yang dihantar melalui WebSocket dan menganalisisnya menggunakan teknik pemprosesan bahasa semula jadi. Dalam contoh ini, kami akan menggunakan API Google Natural Language untuk menganalisis data teks.

Pertama, kami perlu menyediakan fail pengesahan untuk API Bahasa Semulajadi Google. Pergi ke Google Cloud Console dan buat projek baharu di sana. Dalam projek ini, anda perlu mendayakan Google Natural Language API dan membuat akaun perkhidmatan. Selepas penciptaan selesai, muat turun fail pengesahan untuk akaun perkhidmatan. Buat folder pensijilan baharu dalam projek anda dan letakkan fail pensijilan anda di dalamnya.

Kini kita boleh menentukan fungsi untuk mengendalikan data teks yang dihantar melalui WebSocket. Fungsi ini akan menggunakan perpustakaan gjson untuk mendapatkan teks dan memanggil API Bahasa Asli Google untuk analisis. Selepas analisis selesai, kami akan mencetak pelbagai maklumat tentang teks daripada fungsi tersebut. Akhir sekali, kami menghantar kembali hasil analisis kepada klien dalam 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
            }
        }
    }
}

Kini, kami telah menyelesaikan pelaksanaan pemprosesan bahasa semula jadi dan fungsi pengecaman pertuturan. Dengan menggunakan rangka kerja Gin, kami boleh mencipta perkhidmatan web dengan cepat yang boleh berinteraksi antara analisis pertuturan-ke-teks dan teks. Pada masa yang sama, kami juga menggunakan Google Cloud Speech dan Google Natural Language API untuk membantu kami melaksanakan fungsi ini. Semuanya sangat mudah, cekap dan ringkas, dan rangka kerja Gin sekali lagi membuktikan kepentingannya dalam pembangunan web.

Atas ialah kandungan terperinci Gunakan rangka kerja Gin untuk melaksanakan pemprosesan bahasa semula jadi dan fungsi pengecaman pertuturan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!