メニュー
Create maps and spatial visualizations for urban/regional data. Supports heatmaps, cluster maps, grid analysis, and interactive maps with Folium.
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
SOC 職業分類に基づく
Clean, preprocess and perform EDA on tabular data. Use when user asks to clean data, handle missing values, detect outliers, preprocess datasets, or perform exploratory data analysis.
Generate statistical charts and visualizations for ML projects. Supports scatter, bar, line, heatmap, radar charts, feature importance plots, and model evaluation charts.
Exploratory Data Analysis - generate data profiles, statistics, correlation analysis, and distribution visualizations. Use when user asks for EDA, data analysis, data profiling, or understanding data characteristics.
Perform feature selection, construction, transformation and code execution with self-correction. Use when preparing features for model training or improving model performance through feature optimization.
Train machine learning models with RAP retrieval and hyperparameter optimization. Use when user wants to train, predict, or build ML models.
Evaluate model performance with multi-stage verification. Use when user wants to validate, test, or evaluate ML models.
| name | geospatial-analysis |
| description | Create maps and spatial visualizations for urban/regional data. Supports heatmaps, cluster maps, grid analysis, and interactive maps with Folium. |
| license | MIT |
| compatibility | opencode |
| metadata | {"domain":"data-science","tasks":["maps","spatial-analysis","geo-visualization","folium"]} |
You are an expert in geospatial visualization and spatial analysis. Your goal is to help users create maps and analyze spatial patterns in their data.
Use this skill when:
Auto-detect common column names:
lat / latitude / Lat / Latitudelon / lng / longitude / Lon / Lngy / x (when clearly geographic)Visualize Shanghai grid data:
- Create heatmap of population density
- Show business facility distribution
- Generate interactive map with markers
- Identify hotspots in the data
Calculate distances between locations:
- Compute Haversine distance between city centers
- Find nearest metro station for each district
- Calculate coverage radius for facilities
Analyze population concentration:
- Calculate top 10% cities population share
- Identify high-density urban clusters
- Find population-weighted centers
from math import radians, sin, cos, sqrt, atan2
def haversine_distance(lat1, lon1, lat2, lon2):
"""Calculate great-circle distance between two points (km)"""
R = 6371 # Earth radius in km
lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
dlat = lat2 - lat1
dlon = lon2 - lon1
a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
c = 2 * atan2(sqrt(a), sqrt(1-a))
return R * c
# Usage
dist = haversine_distance(31.2304, 121.4737, 31.2304, 121.4737) # Shanghai to itself
from sklearn.cluster import KMeans, DBSCAN
import numpy as np
def spatial_kmeans(coordinates, n_clusters=5):
"""K-means clustering for geographic data"""
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
labels = kmeans.fit_predict(coordinates)
return labels, kmeans.cluster_centers_
def spatial_dbscan(coordinates, eps_km=1, min_samples=5):
"""DBSCAN clustering - finds dense regions"""
# Convert km to degrees (approximate)
eps_deg = eps_km / 111 # 1 degree ≈ 111 km
db = DBSCAN(eps=eps_deg, min_samples=min_samples, metric='euclidean')
labels = db.fit_predict(coordinates)
return labels
def population_concentration(df, pop_column, top_n=10):
"""Calculate population concentration ratio"""
sorted_data = df.sort_values(pop_column, ascending=False)
total = sorted_data[pop_column].sum()
top_n_sum = sorted_data[pop_column].head(top_n).sum()
concentration = {
'top_n_count': top_n,
'top_n_share': top_n_sum / total * 100,
'total_population': total,
'top_n_population': top_n_sum,
'gini_coefficient': calculate_gini(sorted_data[pop_column])
}
return concentration
def calculate_gini(values):
"""Calculate Gini coefficient for inequality"""
sorted_values = np.sort(values)
n = len(values)
cumsum = np.cumsum(sorted_values)
return (2 * np.sum((np.arange(1, n+1) * sorted_values)) - (n + 1) * np.sum(sorted_values)) / (n * np.sum(sorted_values))
def weighted_centroid(df, lat_col, lon_col, weight_col):
"""Calculate population-weighted center"""
total_weight = df[weight_col].sum()
center_lat = (df[lat_col] * df[weight_col]).sum() / total_weight
center_lon = (df[lon_col] * df[weight_col]).sum() / total_weight
return center_lat, center_lon
Provide: