Este laboratorio introduce el aprendizaje automático usando Spark ML Lib (sparkml).
La biblioteca Spark ML también se conoce comúnmente como MLlib y se usa para realizar operaciones de aprendizaje automático con APIs basadas en DataFrames.
Después de completar este laboratorio podrás:
Para este laboratorio vamos a usar Python y Spark (pyspark). Estas bibliotecas deben estar instaladas en tu entorno de laboratorio o en SN Labs.
# When you are executing on SN labs please uncomment the below lines and then run all cells.Next again Restart the kernel and run all cells.
!pip3 install pyspark==3.1.2
!pip install findspark
import findspark
findspark.init()
# Pandas is a popular data science package for Python. In this lab, we use Pandas to load a CSV file from disc to a pandas dataframe in memory.
import pandas as pd
import matplotlib.pyplot as plt
# pyspark is the Spark API for Python. In this lab, we use pyspark to initialize the spark context.
from pyspark import SparkContext, SparkConf
from pyspark.sql import SparkSession
En este ejercicio crearás e inicializarás la sesión de Spark necesaria para cargar los dataframes y operar con ellos.
# Creating a spark context class
sc = SparkContext()
# Creating a spark session
spark = SparkSession \
.builder \
.appName("Python Spark DataFrames basic example") \
.config("spark.some.config.option", "some-value") \
.getOrCreate()
Para trabajar con dataframes solo necesitamos verificar que se haya creado la instancia de sesión de Spark. Puedes hacer clic en el botón "Spark UI" para explorar los elementos de la interfaz de Spark.
spark
En este ejercicio importaremos 4 funciones de SparkML
from pyspark.ml.feature import VectorAssembler, Normalizer, StandardScaler
from pyspark.ml.stat import Correlation
from pyspark.ml.regression import LinearRegression
En esta sección, primero leerás el archivo CSV en un dataframe de pandas y luego en un dataframe de Spark.
Pandas es una biblioteca usada para manipulación y análisis de datos. Ofrece estructuras y operaciones para crear y manipular objetos Series y DataFrame. Los datos pueden importarse desde varias fuentes, por ejemplo arreglos de NumPy, diccionarios de Python y archivos CSV. Pandas permite manipular, organizar y visualizar los datos.
En este ejemplo usamos un conjunto de datos que contiene información sobre automóviles.
# Read the file using `read_csv` function in pandas
cars = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBM-BD0225EN-SkillsNetwork/labs/data/cars.csv')
# Preview a few records
cars.head()
Para este ejemplo, preprocesamos los datos y usamos solo 3 columnas. Este conjunto de datos preprocesado se encuentra en el archivo cars2.csv.
cars2 = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBM-BD0225EN-SkillsNetwork/labs/data/cars2.csv', header=None, names=["mpg", "hp", "weight"])
cars2.head()
# We use the `createDataFrame` function to load the data into a spark dataframe
sdf = spark.createDataFrame(cars2)
# Let us look at the schema of the loaded spark dataframe
sdf.printSchema()
En esta tarea usamos la función VectorAssembler() para convertir las columnas del dataframe en vectores de características.
Para nuestro ejemplo, usamos la potencia ("hp") y el peso del automóvil como características de entrada, y las millas por galón ("mpg") como etiqueta objetivo.
assembler = VectorAssembler(
inputCols=["hp", "weight"],
outputCol="features")
output = assembler.transform(sdf).select('features','mpg')
Ahora creamos una división entrenamiento-prueba de 75%-25%.
train, test = output.randomSplit([0.75, 0.25])
En este ejercicio determinamos la correlación entre los vectores de características y normalizamos las características.
Spark ML tiene una función de correlación incorporada como parte de la biblioteca Stat. Usamos esta función para determinar los distintos tipos de correlación entre las 2 características: "hp" y "weight".
r1 = Correlation.corr(train, "features").head()
print("Pearson correlation matrix:\n" + str(r1[0]))
r2 = Correlation.corr(train, "features", "spearman").head()
print("Spearman correlation matrix:\n" + str(r2[0]))
Podemos ver que existe una correlación de 0.86 (o 86%) entre las características. Esto es lógico, ya que un automóvil con mayor potencia probablemente tiene un motor más grande y por eso pesa más. También podemos visualizar los vectores de características para comprobar que están correlacionados.
plt.figure()
plt.scatter(cars2["hp"], cars2["weight"])
plt.xlabel("horsepower")
plt.ylabel("weight")
plt.title("Correlation between Horsepower and Weight")
plt.show()
Para lograr un mejor entrenamiento y convergencia del modelo, es una buena práctica normalizar los vectores de características.
normalizer = Normalizer(inputCol="features", outputCol="features_normalized", p=1.0)
train_norm = normalizer.transform(train)
print("Normalized using L^1 norm")
train_norm.show(5, truncate=False)
Esta es una práctica estándar para escalar las características, de modo que todas las columnas tengan media cero y varianza unitaria.
standard_scaler = StandardScaler(inputCol="features", outputCol="features_scaled")
train_model = standard_scaler.fit(train)
train_scaled = train_model.transform(train)
train_scaled.show(5, truncate=False)
test_scaled = train_model.transform(test)
test_scaled.show(5, truncate=False)
En este ejercicio entrenamos un modelo de regresión lineal lrModel con nuestro conjunto de entrenamiento. Entrenamos el modelo con la versión de características escaladas de forma estándar.
También imprimimos las métricas finales de RMSE y R-cuadrado.
Podemos crear el modelo usando la clase LinearRegression() y entrenarlo con la función fit().
# Create a LR model
lr = LinearRegression(featuresCol='features_scaled', labelCol='mpg', maxIter=100)
# Fit the model
lrModel = lr.fit(train_scaled)
# Print the coefficients and intercept for linear regression
print("Coefficients: %s" % str(lrModel.coefficients))
print("Intercept: %s" % str(lrModel.intercept))
# Summarize the model over the training set and print out some metrics
trainingSummary = lrModel.summary
#trainingSummary.residuals.show()
print("RMSE: %f" % trainingSummary.rootMeanSquaredError)
print("R-squared: %f" % trainingSummary.r2)
Observamos un RMSE (raíz del error cuadrático medio) de 4.26. Esto significa que nuestro modelo predice el mpg con un error promedio de 4.2 unidades.
Una vez entrenado un modelo, podemos usar transform() sobre datos nuevos no vistos (por ejemplo, los datos de prueba) para generar predicciones.
En la celda de abajo, observa la columna "prediction", que contiene el "mpg" predicho.
lrModel.transform(test_scaled).show(5)
Imprime la matriz de correlación para la partición del conjunto de prueba creada arriba.
# Code block for learners to answer
r1 = Correlation.corr(test, "features").head()
print("Pearson correlation matrix:\n" + str(r1[0]))
Haz doble clic aquí para ver la solución.
Normaliza las características de entrenamiento usando la norma L2 del vector de características.
# Code block for learners to answer
normalizer_l2 = Normalizer(inputCol="features", outputCol="features_normalized", p=2.0)
train_norm_l2 = normalizer_l2.transform(train)
print("Normalized using L^1 norm\n"+str(train_norm_l2))
train_norm_l2.show(5, truncate=False)
Haz doble clic aquí para ver la solución.
Repite el entrenamiento del modelo mostrado arriba durante otras 100 iteraciones y reporta los coeficientes.
# Code block for Question 3
Copyright © 2021 IBM Corporation. Todos los derechos reservados.