GSP271

Descripción general

Introducción

En este lab aprenderás a implementar la regresión logística usando una biblioteca de aprendizaje automático en Apache Spark. Spark se ejecuta en un clúster de Managed Service for Spark para desarrollar un modelo para datos de un conjunto de datos multivariable.

Managed Service for Spark es un servicio en la nube rápido, fácil de usar y completamente administrado que se utiliza para ejecutar clústeres de Apache Spark y Apache Hadoop de manera simple y rentable. Managed Service for Spark se integra fácilmente a otros servicios de Google Cloud, lo que te proporciona una plataforma eficaz y completa para procesamiento de datos, analítica y aprendizaje automático.

Apache Spark es un motor de analítica para procesamiento de datos a gran escala. La regresión logística está disponible como un módulo en MLlib, la biblioteca de aprendizaje automático de Apache Spark. Spark MLlib, también llamada Spark ML, incluye implementaciones para la mayoría de los algoritmos estándar de aprendizaje automático como agrupamientos en clústeres k-means, bosques aleatorios, mínimos cuadrados alternos, árboles de decisión, máquinas de vectores de soporte, entre otros. Spark se puede ejecutar en un clúster Hadoop, como Managed Service for Spark, con el objetivo de procesar conjuntos de datos muy grandes en paralelo.

Este lab utiliza un conjunto de datos base que se recuperó de US Bureau of Transport Statistics. El conjunto de datos proporciona información histórica sobre los vuelos internos en Estados Unidos y puede utilizarse para ilustrar una amplia gama de conceptos y técnicas de ciencia de datos. Este lab proporciona los datos como un conjunto de archivos de texto con formato CSV.

Objetivos

• Crear un conjunto de datos de entrenamiento para aprendizaje automático con Spark
• Desarrollar un modelo de aprendizaje automático de regresión logística con Spark
• Evaluar el comportamiento predictivo de un modelo de aprendizaje automático usando Spark en Managed Service for Spark
• Evaluar el modelo

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar. Se recomienda el navegador Chrome.

Nota: Usa una ventana del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab (recuerda que, una vez que comienzas un lab, no puedes pausarlo).

Nota: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón para abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debes usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordena las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia cuenta de Google Cloud para este lab podría generar cargos adicionales.

7. Haz clic para avanzar por las páginas siguientes:

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

Tarea 1. Crea un clúster de Managed Service for Spark

Habitualmente, el primer paso para escribir trabajos en Hadoop es iniciar su instalación. Esto implica establecer un clúster, instalarle Hadoop y configurarlo de manera que las máquinas se reconozcan entre ellas y puedan comunicarse de manera segura.

Luego, comienzas los procesos YARN y MapReduce y, finalmente, está todo listo para escribir unos programas en Hadoop. En Google Cloud, Managed Service for Spark hace más práctico iniciar un clúster Hadoop capaz de ejecutar MapReduce, Pig, Hive, Presto y Spark.

Si estás usando Spark, Managed Service for Spark ofrece un entorno Spark completamente administrado y sin servidores, solo tienes que enviar un programa Spark y Managed Service for Spark lo ejecuta. De esta manera, Managed Service for Spark es a Apache Spark lo que Dataflow es a Apache Beam. En realidad, Managed Service for Spark y Dataflow comparten servicios de backend.

En esta parte crearás una VM y, después, un clúster Managed Service for Spark en la VM.

1. En la consola de Cloud, en menú de navegación (), haz clic en Compute Engine > Instancias de VM.

2. Haz clic en el botón SSH junto a la VM startup-vm para ejecutar y conectar una terminal.

3. Haz clic en Conectar para confirmar la conexión de SSH.

4. Ejecuta el siguiente comando para clonar el repositorio data-science-on-gcp y navegar hacia el directorio 06_dataproc:

git clone https://github.com/GoogleCloudPlatform/data-science-on-gcp/ cd ~/data-science-on-gcp/06_dataproc

