Tutorial sulla classificazione dei contenuti

Pubblico

Questo tutorial è progettato per consentirti di iniziare a esplorare e sviluppare rapidamente le applicazioni con l'API Cloud Natural Language. È progettata per le persone che hanno familiarità con la programmazione di base, anche se non hanno una conoscenza approfondita della programmazione. Dopo aver seguito questo tutorial, dovresti essere in grado di utilizzare la documentazione di riferimento per creare le tue applicazioni di base.

Questo tutorial illustra un'applicazione Natural Language utilizzando il codice Python. Lo scopo non è spiegare le librerie client per Python, ma spiegare come effettuare chiamate all'API Natural Language. Le applicazioni in Java e Node.js sono essenzialmente simili. Consulta l'API Natural Language Esempi per esempi in altre lingue (incluso l'esempio in questo tutorial).

Prerequisiti

Questo tutorial prevede diversi prerequisiti:

Panoramica

Questo tutorial illustra un'applicazione di Natural Language di base, utilizzando le richieste classifyText, che classifica i contenuti in categorie insieme a un punteggio di affidabilità, ad esempio:

category: "/Internet & Telecom/Mobile & Wireless/Mobile Apps & Add-Ons"
confidence: 0.6499999761581421

Per visualizzare l'elenco di tutte le etichette di categoria disponibili, vedi Categorie.

In questo tutorial, creerai un'applicazione per eseguire le seguenti attività:

  • Classifica più file di testo e scrivi il risultato in un file di indice.
  • Elabora il testo della query di input per trovare file di testo simili.
  • Elabora le etichette delle categorie di query di input per trovare file di testo simili.

Il tutorial utilizza i contenuti di Wikipedia. Potresti creare un'applicazione simile per elaborare articoli di notizie, commenti online e così via.

File di origine

Puoi trovare il codice sorgente del tutorial negli esempi di libreria client Python su GitHub.

Questo tutorial utilizza esempi di testo di origine di Wikipedia. Puoi trovare i file di testo di esempio nella cartella resources/texts del progetto GitHub.

Importazione delle librerie in corso...

Per utilizzare l'API Cloud Natural Language, devi importare il modulo language dalla libreria google-cloud-language. Il modulo language.types contiene le classi necessarie per creare richieste. Il modulo language.enums viene utilizzato per specificare il tipo di testo di input. Questo tutorial classifica i contenuti in testo normale (language.enums.Document.Type.PLAIN_TEXT).

Per calcolare la somiglianza tra i testi in base alla classificazione dei contenuti che ne derivano, questo tutorial utilizza numpy per i calcoli vettoriali.

Python

import argparse
import io
import json
import os

from google.cloud import language_v1
import numpy
import six

Passaggio 1: Classificazione dei contenuti

Puoi utilizzare la libreria client Python per effettuare una richiesta all'API Natural Language per classificare il contenuto. La libreria client Python incapsula i dettagli per le richieste e le risposte dall'API Natural Language.

La funzione classify nel tutorial chiama il metodo API Natural Language classifyText, prima creando un'istanza della classe LanguageServiceClient e poi chiamando il metodo classify_text dell'istanza LanguageServiceClient.

La funzione tutorial classify classifica solo i contenuti di testo per questo esempio. Puoi anche classificare i contenuti di una pagina web passando nell'HTML di origine della pagina web come text e impostando il parametro type su language.enums.Document.Type.HTML.

Per ulteriori informazioni, consulta la sezione Classificare i contenuti. Per maggiori dettagli sulla struttura delle richieste all'API Natural Language, consulta la pagina di riferimento con il linguaggio naturale.

Python

def classify(text, verbose=True):
    """Classify the input text into categories."""

    language_client = language_v1.LanguageServiceClient()

    document = language_v1.Document(
        content=text, type_=language_v1.Document.Type.PLAIN_TEXT
    )
    response = language_client.classify_text(request={"document": document})
    categories = response.categories

    result = {}

    for category in categories:
        # Turn the categories into a dictionary of the form:
        # {category.name: category.confidence}, so that they can
        # be treated as a sparse vector.
        result[category.name] = category.confidence

    if verbose:
        print(text)
        for category in categories:
            print("=" * 20)
            print("{:<16}: {}".format("category", category.name))
            print("{:<16}: {}".format("confidence", category.confidence))

    return result

