Instructivo de clasificación de contenido

Público

Este instructivo está diseñado para que comiences a explorar y desarrollar aplicaciones rápidamente con Cloud Natural Language. Está pensado para los usuarios familiarizados con la programación básica, aunque deberías poder entenderlo sin tener muchos conocimientos sobre programación. Una vez que completes este instructivo, debería poder usar la Documentación de referencia para crear tus propias aplicaciones básicas.

En este instructivo, se explica paso a paso cómo crear una aplicación con Natural Language mediante el código de Python. La finalidad no es explicar las bibliotecas cliente de Python, sino cómo hacer llamadas a Natural Language. En esencia, las aplicaciones en Java y Node.js son similares. Consulta las Aplicaciones de muestra de Natural Language para ver muestras en otros lenguajes (incluida la muestra de este instructivo).

Requisitos

Este instructivo tiene varios requisitos previos:

Resumen

En este instructivo, se explica una aplicación básica de Natural Language mediante solicitudes classifyText, la cual clasifica el contenido en categorías junto con una puntuación de confianza, como en el siguiente ejemplo:

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

Para ver la lista de etiquetas de categoría disponibles, consulta Categorías.

En este instructivo crearás una aplicación para realizar las siguientes tareas:

  • Clasificar varios archivos de texto y escribir los resultados en un archivo de índice
  • Procesar texto de consulta de entrada para buscar archivos de texto similares
  • Procesar etiquetas de categoría de consulta de entrada para encontrar archivos de texto similares

El instructivo utiliza contenido de Wikipedia. Puedes crear una aplicación similar para procesar artículos de noticias, comentarios en línea, etcétera.

Archivos fuente

Puedes encontrar el código fuente del instructivo en las Muestras de bibliotecas cliente de Python en GitHub.

En este instructivo, se utiliza texto fuente de muestra de Wikipedia. Puedes encontrar los archivos de texto de muestra en la carpeta recursos/textos en el proyecto de GitHub.

Importa bibliotecas

Para usar la API de Cloud Natural Language, debes importar el módulo language de la biblioteca google-cloud-language. El módulo language.types contiene clases que son necesarias para crear solicitudes. El módulo language.enums se usa para especificar el tipo de texto de entrada. En este instructivo, se clasifica contenido de texto sin formato (language.enums.Document.Type.PLAIN_TEXT).

Para calcular la similitud entre textos según la clasificación del contenido resultante, en este instructivo se usa numpy para realizar los cálculos de vectores.

Python

import argparse
import io
import json
import os

from google.cloud import language
import numpy
import six

Paso 1. Clasificar contenido

Puede usar la biblioteca cliente de Python para realizar una solicitud a Natural Language a fin de que clasifique el contenido. La biblioteca cliente de Python encapsula los detalles de las solicitudes a Natural Language y las respuestas que se obtienen de ella.

La función classify del instructivo llama al método classifyText de Natural Language, primero con la creación de una instancia de la clase LanguageServiceClient y, luego, mediante la llamada al método classify_text de la instancia LanguageServiceClient.

La función classify del instructivo solo clasifica contenido de texto para este ejemplo. También puedes clasificar el contenido de una página web si pasas el código HTML fuente de la página como text y configuras el parámetro type en language.enums.Document.Type.HTML.

Para obtener más información, consulta Clasificar contenido. Para obtener detalles sobre la estructura de las solicitudes realizadas a Natural Language, consulta la Referencia de Natural Language.

Python

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

    language_client = language.LanguageServiceClient()

    document = language.types.Document(
        content=text,
        type=language.enums.Document.Type.PLAIN_TEXT)
    response = language_client.classify_text(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(u'=' * 20)
            print(u'{:<16}: {}'.format('category', category.name))
            print(u'{:<16}: {}'.format('confidence', category.confidence))

    return result

El resultado que se muestra es un diccionario con las etiquetas de categoría como claves y las puntuaciones de confianza como valores, como se muestra a continuación:

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

La secuencia de comandos de Python del instructivo está organizada, de manera que pueda ejecutarse desde la línea de comandos para experimentos rápidos. Por ejemplo, puedes ejecutar:

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. "

Paso 2. Indexa varios archivos de texto

La función index de la secuencia de comandos del instructivo toma como entrada un directorio que contiene varios archivos de texto y la ruta a un archivo en el que almacena el resultado indexado (el nombre predeterminado de archivo es index.json). La función index lee el contenido de cada archivo de texto en el directorio de entrada y envía los archivos de texto a la API de Cloud Natural Language para que se clasifiquen en categorías de contenido.

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

Los resultados de la API de Cloud Natural Language para cada archivo se organizan en un solo diccionario, serializado como una string JSON, y luego se escriben en un archivo. Por ejemplo:

{
    "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
    }
}

Para indexar archivos de texto en la línea de comandos con el nombre predeterminado de archivo de salida index.json, ejecuta el siguiente comando:

python classify_text_tutorial.py index resources/texts

Paso 3. Consultar el índice

Consulta con etiquetas de categoría

Una vez creado el archivo de índice (el nombre de archivo predeterminado es index.json), podemos realizar consultas al índice para recuperar algunos de los nombres de archivo y sus puntuaciones de confianza.

Una manera de hacerlo es usar una etiqueta de categoría como consulta (el instructivo la obtiene mediante la función query_category). La implementación de las funciones auxiliares como similarity, se puede encontrar en el archivo classify_text_tutorial.py. En tus aplicaciones, la puntuación de similitud y la clasificación deben diseñarse cuidadosamente y para casos prácticos específicos.

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

Para obtener una lista de todas las categorías disponibles, consulta Categorías.

Como antes, puedes llamar a la función query_category con la línea de comandos:

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

Deberías ver un resultado similar al siguiente:

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

Consulta con texto

De manera alternativa, puedes realizar consultas con texto que no sea parte del texto indexado. La función query del instructivo es similar a query_category, pero agrega el paso de realizar una solicitud classifyText para la entrada de texto y usar los resultados para consultar el archivo de índice.

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

Para hacer esto desde la línea de comandos, ejecuta lo siguiente:

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. "

Esto imprime algo similar a lo siguiente:

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

Pasos siguientes

Puedes crear otras aplicaciones con la API de clasificación de contenido. Por ejemplo:

  • Clasificar cada párrafo en un artículo para ver la transición entre temas.

  • Clasificar el contenido con marca de tiempo y analizar la tendencia de los temas a lo largo del tiempo.

  • Comparar las categorías de contenido con las opiniones sobre el contenido con el método analyzeSentiment.

  • Comparar las categorías de contenido con las entidades mencionadas en el texto.

Además, puedes usar otros productos de GCP para optimizar tu flujo de trabajo:

  • En la aplicación de muestra para este instructivo, procesamos archivos de texto locales; no obstante, puedes modificar el código para procesar archivos de texto almacenados en un depósito de Google Cloud Storage pasando un URI de Google Cloud Storage al método classify_text.

  • En la aplicación de muestra para este instructivo, almacenamos el archivo de índice de manera local, y cada consulta se procesa mediante la lectura del archivo de índice completo. Esto significa una latencia alta si tienes una cantidad grande de datos indexados o si necesitas procesar varias consultas. Datastore es una opción natural y conveniente para almacenar datos de índices.