5. Establece el proyecto y la variable de bucket con el siguiente código:

export PROJECT_ID=$(gcloud info --format='value(config.project)') export BUCKET_NAME=$PROJECT_ID-dsongcp

6. Edita el archivo create_cluster.sh quitando el código de dependencia zonal --zone ${REGION}-a

nano create_cluster.sh

El resultado debería ser similar al siguiente:

gcloud dataproc clusters create ch6cluster \ --enable-component-gateway \ --region ${REGION} \ --master-machine-type n1-standard-4 \ --master-boot-disk-size 500 --num-workers 2 \ --worker-machine-type n1-standard-4 \ --worker-boot-disk-size 500 \ --optional-components JUPYTER --project $PROJECT \ --initialization-actions=$INSTALL \ --scopes https://www.googleapis.com/auth/cloud-platform

7. Guarda el archivo con Ctrl+X, presiona Y e Intro

8. Crea un clúster de Managed Service for Spark para ejecutar los trabajos, especificando el nombre de tu bucket y la región en la que se encuentra:

./create_cluster.sh $BUCKET_NAME {{{ project_0.default_region | "REGION" }}}

Este comando podría tardar unos minutos.

Nota: Cuando lleves a cabo estas tareas fuera de este lab, la zona de procesamiento debe estar en la misma región que el bucket para evitar cargos de salida de red. Crear un clúster de Cloud Managed Service for Spark

JupyterLab en Managed Service for Spark

1. En la consola de Cloud, en el menú de navegación, haz clic en Managed Service for Spark. Es posible que tengas que hacer clic en Más Productos y desplazar hacia abajo.

2. En lista de clústeres, haz clic en el nombre del clúster para ver más detalles.

3. Haz clic en la pestaña Interfaces web y, luego, haz clic en JupyterLab en la parte inferior del panel derecho.

4. En la sección del selector de Notebook, haz clic en Python 3 para abrir un notebook nuevo.

Para usar un notebook, debes ingresar comandos en una celda. Asegúrate de ejecutar los comandos en la celda presionando Mayúsculas + Intro o haciendo clic en el triángulo que aparece en el menú superior del notebook para ejecutar las celdas seleccionadas y avanzar.

Tarea 2. Configura un bucket e inicia sesión en Pyspark

1. Configura un bucket de Google Cloud Storage, en el cual se alojarán tus archivos sin procesar:

PROJECT=!gcloud config get-value project PROJECT=PROJECT[0] BUCKET = PROJECT + '-dsongcp' import os os.environ['BUCKET'] = PROJECT + '-dsongcp'

2. Ejecuta la celda presionando Mayúsculas + Intro o haciendo clic en el triángulo que aparece en el menú superior del notebook para ejecutar las celdas seleccionadas y avanzar.

Nota: Después de pegar comandos en la celda del notebook de Jupyter, siempre ejecuta la celda para que se ejecute el comando y avance a la siguiente celda.

3. Crea una sesión de Spark usando el siguiente bloque de código:

from pyspark.sql import SparkSession from pyspark import SparkContext sc = SparkContext('local', 'logistic') spark = SparkSession \ .builder \ .appName("Logistic regression w/ Spark ML") \ .getOrCreate()

Una vez que ese código se agregue al comienzo de cualquier secuencia de comandos de Spark en Python, cualquier código que se desarrolle con la shell interactiva de Spark o el notebook de Jupyter también funcionará cuando se inicie como una secuencia de comandos independiente.

Crea un DataFrame de Spark para entrenamiento

1. Ingresa los siguientes comandos en una celda nueva:

from pyspark.mllib.classification import LogisticRegressionWithLBFGS from pyspark.mllib.regression import LabeledPoint

2. Ejecuta la celda.

Nota: Cuando pegues los comandos en la celda del notebook de Jupyter, recuerda ejecutar la celda para asegurarte de que el último comando de cualquier secuencia se ejecute antes de continuar con el siguiente paso.

Tarea 3. Lee y limpia el conjunto de datos

