Usar as incorporações de insights sobre dinâmica da população

Preparar dados de informações empíricas

Para usar embeddings de dinâmica populacional, os dados de informações empíricas precisam ser agregados a um limite geográfico compatível. Como os tipos de limites administrativos variam globalmente, é possível alinhar os dados usando sistemas de grade matemática universais (como células S2) ou regiões administrativas locais (como condados ou distritos, dependendo do conjunto de dados específico do país).

Opção 1: incorporar embeddings a um modelo atual

  • Prepare as informações empíricas com base no modelo atual: use os embeddings como covariáveis geoespaciais para aprimorar um modelo atual.
  • Treine um modelo de correção de erros: melhore um modelo atual integrando os embeddings a um modelo que usa a saída original, o valor esperado ou as informações empíricas e os embeddings para aprender um novo modelo de correção de erros.

Opção 2: ajuste para casos de uso específicos

  • Escolha um modelo de previsão: qualquer modelo, como GBDT, MLP ou linear, pode ser usado para previsões.
  • Use embeddings para previsão: use embeddings de dinâmica populacional como recursos de entrada, junto com outros dados contextuais, para melhorar a precisão da previsão.

Agregação de limites personalizados

Se os dados de informações empíricas usarem polígonos personalizados, como códigos postais, isócronas de tempo de viagem ou áreas comerciais, você poderá realizar uma agregação de limites. Esse processo combina vários vetores de células S2 em uma única representação para o polígono de destino. A escolha da metodologia de ponderação certa garante que o embedding agregado reflita com precisão as metas de modelagem downstream.

Use a agregação ponderada pela população para casos de uso centrados no ser humano, como performance de lojas de varejo ou modelagem de comportamento do consumidor.

O uso de uma agregação espacial ponderada por área para dados demográficos pode distorcer os recursos de machine learning. Isso ocorre quando áreas não povoadas, como parques, zonas industriais ou corpos d'água, distorcem o perfil dos moradores reais.

Para resolver isso, você pode realizar uma média ponderada pela população no BigQuery. Essa abordagem usa conjuntos de dados demográficos de alta resolução, como o WorldPop no catálogo de dados do Earth Engine, para calcular a densidade precisa de cada segmento de célula S2 que se cruza.

Para conferir um exemplo completo de implementação de um fluxo de trabalho ponderado pela população, execute o notebook interativo.

Logotipo do Colab Executar no Google Colab Logotipo do GitHub Ver código-fonte no GitHub

2. Média ponderada por área

Para casos de uso ambientais ou físicos, use a agregação ponderada por área. Isso é útil para análise de uso da terra, estudos de ambiente construído ou planejamento de infraestrutura em que é necessário avaliar regiões, independentemente da distribuição da população.

Nesses cenários, a área física da terra é mais relevante do que a densidade populacional humana. Isso garante que cada quilômetro quadrado dentro do limite do polígono contribua igualmente para o vetor agregado.

Nesse método, o vetor de embedding de cada célula S2 constituinte é ponderado pela área geográfica que ela cobre dentro do polígono de destino.

Operações geoespaciais e conversão de células S2

O Population Dynamics Insights usa tokens de célula S2 de nível 12 (armazenados na coluna geo_id como strings hexadecimais de 7 caracteres) como unidade espacial principal. É possível usar as funções geográficas integradas no BigQuery para converter coordenadas de pontos ou limites espaciais personalizados em tokens de células S2 correspondentes. Para converter tokens de células S2 em geometrias de polígonos para visualização, use bibliotecas do lado do cliente. Para mais informações, consulte Receber a geometria de células S2 de um token hexadecimal de nível 12.

Converter coordenadas de pontos em tokens hexadecimais de nível 12

Para corresponder coordenadas de pontos de latitude/longitude à coluna geo_id no Population Dynamics Insights, use a função S2_CELLIDFROMPOINT do BigQuery combinada com ST_GEOGPOINT.

