Esta serie de tres partes demuestra cómo usar redes neuronales gráficas (GNN) y Amazonas Neptuno para generar recomendaciones de películas usando el IMDb y Box Office Mojo Películas/TV/OTT paquete de datos con licencia, que proporciona una amplia gama de metadatos de entretenimiento, incluidas más de mil millones de calificaciones de usuarios; créditos para más de 1 millones de miembros del elenco y del equipo; 11 millones de títulos de películas, televisión y entretenimiento; y datos de informes de taquilla global de más de 9 países. Muchos clientes de medios y entretenimiento de AWS obtienen licencias de datos de IMDb a través de Intercambio de datos de AWS para mejorar el descubrimiento de contenido y aumentar el compromiso y la retención del cliente.

In Parte 1, discutimos las aplicaciones de GNN y cómo transformar y preparar nuestros datos de IMDb para realizar consultas. En esta publicación, discutimos el proceso de usar Neptune para generar incrustaciones que se utilizan para realizar nuestra búsqueda fuera del catálogo en la Parte 3. también pasamos Aprendizaje automático de Amazon Neptune, la función de aprendizaje automático (ML) de Neptune y el código que usamos en nuestro proceso de desarrollo. En la Parte 3, explicamos cómo aplicar nuestras incrustaciones de gráficos de conocimiento a un caso de uso de búsqueda fuera del catálogo.

Resumen de la solución

Los grandes conjuntos de datos conectados a menudo contienen información valiosa que puede ser difícil de extraer mediante consultas basadas únicamente en la intuición humana. Las técnicas de ML pueden ayudar a encontrar correlaciones ocultas en gráficos con miles de millones de relaciones. Estas correlaciones pueden ser útiles para recomendar productos, predecir la solvencia crediticia, identificar fraudes y muchos otros casos de uso.

Neptune ML hace posible construir y entrenar modelos ML útiles en gráficos grandes en horas en lugar de semanas. Para lograr esto, Neptune ML utiliza la tecnología GNN impulsada por Amazon SageMaker y del Biblioteca de gráficos profundos (DGL) (cual es De código abierto). Los GNN son un campo emergente en inteligencia artificial (para ver un ejemplo, consulte Una encuesta completa sobre redes neuronales gráficas). Para obtener un tutorial práctico sobre el uso de GNN con DGL, consulte Aprendizaje de redes neuronales gráficas con Deep Graph Library.

En esta publicación, mostramos cómo usar Neptune en nuestra canalización para generar incrustaciones.

El siguiente diagrama muestra el flujo general de datos de IMDb desde la descarga hasta la generación de incrustaciones.

Utilizamos los siguientes servicios de AWS para implementar la solución:

En esta publicación, lo guiamos a través de los siguientes pasos de alto nivel:

1. Configurar variables de entorno
2. Cree un trabajo de exportación.
3. Cree un trabajo de procesamiento de datos.
4. Envíe un trabajo de capacitación.
5. Descargar incrustaciones.

Código para los comandos de Neptune ML

Usamos los siguientes comandos como parte de la implementación de esta solución:

%%neptune_ml export start
%%neptune_ml export status
%neptune_ml training start
%neptune_ml training status

Utilizamos neptune_ml export para verificar el estado o iniciar un proceso de exportación de Neptune ML, y neptune_ml training para iniciar y verificar el estado de un trabajo de entrenamiento de modelos de Neptune ML.

Para obtener más información sobre estos y otros comandos, consulte Uso de la magia del banco de trabajo de Neptune en sus cuadernos.

Requisitos previos

Para seguir con esta publicación, debe tener lo siguiente:

• An Cuenta de AWS
• Familiaridad con SageMaker, Amazon S3 y AWS CloudFormation
• Datos gráficos cargados en el clúster de Neptune (ver Parte 1 para más información)

Configurar variables de entorno

Antes de comenzar, deberá configurar su entorno configurando las siguientes variables: s3_bucket_uri y processed_folder. s3_bucket_uri es el nombre del depósito utilizado en la Parte 1 y processed_folder es la ubicación de Amazon S3 para el resultado del trabajo de exportación.

# name of s3 bucket
s3_bucket_uri = "<s3-bucket-name>" # the s3 location you want to store results
processed_folder = f"s3://{s3_bucket_uri}/experiments/neptune-export/"

Crear un trabajo de exportación

En la Parte 1, creamos un cuaderno SageMaker y un servicio de exportación para exportar nuestros datos desde el clúster de base de datos de Neptune a Amazon S3 en el formato requerido.