Cuando iniciaste este lab, una secuencia de comandos automatizada te proporcionó datos en la forma de un conjunto de archivos CSV preparados, que se colocaron en tu bucket de Cloud Storage.

• Ahora, recupera el nombre del bucket de Cloud Storage de la variable de entorno que configuraste antes y crea el marco de datos traindays leyendo un CSV preparado que la secuencia de comandos automatizada colocó en tu bucket de Cloud Storage.

El archivo CSV identifica un subconjunto de días como válido para entrenamiento. Esto te permite crear vistas de todo el conjunto de datos flights, que está dividido en un conjunto de datos que se usa para entrenar a tu modelo, y otro que prueba o valida ese modelo.

Lee el conjunto de datos

1. Ingresa y ejecuta los siguientes comandos en una celda nueva:

traindays = spark.read \ .option("header", "true") \ .csv('gs://{}/flights/trainday.csv'.format(BUCKET)) traindays.createOrReplaceTempView('traindays')

2. Crea una vista de Spark SQL:

traindays.createOrReplaceTempView('traindays')

3. Consulta los primeros registros de la vista del conjunto de datos de entrenamiento:

spark.sql("SELECT * from traindays LIMIT 5").show()

Este comando muestra los primeros cinco registros en la tabla de entrenamiento:

El próximo paso del proceso es identificar los archivos de datos de origen.

4. Para ello, usa el archivo fragmentado all_flights-00000-*, ya que tiene un subconjunto representativo del conjunto de datos completo y se puede procesar en un tiempo razonable:

inputs = 'gs://{}/flights/tzcorr/all_flights-00000-*'.format(BUCKET) Note: Para procesar todo el conjunto de datos, cambia la línea siguiente por: #inputs = 'gs://{}/flights/tzcorr/all_flights-*'.format(BUCKET) # FULL

5. Ahora lee los datos en Spark SQL desde el archivo de entrada que creaste:

flights = spark.read.json(inputs) flights.createOrReplaceTempView('flights')

6. A continuación, crea una búsqueda que use solo datos de días identificados como parte del conjunto de datos de entrenamiento:

trainquery = """ SELECT DEP_DELAY, TAXI_OUT, ARR_DELAY, DISTANCE FROM flights f JOIN traindays t ON f.FL_DATE == t.FL_DATE WHERE t.is_train_day == 'True' """ traindata = spark.sql(trainquery)

7. Inspecciona algunos datos para verificar si son correctos:

print(traindata.head(2)) Nota: Puedes ver la advertencia "Truncated the string representation of a plan since it was too large." Para este lab, ignórala, ya que solo es relevante si quieres inspeccionar los registros de esquema SQL.

Tu resultado debería ser similar al siguiente código:

[Row(DEP_DELAY=-2.0, TAXI_OUT=26.0, ARR_DELAY=0.0, DISTANCE=677.0), Row(DEP_DELAY=-2.0, TAXI_OUT=22.0, ARR_DELAY=3. 0, DISTANCE=451.0)]

8. Indica a Spark que te proporcione un análisis del conjunto de datos:

traindata.describe().show()

Esto debería mostrar un resultado similar a la siguiente tabla:

Limpia el conjunto de datos

En esta tabla, los valores de la media y la desviación estándar se redondearon a dos decimales para mayor claridad, pero en la pantalla verás los valores de punto flotante completos.

En la tabla, se muestra que hay algunos problemas con los datos. No todos los registros tienen valores para todas las variables, hay diferentes estadísticas de recuento en DEP_DELAY, TAXI_OUT, ARR_DELAY y DISTANCE. Esto ocurre por los siguientes motivos:

• Hay vuelos programados que nunca salen
• Algunos vuelos salen, pero se cancelan antes del despegue
• Algunos vuelos se desvían y, por lo tanto, nunca aterrizan

Nota: Los recuentos para las columnas son todos diferentes. Tenemos que quitar los NULL de las variables de retrasos (corresponden a vuelos cancelados o desviados).