O BigQuery armazena IDs de células S2 como valores INT64 assinados, o que faz com que os IDs de células em determinadas regiões sejam avaliados como números inteiros negativos. Nos exemplos abaixo, definimos uma função auxiliar chamada TO_S2_HEX que converte o número inteiro em um token hexadecimal padrão e remove os zeros à direita de acordo com a especificação de geometria S2.

A consulta a seguir converte coordenadas de pontos para a Times Square, em Nova York (latitude 40.75796, longitude -73.98554) no token hexadecimal de nível 12 correspondente:

CREATE TEMP FUNCTION TO_S2_HEX(s2_int INT64) RETURNS STRING AS (
  RTRIM(FORMAT('%x%015x', (s2_int >> 60) & 0xF, s2_int & 0x0FFFFFFFFFFFFFFF), '0')
);

SELECT
  'Times Square, NYC' AS location_name,
  TO_S2_HEX(S2_CELLIDFROMPOINT(ST_GEOGPOINT(-73.98554, 40.75796), level => 12)) AS geo_id;

Para converter uma tabela de pontos atual com colunas latitude e longitude em tokens S2 combináveis:

CREATE TEMP FUNCTION TO_S2_HEX(s2_int INT64) RETURNS STRING AS (
  RTRIM(FORMAT('%x%015x', (s2_int >> 60) & 0xF, s2_int & 0x0FFFFFFFFFFFFFFF), '0')
);

SELECT
  store_id,
  TO_S2_HEX(S2_CELLIDFROMPOINT(ST_GEOGPOINT(longitude, latitude), level => 12)) AS geo_id
FROM
  `your-project.internal_data.store_locations`;

Gerar tokens de células S2 de nível 12 para um polígono

Se os dados usarem limites de área personalizados (como áreas comerciais, zonas de entrega ou códigos postais no formato WKT ou GeoJSON), converta a representação de texto em uma GEOGRAPHY usando ST_GEOGFROM e use S2_COVERINGCELLIDS para extrair todas as células S2 de nível 12 que se cruzam.

A consulta a seguir extrai todos os tokens hexadecimais de nível 12 que cobrem um polígono personalizado no centro de Manhattan:

CREATE TEMP FUNCTION TO_S2_HEX(s2_int INT64) RETURNS STRING AS (
  RTRIM(FORMAT('%x%015x', (s2_int >> 60) & 0xF, s2_int & 0x0FFFFFFFFFFFFFFF), '0')
);

WITH CustomBoundary AS (
  SELECT ST_GEOGFROM('POLYGON((-73.99 40.75, -73.97 40.75, -73.97 40.76, -73.99 40.76, -73.99 40.75))') AS geom
)
SELECT
  TO_S2_HEX(s2_id) AS geo_id
FROM
  CustomBoundary,
  UNNEST(S2_COVERINGCELLIDS(geom, min_level => 12, max_level => 12)) AS s2_id;

Receber a geometria de células S2 de um token hexadecimal de nível 12

As funções GIS do BigQuery são conversores unidirecionais (geometria → ID de célula S2) e não incluem uma função para converter um token de célula S2 em uma GEOGRAPHY de polígono. Para receber a geometria de polígono de um token de célula S2 para visualização ou análise espacial, use uma biblioteca do lado do cliente em Python, como s2sphere para decodificar um token de célula S2 de 7 caracteres nas coordenadas de limite e shapely para construir um polígono para ferramentas de mapeamento como o Folium:

import s2sphere
from shapely.geometry import Polygon

def s2_token_to_polygon(s2_token: str) -> Polygon:
    """Converts a 7-character S2 cell token into a Shapely Polygon."""
    cell_id = s2sphere.CellId.from_token(s2_token)
    cell = s2sphere.Cell(cell_id)

    # Extract the 4 corner vertices of the S2 cell
    vertices = []
    for i in range(4):
        vertex = cell.get_vertex(i)
        lat_lng = s2sphere.LatLng.from_point(vertex)
        vertices.append((lat_lng.lng().degrees, lat_lng.lat().degrees))

    # Close the polygon loop
    vertices.append(vertices[0])
    return Polygon(vertices)

