Prueba Gemini 1.5 Pro, nuestro modelo multimodal más avanzado en Vertex AI, y descubre lo que puedes compilar con una ventana contextual de token de 1 millón. Prueba Gemini 1.5 Pro, nuestro modelo multimodal más avanzado en Vertex AI, y descubre lo que puedes compilar con una ventana contextual de token de 1 millón.

Instructivo de clasificación de contenido

Público

Este instructivo está diseñado para que comiences a explorar y desarrollar aplicaciones rápidamente con la API de 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 la API de Natural Language. En esencia, las aplicaciones en Java y Node.js son similares. Consulta las Aplicaciones de muestra de la API de Natural Language para ver muestras en otros lenguajes (incluida la muestra de este instructivo).

Requisitos previos

Este instructivo tiene varios requisitos previos:

Haber configurado un proyecto de la API de Cloud Natural Language en la consola de Google Cloud
Haber configurado tu entorno con las credenciales predeterminadas de la aplicación en la consola de Google Cloud
Estar familiarizado con Python en la programación de la consola de Google Cloud
Haber configurado tu entorno de desarrollo de Python. Recomendamos que tengas instalada la versión más reciente de Python, pip y virtualenv en tu sistema. Para conocer las instrucciones, consulta la guía de configuración del entorno de desarrollo en Python para Google Cloud Platform.
Haber instalado la Biblioteca cliente de Google Cloud para Python

Descripción general

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.

Este instructivo utiliza texto fuente de muestra de Wikipedia. Puedes encontrar los archivos de texto de muestra en la carpeta recursos/textos del 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

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Natural Language, consulta Bibliotecas cliente de Natural Language. Para obtener más información, consulta la documentación de referencia de la API de Natural Language Python.

Para autenticarte en Natural Language, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import argparse
import json
import os

from google.cloud import language_v1
import numpy

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 a la API de Natural Language y las respuestas que se obtienen de ella.

La función classify del instructivo llama al método classifyText de la API 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 la API de Natural Language, consulta la Referencia de Natural Language.

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

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. 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 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 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 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 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: {filename}")
        print(f"\tSimilarity: {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 open(index_file) as f:
        index = json.load(f)

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

    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: {text}\n")
    for category, confidence in query_categories.items():
        print(f"\tCategory: {category}, confidence: {confidence}")
    print(f"\nMost similar {n_top} indexed texts:")
    for filename, sim in similarities[:n_top]:
        print(f"\tFilename: {filename}")
        print(f"\tSimilarity: {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

¿Qué sigue?

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 Google Cloud Platform para optimizar el 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.