GIS

Overview

GIS, short for geographic information system, is the combination of software, data and methods used to store, analyze and display information tied to places on Earth. Every record in a GIS has a location, expressed as a point, a line, an area or a grid cell. This lets you ask questions that ordinary spreadsheets cannot answer easily: what lies within 500 meters of this school, which parcels sit inside this flood zone, how tall are the buildings on this block.

At its core, a GIS is a set of tables with a special column for geometry, plus a toolbox of spatial operations and a way to draw maps. That is why GIS and tabular machine learning fit together so well. Attributes such as land use, building height and ownership are ordinary columns. The geometry column adds neighbors, distances, overlaps and containment as new features. For urban work such as parcels, zoning and building geometry, GIS is the standard foundation.

What it is

A geographic information system has four parts that work together.

• Data: layers of spatial features and rasters, each with attributes.
• Storage: files or databases that hold the layers and keep them consistent.
• Analysis: operations that combine and measure layers, such as buffer, intersect, join and overlay.
• Cartography: the design and output of maps, from quick views to print products and web maps.

Layers

A GIS organizes data in layers. One layer might hold roads, another parcels, another building footprints, another elevation. Layers stack on top of each other like transparent sheets on a light table. Because they share the same coordinate system, features line up, and you can ask questions across layers.

An everyday analogy

Think of a tracing-paper atlas. Each sheet shows one theme: streets on one, rivers on another, schools on a third. Stack the sheets and hold them to the light, and you can see which school sits next to a river. A GIS does this stacking digitally, and it also lets you measure, count and compute across the sheets instead of just looking.

Vector and raster

There are two main data models.

• Vector data uses geometry: points for wells or stores, lines for roads or pipes, polygons for parcels or districts. Each feature has attributes in a table row.
• Raster data uses a grid of cells, each with a value. Satellite images, elevation models and land cover maps are rasters.

Vector is best for discrete things with clear edges. Raster is best for continuous fields such as temperature or elevation.

Common attributes

A parcel layer, for instance, may carry an identifier, a land use code, a lot area, a zoning district and the number of floors of the building on it. A building layer may carry a footprint polygon, a height and a year built. A zoning layer may carry district boundaries with rules for use, height limits and density.

Where it came from

The idea of overlaying maps by theme is old. Early thematic mapping showed disease and trade patterns on maps. In the twentieth century, planners overlaid transparent sheets by hand to find suitable land. With computers in the 1960s, the first digital geographic systems appeared in government work on land inventories. Through the following decades, desktop software, relational databases and standard file formats made GIS common in cities, utilities, environmental agencies and business.

Several developments shaped the modern field.

• Satellite imagery and the global positioning system made it easy to capture locations and imagery at scale.
• Relational databases gained spatial extensions, so spatial queries could be written in SQL.
• Open standards for exchanging features and for web map services made data sharing easier.
• Open source tools lowered the cost of entry and built a large community.
• Web maps and mobile devices brought maps to everyday users.
• Cloud storage and tiling schemes made huge datasets practical to serve.
• Machine learning began to extract features such as buildings and roads from imagery.

The field now overlaps with remote sensing, surveying, urban planning, logistics, public health, agriculture and environmental science.

How it works

Step 1: represent the world with coordinates

Every location needs a coordinate system. The Earth is roughly a slightly flattened sphere, and a map is flat, so a GIS has to translate between the two.

• A geographic coordinate system uses latitude and longitude on a model of the Earth.
• A projected coordinate system turns those angles into flat x and y values in meters or feet, using a map projection.

Every projection distorts something: area, shape, distance or direction. Choosing one is a trade-off. A projection that preserves area is good for comparing land sizes. One that preserves shape is good for navigation.

An analogy: peeling an orange and flattening the peel. You cannot do it without stretching or tearing. Different projections choose different ways to tear and stretch.

Step 2: store features and attributes

Features are stored with a geometry and a set of attributes. Common storage choices include:

• Simple file formats, such as shapefile-like sets, GeoJSON text files, or geopackage-style single-file databases.
• Spatial databases, where a geometry column sits beside normal columns and has a spatial index.
• Raster files and cloud-friendly tiled rasters.
• Cloud object storage with columnar formats that include geometry.

Step 3: index for speed