# Example: Get boundary for S2 token '549056f'
cell_polygon = s2_token_to_polygon('549056f')
print(cell_polygon.wkt)

Exemplos de consultas

Substitua your-project.your_dataset.embeddings_table pelo projeto, conjunto de dados e nome da tabela de destino.

SQL: buscar embeddings

Essa consulta recupera o vetor de embedding e os metadados administrativos das células S2 no conjunto de dados provisionado.

SELECT
  geo_id,
  administrative_area_level_1_name AS state,
  administrative_area_level_2_name AS county,
  features -- The 330-dim vector
FROM
  `your-project.your_dataset.embeddings_table`
LIMIT 10;

SQL: encontrar locais semelhantes

Essa consulta identifica locais comportamentalmente semelhantes sem exigir dados externos.

Ela usa a função ML.DISTANCE para calcular a similaridade de cosseno, retornando as principais correspondências para uma célula S2 de destino. Essa abordagem oferece suporte a cenários de planejamento de expansão, como determinar onde abrir uma nova loja com base no perfil de um local atual bem-sucedido.

Para visualizar células S2 em um mapa, é necessário converter ou unir o ID da célula S2 à geometria de polígono correspondente, porque esse conjunto de dados usa tokens de células S2 em vez de pontos de latitude e longitude.

WITH TargetLocation AS (
  SELECT features AS target_vector
  FROM `your-project.your_dataset.embeddings_table`
  -- Replace with your target S2 hex token (e.g., '80ead45')
  WHERE geo_id = 'YOUR_TARGET_S2_TOKEN'
)

SELECT
  t.geo_id,
  t.administrative_area_level_1_name AS state,
  t.administrative_area_level_2_name AS county,
  -- Calculate Similarity (1.0 is identical, 0.0 is dissimilar)
  (1 - ML.DISTANCE(t.features, p.target_vector, 'COSINE')) AS similarity_score
FROM
  `your-project.your_dataset.embeddings_table` t,
  TargetLocation p
WHERE
  t.geo_id != 'YOUR_TARGET_S2_TOKEN' -- Exclude the target itself
ORDER BY
  similarity_score DESC
LIMIT 20;

SQL: unir dados do cliente

Este exemplo demonstra como enriquecer seus próprios dados internos (por exemplo, uma tabela de performance da loja) com embeddings comportamentais. Verifique se os dados internos incluem tokens de células S2 correspondentes (strings hexadecimais).

SELECT
  store.store_id,
  store.s2_token,
  store.total_revenue,
  embeddings.features AS pdfm_vector
FROM
  `your-project.internal_data.store_performance` AS store
JOIN
  `your-project.your_dataset.embeddings_table` AS embeddings
ON
  -- Join based on the S2 hex token string
  store.s2_token = embeddings.geo_id

Python: carregar dados para machine learning

Os embeddings são armazenados como matrizes do BigQuery. Para usá-los em bibliotecas de ML, é necessário converter a coluna em uma matriz NumPy.

from google.cloud import bigquery
import numpy as np
import pandas as pd

client = bigquery.Client()

query = """
    SELECT
        geo_id,
        features -- Returns as a list of floats
    FROM
        `your-project.your_dataset.embeddings_table`
    LIMIT 1000
"""

# 1. Load data into DataFrame
df = client.query(query).to_dataframe()

# 2. Convert the 'features' column (Series of Lists) into a Matrix (2D Array)
X_matrix = np.stack(df['features'].values)

print(f"Data Loaded. Matrix Shape: {X_matrix.shape}")
# Output: Data Loaded. Matrix Shape: (1000, 330)