Ahora que nuestros datos están cargados y el servicio de exportación está creado, necesitamos crear un trabajo de exportación para iniciarlo. Para hacer esto, usamos NeptuneExportApiUri y cree parámetros para el trabajo de exportación. En el siguiente código, usamos las variables expo y export_params. Conjunto expo para usted NeptuneExportApiUri valor, que puede encontrar en el Salidas pestaña de su pila de CloudFormation. Para export_params, usamos el punto final de su clúster de Neptune y proporcionamos el valor para outputS3path, que es la ubicación de Amazon S3 para el resultado del trabajo de exportación.

expo = <NEPTUNE-EXPORT-URI>
export_params={ "command": "export-pg", "params": { "endpoint": neptune_ml.get_host(),
            "profile": "neptune_ml",
            "cloneCluster": True
             }, "outputS3Path": processed_folder, "additionalParams": {
        "neptune_ml": {
          "version": "v2.0"
         }
      }, "jobSize": "medium"}

Para enviar el trabajo de exportación, use el siguiente comando:

%%neptune_ml export start --export-url {expo} --export-iam --store-to export_results --wait-timeout 1000000                                                              
${export_params}

Para verificar el estado del trabajo de exportación, use el siguiente comando:

%neptune_ml export status --export-url {expo} --export-iam --job-id {export_results['jobId']} --store-to export_results

Después de completar su trabajo, configure el processed_folder variable para proporcionar la ubicación de Amazon S3 de los resultados procesados:

export_results['processed_location']= processed_folder

Crear un trabajo de procesamiento de datos

Ahora que se realizó la exportación, creamos un trabajo de procesamiento de datos para preparar los datos para el proceso de capacitación de Neptune ML. Esto se puede hacer de diferentes maneras. Para este paso, puede cambiar el job_name y modelType variables, pero todos los demás parámetros deben permanecer iguales. La parte principal de este código es el modelType parámetro, que pueden ser modelos gráficos heterogéneos (heterogeneous) o gráficos de conocimiento (kge).

El trabajo de exportación también incluye training-data-configuration.json. Utilice este archivo para agregar o eliminar nodos o bordes que no desee proporcionar para el entrenamiento (por ejemplo, si desea predecir el vínculo entre dos nodos, puede eliminar ese vínculo en este archivo de configuración). Para esta publicación de blog, usamos el archivo de configuración original. Para obtener información adicional, consulte Edición de un archivo de configuración de entrenamiento.

Cree su trabajo de procesamiento de datos con el siguiente código:

job_name = neptune_ml.get_training_job_name("link-pred")
processing_params = f"""--config-file-name training-data-configuration.json --job-id {job_name}-DP --s3-input-uri {export_results['outputS3Uri']} --s3-processed-uri {export_results['processed_location']} --model-type kge --instance-type ml.m5.2xlarge """ %neptune_ml dataprocessing start --store-to processing_results {processing_params}

Para verificar el estado del trabajo de exportación, use el siguiente comando:

%neptune_ml dataprocessing status --job-id {processing_results['id']} --store-to processing_results

Enviar un trabajo de formación

Una vez que se completa el trabajo de procesamiento, podemos comenzar nuestro trabajo de capacitación, que es donde creamos nuestras incrustaciones. Recomendamos un tipo de instancia de ml.m5.24xlarge, pero puede cambiarlo para adaptarlo a sus necesidades informáticas. Ver el siguiente código:

dp_id = processing_results['id']
training_job_name = dp_id + "training"
training_job_name = "".join(training_job_name.split("-")) training_params=f"--job-id train-{training_job_name} --data-processing-id {dp_id} --instance-type ml.m5.24xlarge --s3-output-uri s3://{str(s3_bucket_uri)}/training/{training_job_name}/" %neptune_ml training start --store-to training_results {training_params} print(training_results)

Imprimimos la variable training_results para obtener el ID del trabajo de entrenamiento. Use el siguiente comando para verificar el estado de su trabajo:

%neptune_ml training status --job-id {training_results['id']} --store-to training_status_results

Descargar incrustaciones

Después de completar su trabajo de capacitación, el último paso es descargar sus incrustaciones sin procesar. Los siguientes pasos le muestran cómo descargar incrustaciones creadas con KGE (puede usar el mismo proceso para RGCN).

En el siguiente código, usamos neptune_ml.get_mapping() y get_embeddings() para descargar el archivo de mapeo (mapping.info) y el archivo de incrustaciones sin procesar (entity.npy). Luego, debemos asignar las incrustaciones apropiadas a sus ID correspondientes.

neptune_ml.get_embeddings(training_status_results["id"])                                            
neptune_ml.get_mapping(training_status_results["id"])                                               
                                                                                        
f = open('/home/ec2-user/SageMaker/model-artifacts/'+ training_status_results["id"]+'/mapping.info',  "rb")                                                                                   
mapping = pickle.load(f)                                                                
                                                                                        