Spatial queries would be slow if every feature had to be checked. Spatial indexes, such as R-trees or grid-based schemes, quickly find features near a place. It is like a library with sections, shelves and labels. You do not read every spine to find a book.

Step 4: query and analyze

A GIS offers a rich set of spatial operations.

Step 5: derive new attributes

Spatial operations create new columns. A building can get the zoning code of the parcel it sits on, its distance to the nearest park, the number of neighbors within 100 meters, its floor area ratio, its shape compactness, or its sun exposure. Many of the most useful variables in urban analysis are derived this way.

Step 6: visualize

A map style assigns colors, symbols and labels to features by attribute. A choropleth map colors areas by a value. A heat map shows density. A 3D view extrudes buildings by height. Good cartography uses clear legends, sensible color scales and an honest projection.

Step 7: share

Results are shared as static maps, interactive web maps, data downloads or services that other software can call. Web maps often use tiles: small image or vector pieces that load as you pan and zoom.

A short SQL example

Spatial databases let you express GIS operations in SQL. The following example uses a PostGIS-style syntax with placeholder table names.

-- Which parcels fall inside which zoning district, and what is the lot area?
SELECT p.parcel_id,
       z.district_code,
       ST_Area(p.geom) AS lot_area_m2
FROM parcels AS p
JOIN zoning_districts AS z
  ON ST_Within(ST_Centroid(p.geom), z.geom);

-- Buildings within 200 meters of a transit stop
SELECT b.building_id, s.stop_id,
       ST_Distance(b.geom, s.geom) AS dist_m
FROM buildings AS b
JOIN transit_stops AS s
  ON ST_DWithin(b.geom, s.geom, 200);

Both queries assume that the geometries use a projected coordinate system in meters. If they used latitude and longitude, distances would be in degrees and the results would be misleading.

A short Python example

import geopandas as gpd

parcels = gpd.read_file("data/parcels.gpkg").to_crs(epsg=3857)
zones = gpd.read_file("data/zoning.gpkg").to_crs(epsg=3857)

parcels["lot_area_m2"] = parcels.geometry.area
parcels["centroid"] = parcels.geometry.centroid

joined = gpd.sjoin(
    parcels.set_geometry("centroid"),
    zones[["district_code", "geometry"]],
    how="left",
    predicate="within",
)
print(joined[["parcel_id", "district_code", "lot_area_m2"]].head())

The reprojection step comes first so that area is computed in a consistent unit. A projection suited to the local area is a better choice than a global web projection when accurate areas matter.

Key concepts and terms

A worked example

Suppose a city analyst wants to find residential parcels that are close to a transit stop, sit in a zone with a low height limit and hold buildings far below the allowed height. This could point to places where new housing might fit.

Data

Plan

1. Put all layers in the same projected coordinate system in meters.
2. Check validity of geometries and repair broken polygons.
3. Join each parcel to its zoning district by location.
4. Join buildings to parcels by key or by location.
5. Compute distance from each parcel to the nearest transit stop.
6. Compute the gap between allowed height and actual height.
7. Filter and rank.

SQL

WITH parcel_zone AS (
  SELECT p.parcel_id, p.geom, z.district_code, z.max_height_m
  FROM parcels p
  JOIN zoning_districts z
    ON ST_Within(ST_PointOnSurface(p.geom), z.geom)
  WHERE p.land_use = 'residential'
),
parcel_bldg AS (
  SELECT pz.parcel_id, pz.geom, pz.district_code, pz.max_height_m,
         COALESCE(MAX(b.height_m), 0) AS built_height_m
  FROM parcel_zone pz
  LEFT JOIN buildings b ON b.parcel_id = pz.parcel_id
  GROUP BY pz.parcel_id, pz.geom, pz.district_code, pz.max_height_m
)
SELECT pb.parcel_id,
       pb.district_code,
       pb.max_height_m - pb.built_height_m AS height_gap_m,
       (SELECT MIN(ST_Distance(pb.geom, s.geom)) FROM transit_stops s) AS dist_to_stop_m
FROM parcel_bldg pb
WHERE pb.max_height_m - pb.built_height_m >= 10
ORDER BY dist_to_stop_m ASC
LIMIT 50;

Reading the result

Imagine the output lists parcels with a height gap of 10 meters or more and a short distance to a stop. Those are candidates. A GIS analyst would then map them, check the underlying data for errors, and look at other constraints that are not in the tables, such as lot width, historic status or utility capacity. The GIS finds candidates. It does not replace local knowledge or legal review.

Quality checks

• Do all parcels get exactly one district? Parcels that straddle boundaries may match several or none.
• Are building heights in the same unit as the height limits?
• Are there parcels with no building because the data is missing or because the lot is vacant?
• Are the geometries valid, with no self-intersections?
• Is the stop layer complete?

What the example teaches

Most steps are table work: joins, filters and aggregates. The spatial part is a small number of operations that create new columns from geometry. That is the point at which tabular machine learning can take over.

Strengths and limitations

Strengths

• Turns location into a first-class variable that can be joined, measured and mapped.
• Combines many data sources through a common coordinate frame.
• Rich spatial operations that are hard to emulate in plain spreadsheets.
• Mature standards, formats and tools, both open and commercial.
• Excellent communication: a map conveys patterns that a table hides.
• Scales from a laptop project to a national data service.
• Integrates with databases, scripting languages and web services.

Limitations

• Data quality is variable. Boundaries, heights and land use codes can be out of date or inconsistent.
• Coordinate system errors are common and silent. A layer in the wrong CRS can appear shifted or distorted.
• Scale and generalization: a layer made for a coarse map is not suitable for detailed analysis.
• Boundaries of zones, parcels and buildings change over time, so temporal versions matter.
• Edge effects: features near the border of a study area have missing neighbors.
• The modifiable areal unit problem: results can change with how areas are drawn.
• Spatial autocorrelation: nearby things tend to be similar, which breaks the assumptions of many statistical tests.
• Privacy: location data can identify people or sensitive sites.
• Learning curve: concepts like projections and topology take time.

How it compares with alternatives

The sensible pattern is to use GIS to build spatial features and a tabular model to learn from them. For 3D capture, see NeRF and Gaussian splatting, which can supply geometry that GIS then manages.

Role in tabular foundation models

GIS and tabular foundation models meet at the table. A GIS layer is an attribute table with a geometry column. After spatial operations, the geometry turns into ordinary numbers, and those numbers feed a model that learns from rows and columns.

Geometry becomes columns

Spatial operations turn shape and place into features: area, perimeter, compactness, height, distance to the nearest road or park, count of neighbors within a radius, share of neighbors with a given land use, zoning code from a spatial join, elevation from a raster, slope, and so on. Once computed, these are plain numeric and categorical columns. A tabular model does not need to know that a column came from a map. See the architecture page for how a tabular model reads mixed columns.

Mixed types and messy columns

Parcel and zoning tables are typical raw tables. They mix numbers (lot area, height), codes (zoning district, land use), dates (year built), free text (owner or address notes) and identifiers. Many columns have cryptic names, abbreviations or no useful names at all. A foundation model that learns from raw tables must interpret columns from their values, not their headings. Tabular models such as TabPFN, TabICL and FT-Transformer show how mixed types can be handled in one network.

Missing values

Spatial data is full of gaps: buildings without a recorded height, parcels without a year built, units that were never surveyed. Missing values are often not random. Newer buildings may have more complete records than older ones. A tabular model can handle gaps with masking and imputation, as in masked cell modeling, imputation networks and denoising autoencoders. Spatial neighbors give extra clues: a missing height can be estimated from nearby buildings of the same type.

Pre-training on synthetic and real tables

Tabular foundation models are pre-trained on a very large number of tables, often generated synthetically from random causal structures, and may also use real tables. Spatial tables show why this matters. They contain strong structure, such as spatial smoothness and hierarchical codes, which a pre-trained model can recognize without being told that the columns are geographic. The model can then learn in context from a few labeled rows. The details of how this site's model is built are on /model/research, and its measured results are on /model/benchmarks.

In-context learning for local tasks

Planning tasks are often small and local: a few hundred labeled parcels in one district. In-context learning suits this setting. You supply the labeled rows as context and the model predicts for new rows in one pass, without training a model for each district. This is the pattern used by in-context tabular models.

Semantic and sector classification

Classifying what a parcel or building is used for, or what kind of table you hold, is a semantic task. A land use field with codes like "R6" or "C2-4" has meaning only through its relation to other columns and its value patterns. See semantic sector heads for how a model can assign meaning to a table or column from content alone.

