On this tutorial, we construct a complicated agentic AI system that autonomously handles time sequence forecasting utilizing the Darts library mixed with a light-weight HuggingFace mannequin for reasoning. We design the agent to function in a notion–reasoning–motion cycle, the place it first analyzes patterns within the knowledge, then selects an applicable forecasting mannequin, generates predictions, and at last explains and visualizes the outcomes. By strolling by this pipeline, we expertise how agentic AI can convey collectively statistical modeling and pure language reasoning to make forecasting each correct and interpretable. Take a look at the FULL CODES right here.
!pip set up darts transformers pandas matplotlib numpy -q
import pandas as pd
import numpy as np
from darts import TimeSeries
from darts.fashions import ExponentialSmoothing, NaiveSeasonal, LinearRegressionModel
from darts.metrics import mape, rmse
from transformers import pipeline
import matplotlib.pyplot as plt
from datetime import datetime, timedeltaWe start by putting in and importing the important libraries, together with Darts for time sequence forecasting, Transformers for reasoning, and supporting packages like pandas, NumPy, and matplotlib. With these instruments in place, we arrange the inspiration to construct and run our autonomous forecasting agent. Take a look at the FULL CODES right here.
class TimeSeriesAgent:
"""Autonomous agent for time sequence evaluation and forecasting"""
def __init__(self):
print("🤖 Initializing Agent Mind...")
self.llm = pipeline("text-generation", mannequin="distilgpt2", max_length=150,
do_sample=True, temperature=0.7)
self.fashions = {
'exponential_smoothing': ExponentialSmoothing(),
'naive_seasonal': NaiveSeasonal(Okay=12),
'linear_regression': LinearRegressionModel(lags=12)
}
self.selected_model = None
self.forecast = None
def understand(self, knowledge):
"""Agent perceives and analyzes the time sequence knowledge"""
print("n👁️ PERCEPTION PHASE")
self.ts = TimeSeries.from_dataframe(knowledge, 'date', 'worth', freq='M')
pattern = "growing" if knowledge['value'].iloc[-1] > knowledge['value'].iloc[0] else "reducing"
volatility = knowledge['value'].std() / knowledge['value'].imply()
seasonality = self._detect_seasonality(knowledge['value'])
evaluation = {
'size': len(knowledge),
'pattern': pattern,
'volatility': f"{volatility:.2f}",
'has_seasonality': seasonality,
'imply': f"{knowledge['value'].imply():.2f}",
'vary': f"{knowledge['value'].min():.2f} to {knowledge['value'].max():.2f}"
}
print(f"📊 Information Factors: {evaluation['length']}")
print(f"📈 Development: {evaluation['trend'].higher()}")
print(f"🎲 Volatility: {evaluation['volatility']}")
print(f"🔄 Seasonality: {'Detected' if seasonality else 'Not detected'}")
return evaluation
def _detect_seasonality(self, sequence, threshold=0.3):
"""Easy seasonality detection"""
if len(sequence) < 24:
return False
acf = np.correlate(sequence - sequence.imply(), sequence - sequence.imply(), mode="full")
acf = acf[len(acf)//2:]
acf /= acf[0]
return np.max(acf[12:24]) > threshold if len(acf) > 24 else False
def cause(self, evaluation):
"""Agent causes about which mannequin to make use of"""
print("n🧠 REASONING PHASE")
immediate = f"Time sequence evaluation: {evaluation['length']} knowledge factors, {evaluation['trend']} pattern, "
f"volatility {evaluation['volatility']}, seasonality: {evaluation['has_seasonality']}. "
thought = self.llm(immediate, max_length=100, num_return_sequences=1)[0]['generated_text']
print(f"💭 Agent Pondering: {thought[:150]}...")
if evaluation['has_seasonality']:
self.selected_model="naive_seasonal"
cause = "Seasonality detected - utilizing Naive Seasonal mannequin"
elif float(evaluation['volatility']) > 0.3:
self.selected_model="exponential_smoothing"
cause = "Excessive volatility - utilizing Exponential Smoothing"
else:
self.selected_model="linear_regression"
cause = "Steady pattern - utilizing Linear Regression"
print(f"✅ Choice: {cause}")
return self.selected_model
def act(self, horizon=12):
"""Agent takes motion: trains mannequin and generates forecast"""
print("n⚡ ACTION PHASE")
prepare, val = self.ts[:-12], self.ts[-12:]
mannequin = self.fashions[self.selected_model]
print(f"🎯 Coaching {self.selected_model}...")
mannequin.match(prepare)
self.forecast = mannequin.predict(horizon)
if len(val) > 0:
val_pred = mannequin.predict(len(val))
accuracy = 100 - mape(val, val_pred)
print(f"📊 Validation Accuracy: {accuracy:.2f}%")
print(f"🔮 Generated {horizon}-step forecast")
return self.forecast
def clarify(self):
"""Agent explains its predictions"""
print("n💬 EXPLANATION PHASE")
forecast_values = self.forecast.values().flatten()
hist_values = self.ts.values().flatten()
change = ((forecast_values[-1] - hist_values[-1]) / hist_values[-1]) * 100
course = "enhance" if change > 0 else "lower"
rationalization = f"Based mostly on my evaluation utilizing {self.selected_model}, "
f"I predict a {abs(change):.1f}% {course} within the subsequent interval. "
f"Forecast vary: {forecast_values.min():.2f} to {forecast_values.max():.2f}. "
f"Historic imply was {hist_values.imply():.2f}."
print(f"📝 {rationalization}")
immediate = f"Forecast abstract: {rationalization} Clarify implications:"
abstract = self.llm(immediate, max_length=120)[0]['generated_text']
print(f"n🤖 Agent Abstract: {abstract[:200]}...")
return rationalization
def visualize(self):
"""Agent creates visualization of its work"""
print("n📊 Producing visualization...")
plt.determine(figsize=(14, 6))
self.ts.plot(label="Historic Information", lw=2)
self.forecast.plot(label=f'Forecast ({self.selected_model})',
lw=2, linestyle="--")
plt.title('🤖 Agentic AI Time Sequence Forecast', fontsize=16, fontweight="daring")
plt.xlabel('Date', fontsize=12)
plt.ylabel('Worth', fontsize=12)
plt.legend(loc="finest", fontsize=11)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.present()We outline a TimeSeriesAgent that thinks with a light-weight HuggingFace mannequin and acts with a small portfolio of Darts fashions. We understand patterns (pattern, volatility, seasonality), cause to decide on the very best mannequin, then prepare, forecast, and validate. Lastly, we clarify the prediction in plain language and visualize historical past versus forecast. Take a look at the FULL CODES right here.
def create_sample_data():
"""Generate pattern time sequence knowledge"""
dates = pd.date_range(begin="2020-01-01", intervals=48, freq='M')
pattern = np.linspace(100, 150, 48)
seasonality = 10 * np.sin(np.linspace(0, 4*np.pi, 48))
noise = np.random.regular(0, 3, 48)
values = pattern + seasonality + noise
return pd.DataFrame({'date': dates, 'worth': values})We create a helper perform create_sample_data() that generates artificial time sequence knowledge with a transparent pattern, sinusoidal seasonality, and random noise. This permits us to simulate real looking month-to-month knowledge from 2020 to 2023 for testing and demonstrating the agent’s forecasting workflow. Take a look at the FULL CODES right here.
def major():
"""Foremost execution: Agent autonomously handles forecasting job"""
print("="*70)
print("🚀 AGENTIC AI TIME SERIES FORECASTING SYSTEM")
print("="*70)
print("n📥 Loading knowledge...")
knowledge = create_sample_data()
print(f"Loaded {len(knowledge)} knowledge factors from 2020-01 to 2023-12")
agent = TimeSeriesAgent()
evaluation = agent.understand(knowledge)
agent.cause(evaluation)
agent.act(horizon=12)
agent.clarify()
agent.visualize()
print("n" + "="*70)
print("✅ AGENT COMPLETED FORECASTING TASK SUCCESSFULLY")
print("="*70)
if __name__ == "__main__":
major()We outline the primary perform that runs the complete agentic AI pipeline. We load artificial time sequence knowledge, let the TimeSeriesAgent understand patterns, cause to pick out the very best mannequin, act by coaching and forecasting, clarify the outcomes, and at last visualize them. This completes the end-to-end autonomous notion, reasoning, and motion cycle.
In conclusion, we see how an autonomous agent can analyze time sequence knowledge, cause about mannequin choice, generate forecasts, and clarify its predictions in pure language. By combining Darts with HuggingFace, we create a compact but highly effective framework that not solely produces correct forecasts but in addition clearly communicates insights. We full the cycle with visualization, reinforcing how agentic AI makes forecasting extra intuitive and interactive.
Take a look at the FULL CODES right here. Be at liberty to take a look at our GitHub Web page for Tutorials, Codes and Notebooks. Additionally, be happy to observe us on Twitter and don’t overlook to hitch our 100k+ ML SubReddit and Subscribe to our Publication. Wait! are you on telegram? now you possibly can be a part of us on telegram as effectively.
Asif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is dedicated to harnessing the potential of Synthetic Intelligence for social good. His most up-to-date endeavor is the launch of an Synthetic Intelligence Media Platform, Marktechpost, which stands out for its in-depth protection of machine studying and deep studying information that’s each technically sound and simply comprehensible by a large viewers. The platform boasts of over 2 million month-to-month views, illustrating its reputation amongst audiences.
Elevate your perspective with NextTech Information, the place innovation meets perception.
Uncover the newest breakthroughs, get unique updates, and join with a world community of future-focused thinkers.
Unlock tomorrow’s tendencies at present: learn extra, subscribe to our publication, and change into a part of the NextTech group at NextTech-news.com
