Negli ultimi anni il concetto di embedding è diventato centrale nel mondo dell'intelligenza artificiale. Nei Large Language Model una frase, un documento o un concetto vengono trasformati in un vettore numerico che ne rappresenta, in modo distribuito, il significato.
Lo stesso paradigma sta entrando nel GIS.
Una posizione geografica, un quartiere, una cella territoriale, un'immagine satellitare o una feature GIS possono essere rappresentati non soltanto attraverso coordinate, geometrie e attributi, ma attraverso un vettore ad alta dimensionalità appreso da un modello.
Il risultato è un cambiamento concettuale importante:
da "dove si trova questa feature?" e "quali attributi possiede?" a "che tipo di luogo rappresenta e quali altri luoghi le assomigliano?"
ArcGIS sta integrando questo paradigma direttamente nei propri workflow GeoAI. Gli USA Geodemographic Embeddings 2026 ne sono un esempio particolarmente interessante: migliaia di variabili demografiche, socioeconomiche, abitative e ambientali vengono trasformate in un vettore compatto di 256 dimensioni per ogni area geografica.
Ma il concetto va molto oltre quel dataset specifico. Gli embedding possono diventare una nuova primitiva dell'informazione geografica, insieme a geometria, attributi, topologia e coordinate.
1. Un embedding è prima di tutto algebra lineare
Formalmente possiamo descrivere un encoder come una funzione:
f : X → R^d
dove X rappresenta lo spazio originale dei dati e R^d uno spazio vettoriale di dimensione d.
Un oggetto complesso:
x ∈ Xviene trasformato in:
e = f(x)
e = [e₀, e₁, e₂, ..., e₍d-1₎]
Il vettore e viene chiamato embedding.
Nel caso di un modello linguistico:
"spatial database for urban analysis"
│
▼
Encoder
│
▼
[0.18, -0.42, 0.71, ..., -0.09]Nel caso GIS potremmo invece avere:
Location / Area / Raster / Feature
│
▼
Geospatial Encoder
│
▼
[0.31, 0.08, -0.67, ..., 0.22]La caratteristica fondamentale è che le singole componenti del vettore normalmente non hanno un significato interpretabile isolatamente.
Non possiamo quindi dire:
embedding[17] = reddito
embedding[42] = densità
embedding[103] = urbanizzazioneIl significato è distribuito nell'intero spazio latente.
È il pattern complessivo delle componenti a rappresentare il fenomeno.
2. Coordinate ed embedding non sono la stessa cosa
Nel GIS siamo già abituati a rappresentare un punto attraverso numeri:
P = (x, y)oppure:
P = (longitude, latitude)Ma queste coordinate descrivono esclusivamente la posizione geometrica.
Un location embedding risponde a una domanda differente.
Coordinate:
45.46, 9.19
Embedding:
[0.31, -0.12, 0.77, ..., -0.22]Le coordinate dicono:
Dove si trova questo luogo?
L'embedding cerca invece di codificare:
Che tipo di luogo è?
A seconda del modello utilizzato, il vettore può rappresentare informazioni relative a:
- urbanizzazione;
- demografia;
- uso del suolo;
- morfologia urbana;
- vegetazione;
- infrastrutture;
- caratteristiche ambientali;
- immagini satellitari;
- POI;
- mobilità;
- testi associati alla feature;
- relazioni spaziali con altre entità.
Quindi:
geometry ≠ embeddingSono due rappresentazioni complementari dello stesso oggetto geografico.
3. Due spazi differenti: geographic space ed embedding space
Questa distinzione porta a uno dei concetti più interessanti del GeoAI.
Nel normale spazio geografico possiamo avere:
A ●--------------------------------● B
500 kmLa distanza viene calcolata utilizzando coordinate, sistemi di riferimento e metriche spaziali.
Nello spazio degli embedding, gli stessi oggetti potrebbero invece essere:
A ●----● Bperché, nonostante siano geograficamente lontani, presentano caratteristiche estremamente simili.
Oppure due aree fisicamente vicine:
Geographic space
A ●---● B
Embedding space
A ●-------------------------------● Bpotrebbero risultare molto differenti dal punto di vista socioeconomico, urbanistico o ambientale.
Possiamo quindi distinguere due funzioni:
SpatialDistance(A, B)e:
EmbeddingDistance(E(A), E(B))La prima misura una relazione nello spazio geografico. La seconda misura una relazione nello spazio latente appreso dal modello.
4. La cosine similarity
Uno dei modi più comuni per confrontare embedding è la cosine similarity.
Dati due vettori A e B:
A · B
cos(A,B) = -----------------
||A|| ||B||Il prodotto scalare è:
A · B = Σ AᵢBᵢmentre la norma euclidea è:
||A|| = √Σ Aᵢ²La cosine similarity misura essenzialmente l'angolo fra due vettori.
Se i vettori normalizzati puntano nella stessa direzione:
similarity → 1sono molto simili secondo lo spazio semantico costruito dal modello.
Attenzione però a un errore interpretativo frequente:
una cosine similarity di 0.90 non significa che due luoghi siano "uguali al 90%".
È una misura geometrica nello spazio degli embedding, il cui significato dipende dal modello, dal training e dalla distribuzione dei dati.
5. Calcolare la similarity con NumPy
Il calcolo è estremamente semplice.
import numpy as np
a = np.array([0.21, 0.74, -0.32, 0.61], dtype=np.float32)
b = np.array([0.19, 0.70, -0.29, 0.58], dtype=np.float32)
similarity = np.dot(a, b) / (
np.linalg.norm(a) *
np.linalg.norm(b)
)
print(similarity)Dietro una parte importante della cosiddetta "semantic search" c'è quindi algebra lineare relativamente semplice.
La parte complessa non è il confronto fra i vettori.
La vera complessità consiste nel costruire uno spazio vettoriale nel quale la distanza abbia un significato utile per il dominio applicativo.
6. Che cosa possiamo trasformare in embedding nel GIS?
Praticamente qualsiasi sorgente informativa associata allo spazio.
GIS Feature
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
Geometry Imagery Attributes
│ │ │
▼ ▼ ▼
Geo Encoder Vision Encoder Tabular/Text
│ │ │
└───────────────────┼───────────────────┘
│
▼
Embedding
[e₀ ... eₙ]Location embeddings
Rappresentano il contesto associato a una posizione geografica.
Image embeddings
Un modello visuale o geospatial foundation model trasforma chip di immagini satellitari o aeree in vettori.
Text embeddings
Descrizioni, metadata, documenti, toponimi e altri campi testuali collegati a feature GIS possono essere trasformati in vettori semantici.
Geodemographic embeddings
Comprimono centinaia o migliaia di indicatori territoriali in una rappresentazione numerica compatta.
Multimodal embeddings
È probabilmente la direzione più interessante:
Satellite imagery ──► Vision encoder ──────┐
│
Demography ─────────► Tabular encoder ─────┤
│
POI ─────────────────► POI encoder ────────┼──► PLACE EMBEDDING
│
Text ────────────────► Text encoder ───────┤
│
Road network ────────► Graph encoder ──────┘Il risultato sarebbe una sorta di fingerprint digitale del luogo.
7. Gli USA Geodemographic Embeddings di Esri
Un'implementazione concreta di questo paradigma è rappresentata dagli USA Geodemographic Embeddings 2026 disponibili nell'ecosistema ArcGIS.
Gli embedding vengono costruiti attraverso il Geodemographic Foundation Model (GDFM) di Esri.
Il modello utilizza quattro grandi viste informative.
| Dataset | Informazione | Variabili |
|---|---|---|
| Age & Race Census | Struttura demografica e variazioni nel tempo | 2.049 |
| American Community Survey | Istruzione, lavoro, reddito, commuting, household | 1.617 |
| Housing & Household | Housing units, occupancy, tenure, composizione familiare | 1.521 |
| Environment | Temperatura, precipitazioni, land cover e indicatori fisici | 113 |
Parliamo quindi di oltre 5.000 variabili originarie.
Dopo preprocessing, pulizia, imputazione e scaling, queste informazioni vengono elaborate da un'architettura multiview autoencoder.
8. Multiview autoencoder: come nasce il vettore
Un autoencoder classico contiene due parti:
Input
│
▼
Encoder
│
▼
Latent representation
│
▼
Decoder
│
▼
Reconstructed inputL'obiettivo del training è ricostruire il più fedelmente possibile l'input dopo averlo compresso attraverso uno spazio latente più piccolo.
Nel modello geodemografico Esri il concetto viene esteso utilizzando viste informative differenti:
Census ─────────► Encoder 1 ──┐
│
ACS ────────────► Encoder 2 ──┤
│
Housing ────────► Encoder 3 ──┼──► Latent vector
│ 256 dimensions
Environment ────► Encoder 4 ──┘
│
┌─────────────────┼─────────────────┐
▼ ▼ ▼
Decoder Decoder Decoder
│ │ │
▼ ▼ ▼
reconstruct reconstruct reconstructIl modello viene addestrato minimizzando l'errore di ricostruzione delle differenti viste.
Il vettore latente finale ha:
D = 256dimensioni.
Un intero territorio viene quindi trasformato da migliaia di variabili esplicite a:
E(location) ∈ R²⁵⁶senza che ciascuna dimensione debba corrispondere direttamente a una singola variabile originale.
9. H3 come unità spaziale
Gli USA Geodemographic Embeddings vengono distribuiti utilizzando celle Uber H3 resolution 7.
Concettualmente:
territory
│
▼
H3 tessellation
│
├── hex 1 ──► embedding[256]
├── hex 2 ──► embedding[256]
├── hex 3 ──► embedding[256]
│
└── ...
Questa scelta è importante perché l'embedding diventa associato a un'unità spaziale uniforme e interrogabile come una normale feature GIS.
10. ArcGIS Pro: gli embedding diventano un tipo di informazione GIS
ArcGIS Pro dispone oggi di un toolset dedicato alla Embeddings Based Analysis.
Tra gli strumenti principali troviamo:
- Generate Embeddings Using AI Models;
- Find Similar Features Using Embeddings;
- Merge Embeddings;
- Extract Embeddings To Fields.
Questo è rilevante architetturalmente.
L'embedding non viene più considerato soltanto un artefatto interno a una pipeline di machine learning, ma diventa un elemento persistente del dataset GIS.
11. Come ArcGIS memorizza realmente un embedding
ArcGIS Pro persiste gli embedding in un campo geodatabase di tipo BLOB chiamato normalmente Embedding.
La rappresentazione è particolarmente interessante per uno sviluppatore.
Ogni componente viene serializzata come:
IEEE-754 32-bit floating point
little-endianIl payload è costituito semplicemente dalla sequenza dei valori:
[e₀][e₁][e₂]...[e₍D-1₎]senza header, delimitatori o metadata aggiuntivi.
Ogni componente occupa:
4 bytesperciò:
payload_size = D × 4Per un embedding da 256 dimensioni:
256 × 4 = 1024 bytesovvero circa 1 KB per feature, senza considerare l'overhead del database.
12. Leggere direttamente il BLOB con Python
import arcpy
import numpy as np
feature_class = r"C:\GIS\Data.gdb\Embeddings"
dimension = 256
with arcpy.da.SearchCursor(
feature_class,
["OBJECTID", "Embedding"]
) as cursor:
for object_id, blob in cursor:
if blob is None:
continue
expected_size = dimension * 4
if len(blob) != expected_size:
raise ValueError(
f"Embedding non valido per OID {object_id}: "
f"{len(blob)} bytes invece di {expected_size}"
)
vector = np.frombuffer(
blob,
dtype="<f4"
)
print(object_id, vector.shape)Il dtype:
<f4significa:
<= little-endian;f= floating point;4= quattro byte.
13. Scrivere un embedding in una Feature Class
È possibile effettuare anche l'operazione opposta.
import arcpy
import numpy as np
embedding = np.array(
[0.12, -0.98, 1.42, 0.33],
dtype="<f4"
)
embedding_bytes = np.asarray(
embedding,
dtype="<f4",
order="C"
).tobytes()
with arcpy.da.InsertCursor(
feature_class_path,
["SHAPE@", "Name", "Embedding"]
) as cursor:
cursor.insertRow([
geometry,
"Sample Feature",
embedding_bytes
])Questo apre una possibilità interessante: gli embedding non devono necessariamente essere generati da ArcGIS.
Possiamo produrli attraverso un modello esterno, serializzarli nel formato previsto e inserirli in una feature class per utilizzarli nei workflow GIS.
14. Base64 e Feature Service
Quando il BLOB deve transitare attraverso un canale testuale, ad esempio JSON o REST, il payload binario viene normalmente rappresentato attraverso Base64.
Float32[]
│
▼
binary payload
│
▼
Base64
│
▼
JSON / RESTLa rappresentazione logica del vettore non cambia.
15. Similarity Search in ArcGIS Pro
Supponiamo di voler trovare negli Stati Uniti aree con caratteristiche analoghe a una determinata zona universitaria.
Il workflow concettuale è:
Query polygon
│
▼
intersect embedding cells
│
▼
E₁, E₂, ..., Eₙ
│
▼
mean embedding
│
▼
Q
│
▼
cosine similarity
│
▼
all embeddings
│
▼
SIMILARITY ≥ threshold
│
▼
output Feature ClassSe la query interessa più feature, ArcGIS costruisce un unico query embedding attraverso la media:
1
Q = -------- Σ Eᵢ
nIl vettore risultante viene quindi confrontato con gli embedding dello spazio di ricerca utilizzando la cosine similarity.
16. ArcPy: Find Similar Features Using Embeddings
L'operazione può essere automatizzata direttamente in Python:
import arcpy
embedding_features = (
r"C:\GIS\GeoAI.gdb\LocationEmbeddings"
)
query_features = (
r"C:\GIS\GeoAI.gdb\QueryArea"
)
output_features = (
r"C:\GIS\GeoAI.gdb\SimilarAreas"
)
threshold = 0.85
arcpy.geoai.FindSimilarFeaturesUsingEmbeddings(
embedding_features,
query_features,
output_features,
threshold
)Il risultato è una nuova feature class contenente le feature che superano la soglia di similarità.
Questa query:
Find areas similar to this areaè profondamente diversa da:
Find areas within 50 kmoppure:
population > 100000
AND income BETWEEN ...
AND age BETWEEN ...
AND ...Nel primo caso non stiamo definendo manualmente le caratteristiche che rendono due aree simili.
Utilizziamo invece la struttura dello spazio latente appresa dal modello.
17. Implementare la stessa ricerca senza il tool ArcGIS
Possiamo riprodurre il concetto direttamente con NumPy.
import numpy as np
# N feature × D dimensioni
embeddings = np.asarray(embeddings, dtype=np.float32)
# D dimensioni
query = np.asarray(query, dtype=np.float32)
# normalizzazione
embeddings_norm = embeddings / np.linalg.norm(
embeddings,
axis=1,
keepdims=True
)
query_norm = query / np.linalg.norm(query)
# similarity di tutte le feature in una singola operazione matriciale
scores = embeddings_norm @ query_norm
threshold = 0.85
matching_indices = np.where(
scores >= threshold
)[0]
for index in matching_indices:
print(index, scores[index])Questa riga:
scores = embeddings_norm @ query_normè particolarmente significativa.
Con una singola moltiplicazione matrice-vettore otteniamo la similarità fra la query e tutte le feature.
18. Il problema della scala: brute force e ANN
Su qualche migliaio di feature un confronto esaustivo è perfettamente gestibile.
Se però abbiamo:
10 milioni di feature
×
768 dimensionila ricerca lineare diventa più costosa.
È qui che entrano in gioco gli algoritmi di Approximate Nearest Neighbor, o ANN.
Tra le strutture più utilizzate troviamo:
- HNSW;
- IVF;
- IVF-PQ;
- product quantization;
- graph-based vector indexes.
Il concetto è analogo a ciò che da decenni facciamo nei database spaziali.
GIS
Geometry
│
▼
Spatial Index
R-tree / grid / other
│
▼
candidate pruning
│
▼
exact geometry operationnel mondo vettoriale:
Embedding
│
▼
Vector Index
HNSW / IVF / ...
│
▼
candidate pruning
│
▼
vector similarity19. Spatial Index + Vector Index
La combinazione delle due tecnologie è probabilmente una delle architetture GIS più interessanti dei prossimi anni.
Feature
│
├── Geometry
│ │
│ └── Spatial Index
│
├── Attributes
│ │
│ └── B-tree / column index
│
└── Embedding
│
└── Vector IndexLa stessa entità può essere interrogata secondo tre dimensioni differenti:
- dove si trova;
- quali proprietà possiede;
- a cosa assomiglia.
20. La query GIS del futuro
Una query concettuale potrebbe diventare:
SELECT *
FROM Places
WHERE ST_Distance(
Geometry,
@SearchPoint
) < 50000
ORDER BY VectorDistance(
Embedding,
@QueryEmbedding
)
LIMIT 20;Prima applichiamo un vincolo geografico:
entro 50 kme successivamente ordiniamo i candidati in base alla similarità semantica:
più simili al luogo di riferimentoSpatial query e vector search non sono quindi tecnologie concorrenti.
Risolvono dimensioni differenti dello stesso problema.
21. Aggregare gli embedding nello spazio
Un problema molto GIS riguarda il cambio di scala.
Supponiamo di avere embedding a livello H3 ma di voler effettuare un'analisi a livello di contea:
H3 embeddings
│
▼
spatial overlay
│
▼
County
│
▼
aggregated embeddingArcGIS Pro mette a disposizione Merge Embeddings.
Quando le sorgenti sono poligonali, l'aggregazione considera l'area di sovrapposizione con il poligono target.
In termini concettuali:
Σ wᵢ Eᵢ
E_target = -----------------------
Σ wᵢdove il peso può dipendere dall'area di overlap.
Questo introduce un problema affascinante:
che cosa significa aggregare semanticamente lo spazio?
Nella statistica tradizionale sappiamo aggregare popolazione, reddito, superficie o densità.
Con gli embedding stiamo aggregando invece rappresentazioni latenti apprese.
22. Merge Embeddings con ArcPy
import arcpy
target_features = r"C:\GIS\Data.gdb\Counties"
embedding_features = (
r"C:\GIS\Data.gdb\H3_Embeddings"
)
output = (
r"C:\GIS\Data.gdb\CountyEmbeddings"
)
arcpy.geoai.MergeEmbeddings(
target_features,
embedding_features,
output
)23. Da BLOB a variabili esplicative
Molti algoritmi tradizionali di machine learning si aspettano una matrice tabulare:
X =
[
[x₁₁, x₁₂, ..., x₁d],
[x₂₁, x₂₂, ..., x₂d],
...
]Per questo ArcGIS permette di estrarre le componenti dell'embedding dal BLOB creando campi come:
emb_0
emb_1
emb_2
...
emb_255Il dataset diventa quindi:
OBJECTID
SHAPE
Population
Income
...
emb_0
emb_1
...
emb_255e può essere utilizzato come input di modelli di regressione, classificazione, clustering o AutoML.
24. Embedding come feature engineering automatizzato
Tradizionalmente un data scientist GIS potrebbe costruire manualmente decine o centinaia di variabili:
population_density
median_income
road_density
distance_to_station
green_area_percentage
building_density
average_age
employment_rate
...
Questa attività viene chiamata feature engineering.
Un embedding può essere visto, con le dovute cautele, come una forma di:
learned feature engineering.
Il modello apprende automaticamente una rappresentazione compatta delle relazioni presenti nei dati.
Questo non significa che gli attributi originali diventino inutili.
Al contrario, una delle strategie più potenti consiste nel combinare:
domain variables
+
spatial variables
+
embedding dimensions
│
▼
ML model25. Un embedding non è una spiegazione
Questa distinzione è fondamentale.
Se un modello utilizza:
median_income = 42,000la variabile è interpretabile.
Se utilizza:
emb_147 = -0.2738quel numero, da solo, normalmente non ha alcun significato leggibile.
Gli embedding introducono quindi un trade-off:
feature engineering manuale
│
├── maggiore interpretabilità
└── maggiore lavoro
embedding
│
├── rappresentazione ricca
├── maggiore riusabilità
└── minore interpretabilità diretta26. Image embeddings e Earth Observation
Il concetto diventa ancora più potente nel remote sensing.
Invece di classificare immediatamente un'immagine:
Satellite image
│
▼
Classifier
│
▼
urban / forest / water / ...possiamo produrre prima una rappresentazione generale:
Satellite image
│
▼
Foundation model
│
▼
Embedding
│
├── similarity search
├── clustering
├── anomaly detection
├── classification
├── segmentation
└── downstream fine tuningQuesto è uno dei motivi per cui i geospatial foundation model sono così interessanti.
La rappresentazione può essere riutilizzata in task differenti senza ricominciare ogni volta dal dato grezzo.
27. Location embeddings con ArcGIS API for Python
L'ArcGIS API for Python espone anche una classe Embeddings nel modulo arcgis.learn.
Fra i tipi supportati troviamo:
image
text
locationConcettualmente:
from arcgis.learn import Embeddings
model = Embeddings(
dataset_type="location"
)
result = model.get(
input_path,
return_embeddings=True
)Per i location embedding la documentazione ArcGIS API for Python indica come backbone predefinito una variante di SatCLIP addestrata su Sentinel-2.
Qui il concetto è differente dal geodemographic embedding.
Non stiamo comprimendo migliaia di variabili Census, ma stiamo costruendo una rappresentazione geografica utilizzando un modello addestrato a catturare struttura e contesto spaziale.
28. "Embedding GIS" non identifica quindi una sola tecnologia
È importante evitare di utilizzare il termine embedding come se identificasse un'unica rappresentazione universale.
Possiamo avere:
Text embedding
Image embedding
Location embedding
Geodemographic embedding
POI embedding
Network embedding
Trajectory embedding
Graph embedding
Multimodal embeddingDue vettori della stessa dimensione prodotti da modelli differenti non appartengono necessariamente allo stesso spazio semantico e non sono automaticamente confrontabili.
Se:
E₁(x) ∈ R²⁵⁶
E₂(x) ∈ R²⁵⁶non significa:
cos(E₁(x), E₂(y))abbia un significato valido.
La compatibilità dipende dallo spazio latente costruito durante il training.
29. Model versioning diventa data governance
Da sviluppatore questo porta immediatamente a un problema architetturale.
Se memorizziamo embedding persistentemente, dobbiamo sapere quale modello li ha generati.
Un dataset production-ready dovrebbe quindi conservare informazioni come:
Embedding
EmbeddingModel
EmbeddingModelVersion
EmbeddingDimension
EmbeddingGeneratedAt
EmbeddingSourceVersionPerché:
model v1 embedding
≠
model v2 embeddinganche quando la dimensione è identica.
Aggiornare un modello può richiedere il ricalcolo dell'intero indice vettoriale.
30. Un esempio C#
La cosine similarity non richiede necessariamente Python.
Una semplice implementazione C# potrebbe essere:
static float CosineSimilarity(
ReadOnlySpan<float> a,
ReadOnlySpan<float> b)
{
if (a.Length != b.Length)
throw new ArgumentException(
"Vectors must have the same dimension.");
double dot = 0;
double normA = 0;
double normB = 0;
for (int i = 0; i < a.Length; i++)
{
dot += a[i] * b[i];
normA += a[i] * a[i];
normB += b[i] * b[i];
}
if (normA == 0 || normB == 0)
return 0;
return (float)(
dot /
(Math.Sqrt(normA) * Math.Sqrt(normB))
);
}Un'applicazione .NET potrebbe quindi leggere gli embedding provenienti da ArcGIS, da un database vettoriale o da un modello AI ed effettuare direttamente ranking e filtering.
31. Decodificare il formato Float32 ArcGIS in C#
Dal momento che il BLOB ArcGIS contiene float32 little-endian contigui, il concetto lato .NET è:
static float[] DecodeEmbedding(
byte[] bytes,
int expectedDimension)
{
if (bytes.Length != expectedDimension * sizeof(float))
throw new InvalidOperationException(
"Unexpected embedding payload size.");
var result = new float[expectedDimension];
for (int i = 0; i < expectedDimension; i++)
{
result[i] = BitConverter.ToSingle(
bytes,
i * sizeof(float)
);
}
return result;
}Su una piattaforma little-endian come l'architettura Windows/x64 normalmente utilizzata da ArcGIS Pro, il mapping è diretto; in codice interoperabile è comunque opportuno trattare esplicitamente l'endianness prevista dal formato.
32. Vector database e GIS
Un database vettoriale memorizza oggetti del tipo:
ID
metadata
embeddingUn database GIS tradizionale memorizza:
ID
geometry
attributesL'evoluzione naturale è:
ID
geometry
attributes
embeddingcon:
spatial index
+
attribute indexes
+
vector indexQuesto modello rende possibili query ibride estremamente potenti.
33. Hybrid Spatial-Vector Search
Consideriamo una richiesta:
Trova entro 30 km da questa posizione aree che assomigliano a questo distretto commerciale.
La pipeline potrebbe essere:
Query
│
┌─────────────┴─────────────┐
│ │
▼ ▼
Geographic filter Query embedding
│ │
▼ ▼
Spatial Index Vector Index
│ │
└─────────────┬─────────────┘
▼
Candidate set
│
▼
similarity rank
│
▼
ResultsQuesto tipo di ricerca combina contemporaneamente:
- geografia;
- semantica;
- attributi;
- AI.
34. GeoRAG: Retrieval Augmented Generation geografico
Il passaggio successivo è collegare questo sistema a un LLM.
In un normale RAG:
User question
│
▼
Text embedding
│
▼
Vector search
│
▼
Documents
│
▼
LLMIn un possibile GeoRAG:
User
│
│ "Trova aree industriali simili a questa
│ entro 50 km e spiegami le differenze"
│
▼
LLM / Agent
│
├────────► intent extraction
│
├────────► spatial query
│
├────────► vector similarity
│
├────────► feature attributes
│
├────────► imagery embeddings
│
└────────► external/context data
│
▼
ArcGIS / Spatial DB
│
▼
Feature collection
│
▼
LLM
│
▼
explanation + map resultsL'LLM non deve inventare il risultato geografico.
Il GIS rimane il motore deterministico per geometria, coordinate, overlay, network analysis e spatial constraints.
Il motore vettoriale aggiunge invece il retrieval semantico.
L'LLM orchestra e interpreta i risultati.
35. Geometry, semantics e language reasoning
Possiamo vedere l'architettura come tre livelli.
┌────────────────────────────────────┐
│ LANGUAGE / REASONING │
│ LLM │
├────────────────────────────────────┤
│ SEMANTIC RETRIEVAL │
│ Embeddings / Vector Search / ANN │
├────────────────────────────────────┤
│ SPATIAL COMPUTATION │
│ Geometry / Topology / CRS / GIS │
└────────────────────────────────────┘Ognuno risolve un problema differente.
Il GIS calcola.
Gli embedding rappresentano e recuperano similarità.
L'LLM ragiona sull'intento e costruisce una risposta comprensibile.
36. Embedding e Tobler's First Law
Nel GIS è quasi inevitabile collegare questo argomento alla nota prima legge della geografia di Waldo Tobler:
Things that are near tend to be more related than things that are far apart.
Gli embedding introducono però una nuova dimensione.
Due fenomeni possono essere:
far in geographic space
but
near in embedding spaceLa prossimità geografica rimane fondamentale, ma non è più l'unico concetto di vicinanza disponibile.
Possiamo parlare di:
- prossimità geografica;
- prossimità topologica;
- prossimità temporale;
- prossimità semantica.
37. Attenzione alla spatial autocorrelation
Gli embedding geografici introducono anche problemi statistici specifici.
Se il training set viene suddiviso casualmente:
80% train
20% testfeature geograficamente vicine possono finire nei due insiemi.
A causa della spatial autocorrelation, questo può produrre valutazioni eccessivamente ottimistiche.
In molti problemi GeoAI è preferibile valutare anche strategie come:
- spatial block cross-validation;
- geographic holdout;
- leave-one-region-out;
- temporal-spatial split.
Un embedding sofisticato non elimina le regole fondamentali della statistica spaziale.
38. Similarità non significa causalità
Un altro punto essenziale:
embedding similarity
≠
causal relationshipDue territori possono avere embedding simili perché condividono numerosi pattern statistici senza che esista alcuna relazione causale diretta.
Gli embedding sono eccellenti strumenti per:
- retrieval;
- clustering;
- feature enrichment;
- anomaly detection;
- candidate generation;
- prediction.
Non costituiscono automaticamente una spiegazione causale.
39. Distribution shift
Un modello di embedding apprende dalla distribuzione osservata durante il training.
Se viene applicato a:
- un'altra nazione;
- un altro periodo storico;
- sensori differenti;
- urbanizzazioni radicalmente differenti;
- dati con diversa qualità;
potrebbe verificarsi distribution shift.
Questo è particolarmente importante in ambito geospaziale, dove le distribuzioni cambiano nello spazio e nel tempo.
40. Un embedding USA non è automaticamente un embedding europeo
Gli USA Geodemographic Embeddings sono stati progettati utilizzando dataset e geografie statunitensi.
Il principio è generale, ma il modello non deve essere interpretato come rappresentazione universale di qualsiasi territorio.
Per costruire un equivalente europeo o italiano sarebbe necessario definire un insieme coerente di sorgenti, ad esempio:
ISTAT
Copernicus
Sentinel
OpenStreetMap
land cover
meteorological data
mobility
POI
cadastral/urban information
socioeconomic indicators
...e addestrare una rappresentazione coerente con il dominio geografico di interesse.
41. Un possibile "Italian Place Embedding"
Immaginiamo, puramente a livello architetturale:
ISTAT ──────────────────────┐
│
Sentinel / Copernicus ──────┤
│
OpenStreetMap ───────────────┤
├──► Multi-view encoder
POI ────────────────────────┤
│
Mobility ───────────────────┤
│
Climate / Environment ──────┘
│
▼
PLACE VECTOR
R^dOgni cella territoriale italiana avrebbe una rappresentazione numerica general-purpose.
A quel punto potremmo eseguire query come:
Quali aree italiane presentano un profilo urbano, infrastrutturale e socioeconomico simile a questo quartiere?
senza costruire manualmente decine di filtri.
42. Verso il "place foundation model"
Il passo successivo rispetto al semplice embedding è un modello capace di comprendere in maniera multimodale il concetto di luogo.
PLACE FOUNDATION MODEL
┌──────────────┬──────────────┬──────────────┐
│ │ │ │
▼ ▼ ▼ ▼
Imagery Geometry Network Text
│ │ │ │
└──────────────┼──────────────┼──────────────┘
│
▼
Shared latent space
│
┌──────────────┼──────────────┐
▼ ▼ ▼
Retrieval Prediction ReasoningIn prospettiva potremmo non avere soltanto:
text → vectorma:
place → vectore magari:
text ↔ place ↔ imageall'interno di uno spazio multimodale condiviso.
43. Dal GIS basato sugli attributi al GIS basato sulle rappresentazioni
Per decenni una feature GIS è stata concettualmente:
Feature =
Geometry
+
AttributesCon il GeoAI possiamo iniziare a pensare:
Feature =
Geometry
+
Attributes
+
Learned RepresentationIl cambiamento può sembrare piccolo, ma è architetturalmente profondo.
La geometria rappresenta dove.
Gli attributi rappresentano ciò che sappiamo esplicitamente.
L'embedding rappresenta una sintesi latente di ciò che il modello ha appreso.
44. Gli embedding non sostituiranno il GIS classico
Gli embedding non eliminano:
- buffer;
- overlay;
- spatial join;
- network analysis;
- coordinate systems;
- geocoding;
- topologia;
- spatial statistics.
Se devo sapere se due poligoni si intersecano:
ST_Intersects(A, B)rimane la soluzione corretta.
Non avrebbe senso chiedere a un embedding di approssimare un predicato geometrico deterministico.
Ma se la domanda è:
quali territori presentano un contesto simile a questo?
allora entriamo esattamente nel dominio degli embedding.
45. La vera evoluzione è l'integrazione
Il GIS futuro probabilmente non sarà:
GIS
oppure
AIma:
GIS PLATFORM
Geometry ─────── Spatial Engine
│
Attributes ───── Data Engine
│
Embeddings ───── Vector Engine
│
Models ───────── GeoAI Engine
│
LLM ──────────── Agent / Reasoning
│
▼
Geographic IntelligenceEd è probabilmente qui che il concetto di GeoAI diventa realmente interessante per chi sviluppa sistemi GIS.
Conclusioni
Gli embedding stanno introducendo nel GIS un nuovo modo di rappresentare l'informazione geografica.
Non descrivono semplicemente dove si trova un oggetto e non sostituiscono gli attributi tradizionali.
Costruiscono invece uno spazio latente nel quale luoghi, immagini e feature possono essere confrontati in funzione delle caratteristiche apprese da un modello.
La distinzione fondamentale è:
Geographic distance
≠
Semantic distancee le due possono essere utilizzate contemporaneamente.
Spatial Index
+
Vector Index
+
GIS Attributes
+
Foundation Models
+
LLM / Agentsaprono la strada a sistemi capaci non soltanto di rispondere:
Dove si trova?
ma anche:
A quali luoghi assomiglia?
e, in prospettiva:
Quali caratteristiche rendono questo luogo simile ad altri, quali differenze sono geograficamente rilevanti e come posso utilizzarle per prendere una decisione?
Per chi lavora nel GIS questo è probabilmente uno dei passaggi più interessanti dell'attuale evoluzione GeoAI: la feature geografica non è più soltanto una geometria con attributi. Può diventare una rappresentazione appresa.
Riferimenti tecnici
- Esri — Concepts of USA Geodemographic Embeddings
- Esri — Use the USA Geodemographic Embeddings
- ArcGIS Pro — Embeddings Based Analysis toolset
- ArcGIS Pro — Find Similar Features Using Embeddings
- ArcGIS Pro — How Find Similar Features Using Embeddings works
- ArcGIS Pro — Merge Embeddings
- ArcGIS Pro — Embeddings in BLOB fields
- ArcGIS API for Python — arcgis.learn.Embeddings
Nota: gli USA Geodemographic Embeddings 2026 citati nell'articolo sono un modello/dataset specifico dell'ecosistema ArcGIS e, al momento della stesura, Esri li indica come Beta. Gli esempi architetturali relativi a place embeddings, GeoRAG e sistemi multimodali descrivono invece pattern generali e possibili evoluzioni tecnologiche, non uno specifico prodotto ArcGIS.
Nessun commento:
Posta un commento