node2id = mapping['node2id']                                                            
localid2globalid = mapping['node2gid']                                                  
data = np.load('/home/ec2-user/SageMaker/model-artifacts/'+ training_status_results["id"]+'/embeddings/entity.npy')                                                                           
                                                                                          
embd_to_sum = mapping["node2id"]                                                        
full = len(list(embd_to_sum["movie"].keys()))                                                                                                                                    
ITEM_ID = []                                                                            
KEY = []                                                                                
VALUE = []                                                                              
for ii in tqdm(range(full)):                                                         
node_id = list(embd_to_sum["movie"].keys())[ii]
index = localid2globalid['movie'][node2id['movie'][node_id]]
embedding = data[index]
ITEM_ID += [node_id]*embedding.shape[0]
KEY += [i for i in range(embedding.shape[0])]
VALUE += list(embedding)
                                                                       
meta_df = pd.DataFrame({"ITEM_ID": ITEM_ID, "KEY": KEY, "VALUE":VALUE})
meta_df.to_csv('new_embeddings.csv')

Para descargar RGCN, siga el mismo proceso con un nuevo nombre de trabajo de entrenamiento procesando los datos con el parámetro modelType establecido en heterogeneous, luego entrene su modelo con el parámetro modelName establecido en rgcn ver esta página para más detalles. Una vez que haya terminado, llame al get_mapping y get_embeddings funciones para descargar tu nuevo mapeo.info y entidad.npy archivos Una vez que tenga los archivos de entidad y asignación, el proceso para crear el archivo CSV es idéntico.

Finalmente, cargue sus incrustaciones en la ubicación deseada de Amazon S3:

s3_destination = "s3://"+s3_bucket_uri+"/embeddings/"+"new_embeddings.csv" !aws s3 cp new_embeddings.csv {s3_destination}

Asegúrese de recordar esta ubicación S3, deberá usarla en la Parte 3.

Limpiar

Cuando termine de usar la solución, asegúrese de limpiar todos los recursos para evitar cargos continuos.

Conclusión

En esta publicación, discutimos cómo usar Neptune ML para entrenar incrustaciones de GNN a partir de datos de IMDb.

Algunas aplicaciones relacionadas de las incrustaciones de gráficos de conocimiento son conceptos como búsqueda fuera de catálogo, recomendaciones de contenido, publicidad dirigida, predicción de enlaces faltantes, búsqueda general y análisis de cohortes. La búsqueda fuera del catálogo es el proceso de buscar contenido que no es de su propiedad y encontrar o recomendar contenido que está en su catálogo que es lo más parecido posible a lo que el usuario buscó. Profundizamos en la búsqueda fuera de catálogo en la Parte 3.

Acerca de los autores

mateo rodas es un científico de datos que trabaja en Amazon ML Solutions Lab. Se especializa en la construcción de canalizaciones de aprendizaje automático que involucran conceptos como el procesamiento del lenguaje natural y la visión por computadora.

divya bhargavi es científica de datos y líder vertical de medios y entretenimiento en Amazon ML Solutions Lab, donde resuelve problemas comerciales de alto valor para los clientes de AWS mediante el aprendizaje automático. Trabaja en comprensión de imágenes/videos, sistemas de recomendación de gráficos de conocimiento, casos de uso de publicidad predictiva.

Gaurav Relé es un científico de datos en el laboratorio de soluciones de Amazon ML, donde trabaja con clientes de AWS en diferentes verticales para acelerar el uso del aprendizaje automático y los servicios en la nube de AWS para resolver sus desafíos comerciales.

Karan Sindwani es científico de datos en Amazon ML Solutions Lab, donde crea e implementa modelos de aprendizaje profundo. Se especializa en el área de visión artificial. En su tiempo libre, disfruta del senderismo.

Soji Adeshina es científico aplicado en AWS, donde desarrolla modelos basados ​​en redes neuronales gráficas para aprendizaje automático en tareas de gráficos con aplicaciones para fraude y abuso, gráficos de conocimiento, sistemas de recomendación y ciencias de la vida. En su tiempo libre le gusta leer y cocinar.

Vidya Sagar Ravipati es Gerente en Amazon ML Solutions Lab, donde aprovecha su vasta experiencia en sistemas distribuidos a gran escala y su pasión por el aprendizaje automático para ayudar a los clientes de AWS en diferentes verticales de la industria a acelerar su adopción de la nube y la inteligencia artificial.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• Platoblockchain. Inteligencia del Metaverso Web3. Conocimiento amplificado. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/part-2-power-recommendations-and-search-using-an-imdb-knowledge-graph/