First Agent Template
Enhance tasks with web search, flight info, currency conversion, time zones, and conversation
Second Run. Huge Gains.
Refined AdaptiveGESAL
is a custom NN with dynamic graph-based clustering (up to 30 nodes), trainable SVD layers (SVFLinear
), and temporal processing to capture engine degradation patterns over cycles.Here’s how our refined model performed after training and evaluation on the test set:
These results are a significant improvement over our first run (RMSE 85.03, MAE 73.95), demonstrating the effectiveness of temporal layers and preprocessing. However, the model still requires tuning to achieve competitiveness.
Industry-standard models on FD001 (e.g., CNN-LSTM, LSTM, or hybrid deep learning approaches) typically achieve:
class AdaptiveGESAL(nn.Module):
def __init__(self, input_dim=5, hidden_dim=128, num_nodes=30, distance_threshold=0.05, buffer_size=50):
super().__init__()
# Temporal layers
self.conv1d = nn.Conv1d(input_dim, hidden_dim, kernel_size=3, padding=1)
self.lstm = nn.LSTM(hidden_dim, hidden_dim, batch_first=True, num_layers=1)
# SVF layers
self.svf1 = SVFLinear(hidden_dim, hidden_dim)
self.svf2 = SVFLinear(hidden_dim, hidden_dim)
self.output_layer = nn.Linear(hidden_dim, 1) # RUL prediction
self.activation = nn.ReLU()
# Graph structure
self.device = device
initial_embedding = torch.zeros(input_dim, device=self.device)
initial_z_vectors = [self.svf1.z.clone().detach(), self.svf2.z.clone().detach()]
self.nodes = [Node(initial_embedding, initial_z_vectors)]
self.distance_threshold = distance_threshold
self.buffer = []
self.buffer_size = buffer_size
self.hidden_dim = hidden_dim
self.num_nodes = num_nodes
def compute_distance(self, emb1, emb2):```
This project explores Remaining Useful Life (RUL) prediction for turbofan engines using the NASA C-MAPSS FD001 dataset, implementing an innovative neural network model called AdaptiveGESAL. Unlike my previous work with language models, this setup focuses solely on a neural network (NN) with graph-based adaptation and SVD-based linear layers (no LLM), marking an awesome first attempt at this task!
AdaptiveGESAL
is a custom NN with dynamic graph-based clustering (up to 50 nodes) and trainable SVD layers (SVFLinear
) to adapt to engine degradation patterns.Here’s how our model performed in its initial run:
These results are OK for a first attempt, demonstrating that the model learned to cluster engines and predict RUL, but there’s significant room for improvement.
Industry-standard models on FD001 (e.g., CNN-LSTM, LSTM, or hybrid deep learning approaches) typically achieve:
Our model’s RMSE (85.03 cycles) highlights a gap, but this first run is a promising starting point. With tuning, we aim to close this gap and achieve competitive performance.
Here’s a visual summary of our progress, comparing AdaptiveGESAL
’s performance to industry standards:
The visualization shows:
This is an awesome first attempt, but the results need tuning to improve competitiveness. Planned improvements include:
distance_threshold
, learning rates).Stay tuned for updates as we refine AdaptiveGESAL
to match or exceed industry standards!
Check out the full code and notebook on GitHub: AI-Adaptive-Learning-GESAL
Working on some tweaks but here are some earlier training logs.
I’ve captured the latest GESAL training logs for my engine/turbine dataset, showing real-time adaptation in action. Using meta-llama/Llama-3.2-1B
on Ubuntu 24.04 (4060Ti GPU, 16GB VRAM; Xeon, 32 cores; 256GB RAM) with InfluxDB 3 Core, the logs detail:
flight_hours
, exhaust_temp
, and wear
Note: The attached image shows logs from my GESAL-Training.ipynb
notebook, running on February 26, 2025.
@wassemgtk — Thank you for your brilliant work on Graph-Enhanced Singular Adaptive Learning (GESAL) and for releasing the code and white paper on GitHub. Your framework’s innovative approach—leveraging Singular Value Factorization (SVF), graph memory, and reinforcement learning (RL) for real-time LLM adaptation—is truly impressive, efficient, and fast. I’ve adapted GESAL for synthetic engine/turbine data for wear prediction and predictive maintenance, as referenced in @oieieio1’s X update, and it’s shown promising results, though I’ve noticed prompt design has a massive impact on outcomes.
I’m using GESAL with meta-llama/Llama-3.2-1B
on an Ubuntu 24.04 system with:
flight_hours
exhaust_temp
vibration
rpm
thrust
pressure
wear
fuel_flow
, oil_temp
, etc.)My latest analysis of 1,326 synthetic engines shows:
For example, a sample input is:Engine 1—flight_hours=5000h, exhaust_temp=750°C, vibration=0.5g, rpm=12000, thrust=75kN, pressure=1.5bar, wear=3.2. Predict maintenance.
We’re actively experimenting with prompts—e.g., “Predict maintenance” vs. “Identify maintenance needs for wear and predict ‘replace’, ‘maintenance’, or ‘check’”—and finding that slight changes dramatically affect GESAL’s responses, likely due to temperature=0.7
and top_k=50
in generation.
While GESAL’s scalability is excellent, I’m targeting:
The drop from 42.0% to 22.48% accuracy may stem from prompt variations or scaling effects, possibly amplified by current hyperparameters.
I’d appreciate your insights on:
temperature
, top_k
, distance_threshold
)The attached visualization (Wear vs Exhaust Temperature) shows current performance—I’m eager to collaborate further to refine prompts and boost accuracy!
Thanks again for this groundbreaking tool—I’m excited to see how GESAL can evolve!
meta-llama/Llama-3.2-1B
adapt in real time using user feedback. Check out the code and white paper on GitHub!transformers
:pip install transformers torch numpy
python Adaptive_Learning_(GESAL).py
If you're building with AI at any scale, definitely worth checking out. Yes! Looks great!