Instructivo de clasificación de contenido

Público

Este instructivo está diseñado para permitirte comenzar a explorar y desarrollar aplicaciones rápidamente con la API de Cloud Natural Language. Se ha diseñado para personas familiarizadas con la programación básica, aunque incluso sin muchos conocimientos de programación deberías poder entenderlo. 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 la API de Natural Language con el código de Python. El propósito de este instructivo no es explicar las bibliotecas cliente de Python, sino cómo hacer llamadas a la API de Natural Language. Las aplicaciones en Java y Node.js son similares en esencia. Consulta las Muestras de la API de Natural Language para buscar muestras en otros idiomas (incluida la muestra de este instructivo).

Requisitos previos

Este instructivo tiene varios requisitos previos:

Descripción general

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

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.

Este instructivo 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.

Importar bibliotecas

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

Para calcular la similitud entre textos según la clasificación del contenido resultante, este instructivo 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

Puedes usar la biblioteca cliente de Python para realizar una solicitud a la API de Natural Language para clasificar contenido. La biblioteca cliente de Python encapsula los detalles para las solicitudes y respuestas de la API de Natural Language.

La función classify en el instructivo llama al método classifyText de la API de Natural Language mediante la creación, primero, de una instancia de la clase LanguageServiceClient, y luego realiza un llamado 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 pasando el HTML fuente de la página como text y configurando 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 la API de Natural Language, consulta la Referencia de la API 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 mostrado es un diccionario con las etiquetas de categoría como claves y las puntuaciones de confianza como valores, como:

{
    "/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. Indexar varios archivos de texto

La función index en la secuencia de comandos del instructivo toma como entrada un directorio que contiene varios archivos de texto y la ruta a un archivo donde almacena el resultado indexado (el nombre predeterminado del archivo es index.json). La función index lee el contenido de cada archivo de texto en el directorio de entrada y luego pasa los archivos de texto a la API de Cloud Natural Language para que los clasifique 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 escribe 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 desde la línea de comandos con el nombre de archivo de salida predeterminado 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 (nombre de archivo predeterminado = 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 la consulta, la cual el instructivo 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 desde 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 la función query_category, con el paso extra de crear una solicitud classifyText para la entrada de texto, y utilizar 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:

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.

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

API de Cloud Natural Language
Si necesitas ayuda, visita nuestra página de asistencia.