ga.ia

Project Overview

ga.ia is a demonstration platform for intelligent monitoring of landslide risk and structural instability affecting electrical transmission towers.

The project combines:

• IoT data simulation
• Machine learning–based anomaly detection
• Blockchain persistence and verification
• Agent API services
• Operational dashboard visualization

The objective is to provide operators with a synthetic, explainable, and verifiable view of monitored asset risk, enhanced by AI-generated explanations, reports, and operational recommendations.

Main Components

The project is organized into four functional areas:

• backend/ — dataset generation, LSTM autoencoder training, and real-time anomaly simulation.
• contracts/ — Solidity smart contracts, Foundry tests, and deployment scripts.
• agent/ — Express API exposing operational data, network status, and AI capabilities.
• frontend/ — React/Vite dashboard for monitoring, visualization, reporting, and operator interaction.

Machine Learning Backend

The Python backend manages sensor simulation and anomaly detection over transmission tower telemetry.

Dataset Generation

backend/dataset_generation.py generates two CSV datasets:

• backend/train_dataset.csv → normal operating conditions used for training.
• backend/test_dataset.csv → testing dataset containing simulated anomalies.

Generated variables include:

• Timestamp
• Tower identifier (pylon_id)
• Rainfall (rain_mm)
• Soil humidity (umidity_pct)
• Air temperature (temp_air)
• Soil temperature (temp_soil)
• Tower inclination on X axis (tilt_x)
• Tower inclination on Y axis (tilt_y)

The testing dataset injects an anomalous scenario consisting of:

• Heavy rainfall
• Increased soil humidity
• Progressive displacement of tower inclination along the Y axis

Model Training

backend/model_training.py trains an unsupervised LSTM autoencoder.

Main functionalities

• Computes delta_x and delta_y relative to the tower structural baseline
• Selects relevant numerical features
• Applies scaling using RobustScaler
• Creates temporal windows with a 24-hour lookback
• Trains an LSTM autoencoder to reconstruct normal sequences
• Computes reconstruction MAE
• Uses P95 and P99 percentiles to derive risk thresholds
• Stores trained artifacts and configuration

Real-Time Detection

backend/realtime_detection.py simulates continuous IoT data ingestion.

Main functionalities:

• Maintains a temporal buffer
• Waits for lookback completion
• Computes engineered features
• Applies scaling and model reshaping
• Executes inference
• Computes anomaly index and reconstruction MAE
• Assigns operational status:

Solidity Smart Contract

Main contract:

contracts/src/GaIA.sol

Interface:

contracts/src/IGaIA.sol

Data Model

Each risk event is represented as:

struct RiskData {  
uint256 id;  
uint256 idTruss;  
uint256 risk;  
bool consumed;
}

• id → unique event identifier
• idTruss → monitored tower identifier
• risk → associated risk score
• consumed → indicates whether the event has already been processed

Permissions

Ownership model:

• Deployer becomes owner
• Only owner can insert or update data
• Ownership transfer supported via transferOwnership

Custom Errors

• UnauthorizedAccess
• InvalidOwner
• DataAlreadyExists
• DataNotFound
• DataNotValid

Data Insertion

Supported operations:

• addData
• addMultipleData
• upsertData
• upsertMultipleData

Validation:

• id != 0
• idTruss != 0

Data Update

Supported operations:

• updateData
• updateMultipleData

Updates maintain consistency of tower indexes.

If an event changes tower assignment or transitions from active to consumed, it is removed from the previous open-event index.

Data Retrieval

Available functions:

• getDataById
• dataExists
• getAssetByTruss
• getAssetByTrussRange
• getDataByTrussCount

Consumed Flag Logic

The consumed flag separates active events from processed events.

• consumed == false → included in tower indexes
• consumed == true → remains stored but excluded from open-event queries

Events are not automatically consumed on read, they need to be updated.

Deployment and Networks

Deployment is managed through Foundry.

Agent API

The agent/ module exposes an Express server on port 3001.

• Dashboard API
• Mock and on-chain operation modes
• Solana health monitoring
• Risk exposure endpoints
• OpenAI integration

Data Modes

Supported modes:

• mock
• onchain
• mock_fallback

Available Endpoints

GET  /api/status
POST /api/mode
GET  /api/towers
GET  /api/summarize
POST /api/explain
POST /api/report
POST /api/chat

AI Features

• Explain risk causes
• Generate incident reports
• Suggest operational priorities
• Answer operator questions
• Summarize critical asset conditions

Without API access, AI services operate in offline mode.

Frontend Dashboard

The frontend is a React/Vite operational dashboard.

• Risk overview
• Critical asset count
• Average risk probability
• Risk distribution
• Monitored tower list
• Interactive Italy map
• Asset details
• Trend and metadata views
• AI quick actions
• Operational chat
• Mock / on-chain toggle

Each class includes dedicated labels, colors, and indicators.

Expected Operational Flow

1. Sensors collect environmental and structural data.
2. The ML backend computes anomaly and risk indicators.
3. Backend services publish RiskData events to the smart contract.
4. The contract stores and indexes unresolved events.
5. The agent exposes data and AI capabilities.
6. The dashboard displays operational priorities and reports.
7. Operators manage and mark events as consumed.