1. Ingresa el siguiente código en una celda nueva: trainquery = """ SELECT DEP_DELAY, TAXI_OUT, ARR_DELAY, DISTANCE FROM flights f JOIN traindays t ON f.FL_DATE == t.FL_DATE WHERE t.is_train_day == 'True' AND f.dep_delay IS NOT NULL AND f.arr_delay IS NOT NULL """ traindata = spark.sql(trainquery) traindata.describe().show()

Esto debería mostrar un resultado similar a la siguiente tabla:

2. Quita los vuelos que fueron cancelados o desviados usando la siguiente consulta:

trainquery = """ SELECT DEP_DELAY, TAXI_OUT, ARR_DELAY, DISTANCE FROM flights f JOIN traindays t ON f.FL_DATE == t.FL_DATE WHERE t.is_train_day == 'True' AND f.CANCELLED == 'False' AND f.DIVERTED == 'False' """ traindata = spark.sql(trainquery) traindata.describe().show()

Este resultado debería mostrar el mismo valor de recuento para cada columna, lo cual indica que solucionaste el problema.

Tarea 4. Desarrolla un modelo de regresión logística

Ahora puedes crear una función que convierta un conjunto de datos de tu DataFrame en un ejemplo de entrenamiento. Un ejemplo de entrenamiento contiene una muestra de los atributos de entrada y la respuesta correcta para esas entradas.

En este caso, respondes si el retraso de la llegada es menor a 15 minutos. Las etiquetas que usas como entrada son los valores de retraso de salida, tiempo de carreteo previo al despegue y distancia de vuelo.

1. Ingresa y ejecuta lo siguiente en una celda nueva para crear la definición de la función del ejemplo de entrenamiento:

