Tutorial de clasificación de contenido

Audiencia

Este tutorial se ha diseñado para que puedas empezar a explorar y desarrollar aplicaciones rápidamente con la API Cloud Natural Language. Está diseñado para personas que tengan conocimientos básicos de programación, aunque también podrás seguirlo si no tienes mucha experiencia en este campo. Después de haber seguido este tutorial, podrás utilizar la documentación de referencia para crear tus propias aplicaciones básicas.

En este tutorial se explica cómo usar una aplicación de Natural Language con código Python. El objetivo no es explicar las bibliotecas de cliente de Python, sino cómo hacer llamadas a la API Natural Language. Las aplicaciones en Java y Node.js son esencialmente similares. Consulta los ejemplos de la API Natural Language para ver muestras en otros idiomas (incluida la muestra de este tutorial).

Requisitos previos

Este tutorial tiene varios requisitos previos:

• Has configurado un proyecto de Cloud Natural Language en la Google Cloud consola Google Cloud .
• Has configurado tu entorno con credenciales predeterminadas de la aplicación en la consola. Google Cloud
• Tienes experiencia con Python en la programación de la consola Google Cloud .
• Has configurado tu entorno de desarrollo de Python. Te recomendamos que tengas instaladas en tu sistema las versiones más recientes de Python, pip y virtualenv. Para obtener instrucciones, consulta la guía de configuración del entorno de desarrollo de Python para Google Cloud Platform.
• Has instalado la biblioteca de cliente de Google Cloud para Python.

Información general

En este tutorial se explica cómo usar una aplicación básica de Natural Language mediante solicitudes classifyText, que clasifica el contenido en categorías junto con una puntuación de confianza, como las siguientes:

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

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

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

• Clasifica varios archivos de texto y escribe el resultado en un archivo de índice.
• Procesa el texto de la consulta de entrada para encontrar archivos de texto similares.
• Procesa las etiquetas de categoría de la consulta de entrada para encontrar archivos de texto similares.

En este tutorial se usa contenido de Wikipedia. Podrías crear una aplicación similar para procesar artículos de noticias, comentarios online, etc.

Archivos de origen

Puedes encontrar el código fuente del tutorial en los ejemplos de la biblioteca de cliente de Python de GitHub.

En este tutorial se usa texto de origen de ejemplo de Wikipedia. Puedes encontrar los archivos de texto de ejemplo en la carpeta resources/texts del proyecto de GitHub.

Importar bibliotecas

Para usar la API Cloud Natural Language, debes importar el módulo language de 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. En este tutorial se clasifica contenido de texto sin formato (language.enums.Document.Type.PLAIN_TEXT).

Para calcular la similitud entre textos en función de la clasificación de contenido resultante, en este tutorial se usa numpy para los cálculos vectoriales.

import argparse
import json
import os

from google.cloud import language_v1
import numpy

Paso 1. Clasificar contenido

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

La función classify del tutorial llama al método classifyText de la API Natural Language. Para ello, primero crea una instancia de la clase LanguageServiceClient y, después, llama al método classify_text de la instancia LanguageServiceClient.

La función classify del tutorial solo clasifica el contenido de texto de este ejemplo. También puede clasificar el contenido de una página web si envía el código HTML de origen de la página web como text y define el parámetro type como language.enums.Document.Type.HTML.

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

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

El resultado devuelto 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 tutorial está organizada de forma que se pueda ejecutar desde la línea de comandos para hacer experimentos rápidos. Por ejemplo, puedes ejecutar lo siguiente:

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 de la secuencia de comandos del tutorial toma como entrada un directorio que contiene varios archivos de texto y la ruta a un archivo en el que almacena la salida indexada (el nombre de archivo predeterminado es index.json). La función index lee el contenido de cada archivo de texto del directorio de entrada y, a continuación, pasa los archivos de texto a la API Cloud Natural Language para que se clasifiquen en categorías de contenido.

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 open(file_path) as f:
                text = f.read()
                categories = classify(text, verbose=False)

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

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

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

Los resultados de la API Cloud Natural Language de cada archivo se organizan en un solo diccionario, se serializan como una cadena JSON y, a continuación, 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 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 hacer consultas al índice para recuperar algunos de los nombres de archivo y sus puntuaciones de confianza.

Una forma de hacerlo es usar una etiqueta de categoría como consulta, lo que se consigue en el tutorial con 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 y la clasificación de similitud deben diseñarse cuidadosamente en función de casos de uso específicos.

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 open(index_file) 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 index.items():
        similarities.append((filename, similarity(query_categories, categories)))

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

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