Anomaly detection in spatial tables

Real GIS data has errors: a building 900 meters tall, a lot area of zero, a parcel assigned to the wrong district, a duplicate footprint. Tabular anomaly detection can flag rows that do not fit, using both attributes and derived spatial features. Typical anomalies in urban data include impossible heights, extreme ratios of building area to lot area, and parcels whose neighbors all differ.

Continual learning

Zoning rules and building stocks change over time. A model trained on last year's data may drift. Continual learning methods keep a model current without forgetting old patterns, using replay or regularization. See experience replay and EWC.

Urban intelligence and digital twins

Cities build digital twins that join GIS layers, sensors and models. The tabular part of such systems, with parcels, permits, utility records and sensor readings, is where tabular models do the learning. See digital twins, smart city and urban intelligence for related topics.

Spatial pitfalls for models

• Spatial leakage: if you randomly split rows into train and test, neighbors end up on both sides and the test score looks too good. Split by area or by block instead.
• Autocorrelation: nearby rows are not independent, so effective sample size is smaller than the row count.
• Scale mismatch: features computed at different radii can mean different things.
• Coordinate columns: raw latitude and longitude as numeric features can help or can cause overfitting. Distances and region codes are often safer.

What not to claim

A tabular foundation model does not replace a GIS. It does not draw maps or compute geometric operations. It learns from the columns that a GIS prepares. Equally, a GIS does not learn from data by itself. The two tools work best in sequence.

Practical guidance and best practices

Data handling

• Record the CRS of every layer and convert to one suitable projected system before measuring.
• Check and repair invalid geometries before any overlay.
• Keep the original data untouched and do work on copies.
• Keep metadata: source, date, resolution and known issues.
• Use stable identifiers so that layers can be joined without geometry when possible.
• Version your data. Zoning and parcels change.

Analysis

• Prefer attribute joins by key over spatial joins when a key exists. They are faster and exact.
• Use centroid or point-on-surface tests with care. A centroid of a curved shape can fall outside it.
• Choose buffer distances with a reason, and test sensitivity to them.
• Compute area and length in an appropriate projected system, not in degrees.
• Handle edge effects by extending the study area past the area of interest.
• Document each step so it can be repeated.

Performance

• Build spatial indexes on geometry columns.
• Filter early with bounding boxes.
• Simplify geometries for display, not for analysis.
• Use tiling and caching for web delivery.
• Store large data in columnar formats where available.

Cartography

• Pick a color scale that matches the data: sequential for amounts, diverging for deviation, categorical for classes.
• Normalize counts by area or population before mapping them.
• Add a legend, scale and source note.
• Check how the map looks for people with color vision differences.

Modeling with spatial features

• Derive features with GIS, then join them into a flat table.
• Keep a record of the radius and method for each feature.
• Split data spatially for honest validation.
• Check for leakage from identifiers or from fields created after the outcome.
• Use anomaly checks on the final table before training.

Governance and privacy

• Treat location data as sensitive when it can reveal individuals, homes or protected sites.
• Aggregate or blur coordinates when sharing.
• Respect data licenses and terms of use.

Testing

• Test with a small known area where you can verify results by eye.
• Compare computed areas and counts with an independent source.
• Add automated checks for CRS, validity and expected ranges.

A quick checklist before you publish a map or a dataset

• State the source, the date and the coordinate system.
• State known gaps and the scale at which the data is reliable.
• Check that every layer has a clear license.
• Test the result on a small area you can verify by eye.
• Run basic validity and range checks automatically.
• Remove or generalize sensitive locations.
• Keep a changelog so users know when boundaries or codes changed.

Typical data sources for urban work

Common mistakes

• Mixing layers with different coordinate systems.
• Measuring distance or area in degrees.
• Ignoring invalid geometries, which silently break overlays.
• Joining spatially when a reliable key exists.
• Using centroids that fall outside the shape.
• Mapping raw counts instead of rates, which just shows where more people live.
• Random train and test splits on spatial data, causing leakage.
• Treating old boundaries as current.
• Over-trusting attribute data without checking for outliers and missing values.
• Using a web map projection to compare areas.
• Publishing precise coordinates of sensitive locations.
• Skipping metadata and then being unable to explain the result.