Il risultato restituito è un dizionario con le etichette delle categorie come chiavi e i punteggi di affidabilità come valori, ad esempio:

{
    "/Computers & Electronics": 0.800000011920929,
    "/Internet & Telecom/Mobile & Wireless/Mobile Apps & Add-Ons": 0.6499999761581421
}

Lo script Python del tutorial è organizzato in modo che possa essere eseguito dalla riga di comando per esperimenti rapidi. Ad esempio:

python classify_text_tutorial.py classify "Google Home enables users to speak voice commands to interact with services through the Home's intelligent personal assistant called Google Assistant. A large number of services, both in-house and third-party, are integrated, allowing users to listen to music, look at videos or photos, or receive news updates entirely by voice. "

Passaggio 2: Indicizzare più file di testo

La funzione index nello script del tutorial prende come input una directory contenente più file di testo e il percorso di un file in cui archivia l'output indicizzato (il nome predefinito del file è index.json). La funzione index legge il contenuto di ogni file di testo nella directory di input, quindi passa i file di testo all'API Cloud Natural Language per essere classificata in categorie di contenuti.

Python

def index(path, index_file):
    """Classify each text file in a directory and write
    the results to the index_file.
    """

    result = {}
    for filename in os.listdir(path):
        file_path = os.path.join(path, filename)

        if not os.path.isfile(file_path):
            continue

        try:
            with io.open(file_path, "r") as f:
                text = f.read()
                categories = classify(text, verbose=False)

                result[filename] = categories
        except Exception:
            print("Failed to process {}".format(file_path))

    with io.open(index_file, "w", encoding="utf-8") as f:
        f.write(json.dumps(result, ensure_ascii=False))

    print("Texts indexed in file: {}".format(index_file))
    return result

I risultati dell'API Cloud Natural Language per ogni file sono organizzati in un unico dizionario, serializzato come stringa JSON e quindi scritti in un file. Ad esempio:

{
    "android.txt": {
        "/Computers & Electronics": 0.800000011920929,
        "/Internet & Telecom/Mobile & Wireless/Mobile Apps & Add-Ons": 0.6499999761581421
    },
    "google.txt": {
        "/Internet & Telecom": 0.5799999833106995,
        "/Business & Industrial": 0.5400000214576721
    }
}

Per indicizzare i file di testo dalla riga di comando con il nome file di output predefinito index.json, esegui il comando seguente:

python classify_text_tutorial.py index resources/texts

Passaggio 3: Eseguire query sull'indice

Query con etichette di categoria

Una volta creato il file di indice (nome file predefinito = index.json), possiamo effettuare query nell'indice per recuperare alcuni dei nomi file e i relativi punteggi di affidabilità.

Un modo per farlo è utilizzare un'etichetta di categoria come query, che il tutorial pratica con la funzione query_category, L'implementazione delle funzioni helper, come similarity, è disponibile nel file classify_text_tutorial.py. Nelle tue applicazioni, il punteggio di somiglianza e il ranking dovrebbero essere progettati con attenzione in base a casi d'uso specifici.

Python

def query_category(index_file, category_string, n_top=3):
    """Find the indexed files that are the most similar to
    the query label.

    The list of all available labels:
    https://cloud.google.com/natural-language/docs/categories
    """

    with io.open(index_file, "r") as f:
        index = json.load(f)

    # Make the category_string into a dictionary so that it is
    # of the same format as what we get by calling classify.
    query_categories = {category_string: 1.0}

    similarities = []
    for filename, categories in six.iteritems(index):
        similarities.append((filename, similarity(query_categories, categories)))

    similarities = sorted(similarities, key=lambda p: p[1], reverse=True)

    print("=" * 20)
    print("Query: {}\n".format(category_string))
    print("\nMost similar {} indexed texts:".format(n_top))
    for filename, sim in similarities[:n_top]:
        print("\tFilename: {}".format(filename))
        print("\tSimilarity: {}".format(sim))
        print("\n")

    return similarities

Per un elenco di tutte le categorie disponibili, vedi Categorie.

Come prima, puoi chiamare la funzione query_category dalla riga di comando:

python classify_text_tutorial.py query-category index.json "/Internet & Telecom/Mobile & Wireless"

Dovresti vedere un output simile al seguente:

Query: /Internet & Telecom/Mobile & Wireless

Most similar 3 indexed texts:
  Filename: android.txt
  Similarity: 0.665573579045

  Filename: google.txt
  Similarity: 0.517527175966

  Filename: gcp.txt
  Similarity: 0.5

Query con testo

In alternativa, puoi eseguire query con testo che potrebbe non far parte del testo indicizzato. La funzione tutorial query è simile alla funzione query_category, con il passaggio aggiuntivo di creare una richiesta classifyText per l'input di testo e utilizzare i risultati per eseguire una query sul file Indice.

Python

def query(index_file, text, n_top=3):
    """Find the indexed files that are the most similar to
    the query text.
    """

    with io.open(index_file, "r") as f:
        index = json.load(f)

    # Get the categories of the query text.
    query_categories = classify(text, verbose=False)

    similarities = []
    for filename, categories in six.iteritems(index):
        similarities.append((filename, similarity(query_categories, categories)))

    similarities = sorted(similarities, key=lambda p: p[1], reverse=True)

    print("=" * 20)
    print("Query: {}\n".format(text))
    for category, confidence in six.iteritems(query_categories):
        print("\tCategory: {}, confidence: {}".format(category, confidence))
    print("\nMost similar {} indexed texts:".format(n_top))
    for filename, sim in similarities[:n_top]:
        print("\tFilename: {}".format(filename))
        print("\tSimilarity: {}".format(sim))
        print("\n")

    return similarities

Per farlo, dalla riga di comando esegui:

python classify_text_tutorial.py query index.json "Google Home enables users to speak voice commands to interact with services through the Home's intelligent personal assistant called Google Assistant. A large number of services, both in-house and third-party, are integrated, allowing users to listen to music, look at videos or photos, or receive news updates entirely by voice. "

Verrà stampato un testo simile al seguente:

Query: Google Home enables users to speak voice commands to interact with services through the Home's intelligent personal assistant called Google Assistant. A large number of services, both in-house and third-party, are integrated, allowing users to listen to music, look at videos or photos, or receive news updates entirely by voice.

  Category: /Internet & Telecom, confidence: 0.509999990463
  Category: /Computers & Electronics/Software, confidence: 0.550000011921

Most similar 3 indexed texts:
  Filename: android.txt
  Similarity: 0.600579500049

  Filename: google.txt
  Similarity: 0.401314790229

  Filename: gcp.txt
  Similarity: 0.38772339779

Passaggi successivi

L'API di classificazione dei contenuti consente di creare altre applicazioni. Ad esempio:

  • Classifica ogni paragrafo di un articolo per visualizzare la transizione tra gli argomenti.

  • Classifica i contenuti con timestamp e analizza la tendenza degli argomenti nel tempo.

  • Confronta le categorie di contenuti con il sentiment sui contenuti utilizzando il metodo analyzeSentiment.

  • Confronta le categorie di contenuti con le entità menzionate nel testo.

Inoltre, è possibile utilizzare altri prodotti GCP per semplificare il tuo flusso di lavoro:

  • Nell'applicazione di esempio per questo tutorial, abbiamo elaborato i file di testo locali, ma puoi modificare il codice per elaborare i file di testo archiviati in un bucket Google Cloud Storage, passando un URI di Google Cloud Storage al metodo classify_text.

  • Nell'applicazione di esempio per questo tutorial, abbiamo archiviato il file di indice localmente e ogni query viene elaborata leggendo l'intero file di indice. Questo comporta un'elevata latenza se hai una grande quantità di dati indicizzati o devi elaborare numerose query. Datastore è una scelta naturale e pratica per archiviare i dati dell'indice.