def to_example(fields): return LabeledPoint(\ float(fields['ARR_DELAY'] < 15), #ontime? \ [ \ fields['DEP_DELAY'], \ fields['TAXI_OUT'], \ fields['DISTANCE'], \ ])

2. Asigna esta función de ejemplo de entrenamiento al conjunto de datos de entrenamiento:

examples = traindata.rdd.map(to_example)

3. Ingresa y ejecuta el siguiente comando para proporcionar un DataFrame de entrenamiento para el módulo de regresión logística de Spark:

lrmodel = LogisticRegressionWithLBFGS.train(examples, intercept=True)

El DataFrame de entrenamiento crea un modelo de regresión logística basada en tu conjunto de datos de entrenamiento:

• Usa el parámetro intercept=verdadero, porque, en este caso, la predicción para el retraso de llegadas no será igual a cero cuando todas las entradas sean cero.
• Si esperas que, en algún conjunto de datos de entrenamiento, la predicción sea cero cuando todas las entradas sean igual a cero, entonces debes especificar intercept=Falso.

4. Cuando se finalice este método de entrenamiento, el objeto lrmodel tendrá pesos y un valor de intercepción que puedes inspeccionar:

print(lrmodel.weights,lrmodel.intercept)

El resultado es similar al siguiente:

[-0.17926510230641074,-0.1353410840270897,0.00047781052266304745] 5.403405250989946

Cuando estos pesos se usen con la fórmula de regresión lineal, te permitirán crear un modelo utilizando código en el lenguaje que desees.

5. Prueba esto proporcionando algunas variables de entrada para un vuelo con las siguientes características:

• Retraso de salida de 6 minutos
• Tiempo de carreteo previo al despegue de 12 minutos
• Distancia de vuelo de 594 millas

print(lrmodel.predict([6.0,12.0,594.0]))

El resultado de 1 predice que el vuelo llegará a tiempo.

6. Ahora prueba con un retraso de salida mucho más largo, de 36 minutos.

print(lrmodel.predict([36.0,12.0,594.0]))

El resultado de 0 predice que el vuelo no llegará a tiempo.

Estos resultados no son probabilidades; se devuelven como verdadero o falso según un umbral que se configura en 0.5 de forma predeterminada.

7. Puedes borrar el umbral para que se devuelva la probabilidad real:

lrmodel.clearThreshold() print(lrmodel.predict([6.0,12.0,594.0])) print(lrmodel.predict([36.0,12.0,594.0]))

Observa que los resultados son probabilidades, con el primer resultado cerca de 1 y el segundo, cerca de 0.

8. Configura el umbral en 0.7 para que coincida con tu requisito de poder cancelar reuniones si la probabilidad de una llegada a tiempo es menor que el 70%.

lrmodel.setThreshold(0.7) print(lrmodel.predict([6.0,12.0,594.0])) print(lrmodel.predict([36.0,12.0,594.0]))

Nuevamente, tus resultados son 1 y 0, pero ahora reflejan el umbral de probabilidad del 70% que necesitas y no el 50% predeterminado.

Tarea 5. Guarda y restablece un modelo de regresión logística

Puedes guardar un modelo de regresión logística de Spark directamente en Cloud Storage. Esto te permite reutilizar un modelo sin tener que volver a entrenarlo desde cero.

Una ubicación de almacenamiento contiene solo un modelo. Esto evita interferencias con otros archivos existentes, que pueden causar problemas con la carga del modelo. Para ello, asegúrate de que la ubicación de almacenamiento esté vacía antes de guardar tu modelo de regresión Spark.

1. Ingresa el siguiente código en una celda nueva y ejecútalo:

MODEL_FILE='gs://' + BUCKET + '/flights/sparkmloutput/model' os.system('gsutil -m rm -r ' + MODEL_FILE)

Este comando debería informar un error que indica CommandException: 1 files/objects could not be removed porque aún no se guardó el modelo. El error indica que no hay archivos en la ubicación de destino. Debes asegurarte de que la ubicación esté vacía antes de intentar guardar el modelo; esto es lo que nos garantiza este comando.

2. Para guardar el modelo, ejecuta el siguiente comando:

lrmodel.save(sc, MODEL_FILE) print('{} saved'.format(MODEL_FILE))

3. Ahora destruye el objeto del modelo en la memoria y confirma que ya no contiene ningún dato del modelo:

lrmodel = 0 print(lrmodel)

4. Ahora recupera el modelo de Storage:

from pyspark.mllib.classification import LogisticRegressionModel lrmodel = LogisticRegressionModel.load(sc, MODEL_FILE) lrmodel.setThreshold(0.7)

Se restablecieron los parámetros del modelo, es decir, los valores de intercepciones y pesos.

Crear un modelo de regresión logística

Tarea 6. Haz predicciones con el modelo de regresión logística

1. Prueba el modelo con una situación en la que definitivamente el vuelo no llegue a tiempo:

print(lrmodel.predict([36.0,12.0,594.0]))

Esto imprime en pantalla un 0, que predice que el vuelo probablemente llegará tarde, según tu umbral de probabilidad del 70%.

2. Para finalizar, vuelve a probar el modelo con datos de un vuelo que llegue a tiempo:

print(lrmodel.predict([8.0,4.0,594.0]))

Esto imprime en pantalla un 1, que predice que el vuelo probablemente llegará a tiempo, según tu umbral de probabilidad del 70%.

Tarea 7. Examina el comportamiento del modelo

1. Ingresa el siguiente código en una celda nueva y ejecútala:

lrmodel.clearThreshold() # to make the model produce probabilities print(lrmodel.predict([20, 10, 500]))

Una vez que se quiten los umbrales, obtendrás las probabilidades. La probabilidad de llegar tarde aumenta a medida que aumenta el tiempo de retraso de la salida.

2. Considerando un retraso de la salida de 20 minutos y un tiempo de carreteo previo al despegue de 10 minutos, así es como la distancia afecta la probabilidad de que el vuelo llegue a tiempo:

import matplotlib.pyplot as plt import seaborn as sns import pandas as pd import numpy as np dist = np.arange(10, 2000, 10) prob = [lrmodel.predict([20, 10, d]) for d in dist] sns.set_style("whitegrid") ax = plt.plot(dist, prob) plt.xlabel('distance (miles)') plt.ylabel('probability of ontime arrival')

Como se puede observar, el efecto es relativamente menor. La probabilidad aumenta de 0.63 a 0.76 aproximadamente a medida que la distancia pasa de un vuelo muy corto a un vuelo intercontinental.

3. Ejecuta lo siguiente en una celda nueva:

delay = np.arange(-20, 60, 1) prob = [lrmodel.predict([d, 10, 500]) for d in delay] ax = plt.plot(delay, prob) plt.xlabel('departure delay (minutes)') plt.ylabel('probability of ontime arrival')

Por otro lado, si mantienes constantes el tiempo de carreteo previo al despegue y la distancia, y analizas el efecto del retraso de la salida, vas a ver un impacto más drástico.

Tarea 8. Evalúa el modelo

1. Para evaluar el modelo de regresión logística, debes probar los datos:

inputs = 'gs://{}/flights/tzcorr/all_flights-00001-*'.format(BUCKET) flights = spark.read.json(inputs) flights.createOrReplaceTempView('flights') testquery = trainquery.replace("t.is_train_day == 'True'","t.is_train_day == 'False'")

2. Ahora asigna esta función de ejemplo de entrenamiento al conjunto de datos de prueba:

testdata = spark.sql(testquery) examples = testdata.rdd.map(to_example)

3. Indica a Spark que te proporcione un análisis del conjunto de datos:

testdata.describe().show()

Esto debería mostrar un resultado similar a la siguiente tabla:

4. Define una función eval y devuelve los detalles de los vuelos totales cancelados, totales no cancelados, cancelados correctos y no cancelados correctos:

def eval(labelpred): ''' data = (label, pred) data[0] = label data[1] = pred ''' cancel = labelpred.filter(lambda data: data[1] < 0.7) nocancel = labelpred.filter(lambda data: data[1] >= 0.7) corr_cancel = cancel.filter(lambda data: data[0] == int(data[1] >= 0.7)).count() corr_nocancel = nocancel.filter(lambda data: data[0] == int(data[1] >= 0.7)).count() cancel_denom = cancel.count() nocancel_denom = nocancel.count() if cancel_denom == 0: cancel_denom = 1 if nocancel_denom == 0: nocancel_denom = 1 return {'total_cancel': cancel.count(), \ 'correct_cancel': float(corr_cancel)/cancel_denom, \ 'total_noncancel': nocancel.count(), \ 'correct_noncancel': float(corr_nocancel)/nocancel_denom \ }

5. Ahora, evalúa el modelo pasando una etiqueta de predicción correcta:

lrmodel.clearThreshold() # so it returns probabilities labelpred = examples.map(lambda p: (p.label, lrmodel.predict(p.features))) print('All flights:') print(eval(labelpred))

Resultado:

All flights: {'total_cancel': 14689, 'correct_cancel': 0.8239498944788617, 'total_noncancel': 67495, 'correct_noncancel': 0.9556411586043411}

6. Mantén solo esos ejemplos cerca del umbral de decisión, que es superior al 65% y menor que el 75%:

print('Flights near decision threshold:') labelpred = labelpred.filter(lambda data: data[1] > 0.65 and data[1] < 0.75) print(eval(labelpred))

Resultado:

Flights near decision threshold: {'total_cancel': 714, 'correct_cancel': 0.3711484593837535, 'total_noncancel': 850, 'correct_noncancel': 0.6788235294117647}

¡Felicitaciones!

Ahora sabes cómo usar Spark para realizar una regresión logística con un clúster de Managed Service for Spark.

Realiza tu próximo lab

Continúa con:

• Aprendizaje automático con TensorFlow en Agent Platform

Próximos pasos y más información

• Data Science on the Google Cloud Platform, 2nd Edition: O'Reilly Media, Inc.

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 4 de diciembre de 2023

Prueba más reciente del lab: 4 de diciembre de 2023

Copyright 2026 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.