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

Preparar dados de informações empíricas

Para usar incorporações de dinâmica populacional, seus dados de referência local precisam ser agregados a um limite geográfico compatível. Como os tipos de limites administrativos variam globalmente, você pode alinhar seus 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 informações empíricas baseadas em modelos atuais: use os embeddings como covariáveis geoespaciais para melhorar 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 do modelo original, o valor esperado ou a verdade fundamental 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 personalizada

Se os dados de verdade básica usarem polígonos personalizados, como códigos postais, isócronas de tempo de carro ou áreas de comércio, você poderá fazer uma agregação de limites. Esse processo combina vários vetores de célula S2 em uma única representação para o polígono de destino. Escolher a metodologia de ponderação certa garante que o embedding agregado reflita com precisão suas metas de modelagem downstream.

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

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

Para resolver isso, faça 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 por 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 do solo, 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 é 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 incorporação de cada célula S2 constituinte é ponderado pela área de superfície geográfica que ela cobre no polígono de destino.

Exemplos de consultas

Substitua your-project.your_dataset.embeddings_table pelo nome real do projeto, do conjunto de dados e 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 e retornar as principais correspondências de 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 de sucesso.

Para visualizar as 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élula 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: mesclar dados de clientes

Este exemplo demonstra como enriquecer seus próprios dados internos (por exemplo, uma tabela de performance da loja) com incorporações comportamentais. Verifique se os dados internos incluem tokens de célula 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á-las 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)