Frequently asked questions

What does GIS stand for?

GIS stands for geographic information system. It is a combination of software, data and methods for storing, analyzing and mapping information that is tied to locations on the Earth, such as parcels, roads, buildings and zoning districts.

What is the difference between vector and raster data?

Vector data stores discrete features as points, lines and polygons with attribute rows, which suits things with clear edges such as parcels and roads. Raster data stores a grid of cells with values, which suits continuous fields such as elevation or temperature and imagery from satellites.

Why does the coordinate reference system matter so much?

Coordinates only mean something relative to a reference system. If two layers use different systems, they will not line up, and measurements in degrees will not match real distances. Choosing and checking the system is the first step in any careful analysis.

Can I do GIS in a database?

Yes. Spatial extensions let a database store geometry, index it and run spatial functions in SQL. This is a common choice for large datasets and production services, with desktop or web tools used for display.

How does GIS relate to machine learning?

GIS prepares the spatial features that a model can learn from. Operations such as joins, buffers and distances turn shapes into numeric columns. A tabular model then reads those columns together with ordinary attributes. GIS does not learn from data by itself, and a model does not do geometry by itself.

What are parcels, zoning and building footprints?

A parcel is a legal lot of land. Zoning is the set of district rules for what can be built and used on parcels, such as use type, height and density. A building footprint is the outline of a building on the ground, often with a height attribute. Together they describe how land is divided, regulated and built up.

What is a spatial join?

A spatial join attaches attributes from one layer to another based on location rather than on a shared key. For example, each building can receive the zoning code of the district it lies in. It is powerful but slower and less exact than a key join, so use keys when you have them.

What is spatial leakage in model evaluation?

Spatial leakage happens when training and test rows are close neighbors. Because nearby places tend to be similar, the model appears to perform better than it will on truly new areas. Splitting by block, district or region gives a more honest estimate.

Do tabular foundation models understand maps?

Not directly. They read tables of numbers and categories. Maps become useful to them only after a GIS turns geometry into columns such as distance, area, height or neighbor counts. Once that is done, the model can use the columns like any other.

How accurate is GIS data?

It varies widely. Accuracy depends on the source, scale, date and method of capture. Building heights, land use codes and boundaries can contain errors or be out of date, so it pays to check metadata, compare with other sources and flag outliers before trusting a result.

Glossary

• Attribute table: The table of descriptive values attached to features.
• Buffer: A zone of fixed distance around a feature.
• CRS: Coordinate reference system, the rule for mapping coordinates to places.
• Choropleth: A map that colors areas by a value.
• Datum: A model of the Earth's shape used as a reference.
• Dissolve: Merging features that share an attribute value.
• Feature: A single mapped object with geometry and attributes.
• Footprint: The outline of a building on the ground.
• Geocoding: Converting an address to coordinates.
• Geometry: The shape of a feature as points, lines or polygons.
• Layer: A collection of features or a raster of one theme.
• Parcel: A legal unit of land.
• Projection: A method for drawing the curved Earth on a flat surface.
• Raster: A grid of cells with values.
• Spatial autocorrelation: The tendency of nearby places to be similar.
• Spatial index: A structure that speeds location queries.
• Spatial join: Joining by location instead of by key.
• Tile: A piece of a map served on demand.
• Topology: Rules about how shapes touch and connect.
• Vector: Data stored as geometric shapes.
• Zoning: Rules that govern land use and building size by district.

Summary

GIS stores places as layers of features with attributes, ties them together with a coordinate system, and offers operations such as buffer, intersect and spatial join to answer questions about location. It handles vector shapes and raster grids, scales from laptops to national services, and turns analysis into maps. Its main hazards are coordinate mistakes, uneven data quality, spatial dependence and privacy.

For tabular foundation models, GIS is the feature factory. Parcels, zoning and building geometry become columns of area, height, distance, neighbor counts and codes, and the model learns from those rows even when they contain mixed types, missing values and unlabeled columns. Split data by area to avoid leakage, check for anomalies, and keep the data current. For 3D capture that feeds spatial data, see NeRF and Gaussian splatting, and for the modeling side see the architecture, research and benchmarks pages.

Related

It belongs to Vision and multimodal in my stack, under Foundation models and applied ML. Others in the same group: