Crea un modelo de k-means para agrupar en clústeres un conjunto de datos de alquileres de bicicletas en Londres

En este instructivo, aprenderás a usar un modelo de k-means en BigQuery ML para identificar clústeres en un conjunto de datos.

El algoritmo k-means que agrupa tus datos en clústeres es una forma de aprendizaje automático no supervisado. A diferencia del aprendizaje automático supervisado, que se centra en el análisis predictivo, el aprendizaje automático no supervisado se centra en el análisis descriptivo. El aprendizaje automático no supervisado puede ayudarte a comprender tus datos para que puedas tomar decisiones basadas en ellos.

Las consultas en este instructivo usan funciones de geografía disponibles en estadísticas geoespaciales. Para obtener más información, consulta Introducción a las estadísticas geoespaciales.

En este instructivo, se usa el conjunto de datos públicos Alquileres de bicicletas de Londres. Los datos incluyen marcas de tiempo de inicio y parada, nombres de estaciones y duración del viaje.

Crea un conjunto de datos

Crea un conjunto de datos de BigQuery para almacenar tu modelo de k-means:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a la página de BigQuery

2. En el panel de la izquierda, haz clic en Explorar:

   

   Si no ves el panel izquierdo, haz clic en Expandir panel izquierdo para abrirlo.

3. En el panel Explorador, haz clic en el nombre de tu proyecto.

4. Haz clic en Ver acciones > Crear conjunto de datos.

   

5. En la página Crear conjunto de datos, haz lo siguiente:

   • En ID del conjunto de datos, ingresa bqml_tutorial.

   • En Tipo de ubicación (Location type), selecciona Multirregión (Multi-region) y, luego, UE (varias regiones en la Unión Europea) (EU [multiple regions in European Union]).

     El conjunto de datos públicos de Alquileres de bicicletas de Londres se almacena en la multirregión EU. Tu conjunto de datos debe estar en la misma ubicación.

   • Deja la configuración predeterminada restante como está y haz clic en Crear conjunto de datos(Create dataset).

     

Examina los datos de entrenamiento

Examina los datos que usarás para entrenar tu modelo de k-means. En este instructivo, agruparás en clústeres las estaciones de bicicletas en función de los siguientes atributos:

• Duración de los alquileres
• Cantidad de viajes por día
• Distancia desde el centro de la ciudad

SQL

Esta consulta extrae datos sobre el alquiler de bicicletas, incluidas las columnas start_station_name y duration, y une estos datos con la información de la estación. Esto incluye la creación de una columna calculada que contenga la distancia de la estación al centro de la ciudad. Luego, calcula los atributos de la estación en una columna stationstats, incluida la duración promedio de los viajes y la cantidad de viajes, y la columna distance_from_city_center calculada.

Sigue estos pasos para examinar los datos de entrenamiento:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

   WITH
   hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF(
         EXTRACT(DAYOFWEEK FROM h.start_date) = 1
           OR EXTRACT(DAYOFWEEK FROM h.start_date) = 7,
         'weekend',
         'weekday') AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude, s.latitude), ST_GEOGPOINT(-0.1, 51.5)) / 1000
         AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
       ON
         h.start_station_id = s.id
     WHERE
       h.start_date
       BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP)
   ),
   stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday
   )
   SELECT *
   FROM
   stationstats
   ORDER BY
   distance_from_city_center ASC;

Los resultados debería ser similar al siguiente:

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de BigQuery DataFrames.

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

import datetime
import typing

import pandas as pd
from shapely.geometry import Point

import bigframes
import bigframes.bigquery as bbq
import bigframes.geopandas
import bigframes.pandas as bpd

bigframes.options.bigquery.project = your_gcp_project_id
# Compute in the EU multi-region to query the London bicycles dataset.
bigframes.options.bigquery.location = "EU"

# Extract the information you'll need to train the k-means model in this
# tutorial. Use the read_gbq function to represent cycle hires
# data as a DataFrame.
h = bpd.read_gbq(
    "bigquery-public-data.london_bicycles.cycle_hire",
    col_order=["start_station_name", "start_station_id", "start_date", "duration"],
).rename(
    columns={
        "start_station_name": "station_name",
        "start_station_id": "station_id",
    }
)

# Use GeoSeries.from_xy and BigQuery.st_distance to analyze geographical
# data. These functions determine spatial relationships between
# geographical features.
cycle_stations = bpd.read_gbq("bigquery-public-data.london_bicycles.cycle_stations")
s = bpd.DataFrame(
    {
        "id": cycle_stations["id"],
        "xy": bigframes.geopandas.GeoSeries.from_xy(
            cycle_stations["longitude"], cycle_stations["latitude"]
        ),
    }
)
s_distance = bbq.st_distance(s["xy"], Point(-0.1, 51.5), use_spheroid=False) / 1000
s = bpd.DataFrame({"id": s["id"], "distance_from_city_center": s_distance})

# Define Python datetime objects in the UTC timezone for range comparison,
# because BigQuery stores timestamp data in the UTC timezone.
sample_time = datetime.datetime(2015, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
sample_time2 = datetime.datetime(2016, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)

h = h.loc[(h["start_date"] >= sample_time) & (h["start_date"] <= sample_time2)]

# Replace each day-of-the-week number with the corresponding "weekday" or
# "weekend" label by using the Series.map method.
h = h.assign(
    isweekday=h.start_date.dt.dayofweek.map(
        {
            0: "weekday",
            1: "weekday",
            2: "weekday",
            3: "weekday",
            4: "weekday",
            5: "weekend",
            6: "weekend",
        }
    )
)

# Supplement each trip in "h" with the station distance information from
# "s" by merging the two DataFrames by station ID.
merged_df = h.merge(
    right=s,
    how="inner",
    left_on="station_id",
    right_on="id",
)

# Engineer features to cluster the stations. For each station, find the
# average trip duration, number of trips, and distance from city center.
stationstats = typing.cast(
    bpd.DataFrame,
    merged_df.groupby(["station_name", "isweekday"]).agg(
        {"duration": ["mean", "count"], "distance_from_city_center": "max"}
    ),
)
stationstats.columns = pd.Index(
    ["duration", "num_trips", "distance_from_city_center"]
)
stationstats = stationstats.sort_values(
    by="distance_from_city_center", ascending=True
).reset_index()

# Expected output results: >>> stationstats.head(3)
# station_name	isweekday duration  num_trips	distance_from_city_center
# Borough Road...	weekday	    1110	    5749	    0.12624
# Borough Road...	weekend	    2125	    1774	    0.12624
# Webber Street...	weekday	    795	        6517	    0.164021
#   3 rows × 5 columns

Crea un modelo de k-means

Crea un modelo de k-means con los datos de entrenamiento de alquileres de bicicletas en Londres.

SQL

En la siguiente consulta, la instrucción CREATE MODEL especifica la cantidad de clústeres que se usarán: cuatro. En la declaración SELECT, la cláusula EXCEPT excluye la columna station_name porque esta columna no contiene un atributo. La consulta crea una fila única por station_name y en la declaración SELECT solo se mencionan los atributos.

Sigue estos pasos para crear un modelo de k-means:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

   CREATE OR REPLACE MODEL `bqml_tutorial.london_station_clusters`
   OPTIONS (
     model_type = 'kmeans',
     num_clusters = 4)
   AS
   WITH
   hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF(
         EXTRACT(DAYOFWEEK FROM h.start_date) = 1
           OR EXTRACT(DAYOFWEEK FROM h.start_date) = 7,
         'weekend',
         'weekday') AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude, s.latitude), ST_GEOGPOINT(-0.1, 51.5)) / 1000
         AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
       ON
         h.start_station_id = s.id
     WHERE
       h.start_date
       BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP)
   ),
   stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday
   )
   SELECT *
   EXCEPT (station_name, isweekday)
   FROM
   stationstats;

Permite trabajar con BigQuery DataFrames.

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de BigQuery DataFrames.

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

from bigframes.ml.cluster import KMeans

# To determine an optimal number of clusters, construct and fit several
# K-Means objects with different values of num_clusters, find the error
# measure, and pick the point at which the error measure is at its minimum
# value.
cluster_model = KMeans(n_clusters=4)
cluster_model.fit(stationstats)
cluster_model.to_gbq(
    your_model_id,  # For example: "bqml_tutorial.london_station_clusters"
    replace=True,
)

Interpreta los clústeres de datos

La información de la pestaña Evaluación de los modelos puede ayudarte a interpretar los clústeres que produce el modelo.

Sigue estos pasos para ver la información de evaluación del modelo:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a BigQuery

2. En el panel de la izquierda, haz clic en Explorar:

   

3. En el panel Explorador, expande tu proyecto y haz clic en Conjuntos de datos.

4. Haz clic en el conjunto de datos bqml_tutorial y, luego, ve a la pestaña Modelos.

5. Selecciona el modelo london_station_clusters.

6. Selecciona la pestaña Evaluación. Esta pestaña muestra visualizaciones de los clústeres identificados por el modelo k-means. En la sección Atributos numéricos, los gráficos de barras muestran los valores de atributos numéricos más importantes para cada centroide. Cada centroide representa un clúster de datos determinado. Puedes seleccionar qué atributos visualizar en el menú desplegable.

   

   Este modelo crea los siguientes centroides:

   • El centroide 1 muestra una estación de la ciudad menos ocupada, con alquileres de menor duración.
   • El centroide 2 muestra la segunda estación de la ciudad que está menos ocupada y que se usa para alquileres de mayor duración.
   • El centroide 3 muestra una estación de la ciudad ocupada que se encuentra cerca del centro de la ciudad.
   • El centroide 4 muestra una estación suburbana con viajes que son más largos.

   Si tuvieras un negocio de alquiler de bicicletas, podrías usar esta información para tomar decisiones comerciales. Por ejemplo:

   • Supongamos que necesitas experimentar con un tipo nuevo de anclaje. ¿Qué clúster de estaciones deberías elegir para realizar este experimento? Las estaciones los centroides 1, 2 o 4 parecen opciones lógicas porque no son las estaciones más concurridas.

   • Supongamos que deseas abastecer algunas estaciones con bicicletas de carrera. ¿Qué estaciones debes elegir? El centroide 4 es el grupo de estaciones que están lejos del centro de la ciudad y tienen los viajes más largos. Estas son las posibles candidatas para las bicicletas de carrera.

Usa la función ML.PREDICT para predecir el clúster de una estación

Identifica el clúster al que pertenece una estación en particular con la función ML.PREDICT de SQL o la función predict de BigQuery DataFrames.

SQL

En la siguiente consulta, se usa la función REGEXP_CONTAINS para buscar todas las entradas en la columna station_name que contienen la cadena Kennington. La función ML.PREDICT usa esos valores para predecir qué clústeres podrían contener esas estaciones.

Sigue estos pasos para predecir el clúster de cada estación que tiene la cadena Kennington en su nombre:

1. En la consola de Google Cloud , ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

   WITH
   hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF(
         EXTRACT(DAYOFWEEK FROM h.start_date) = 1
           OR EXTRACT(DAYOFWEEK FROM h.start_date) = 7,
         'weekend',
         'weekday') AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude, s.latitude), ST_GEOGPOINT(-0.1, 51.5)) / 1000
         AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
       ON
         h.start_station_id = s.id
     WHERE
       h.start_date
       BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP)
   ),
   stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday
   )
   SELECT *
   EXCEPT (nearest_centroids_distance)
   FROM
   ML.PREDICT(
     MODEL `bqml_tutorial.london_station_clusters`,
     (
       SELECT *
       FROM
         stationstats
       WHERE
         REGEXP_CONTAINS(station_name, 'Kennington')
     ));

Los resultados deberían ser similares a los siguientes.

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de BigQuery DataFrames.

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

# Select model you'll use for predictions. `read_gbq_model` loads model
# data from BigQuery, but you could also use the `cluster_model` object
# from previous steps.
cluster_model = bpd.read_gbq_model(
    your_model_id,
    # For example: "bqml_tutorial.london_station_clusters",
)

# Use 'contains' function to filter by stations containing the string
# "Kennington".
stationstats = stationstats.loc[
    stationstats["station_name"].str.contains("Kennington")
]

result = cluster_model.predict(stationstats)

# Expected output results:   >>>results.peek(3)
# CENTROID...	NEAREST...	station_name  isweekday	 duration num_trips dist...
# 	1	[{'CENTROID_ID'...	Borough...	  weekday	  1110	    5749	0.13
# 	2	[{'CENTROID_ID'...	Borough...	  weekend	  2125      1774	0.13
# 	1	[{'CENTROID_ID'...	Webber...	  weekday	  795	    6517	0.16
#   3 rows × 7 columns