from faim_sdk import ForecastClient # Initialize client with your API key client = ForecastClient(api_key="your-api-key")

import numpy as np from faim_sdk import ForecastClient, Chronos2ForecastRequest # Initialize client client = ForecastClient(api_key="your-api-key") # Prepare your time-series data # Shape: (batch_size, sequence_length, features) data = np.random.randn(32, 100, 1).astype(np.float32) # Create probabilistic forecast request request = Chronos2ForecastRequest( x=data, horizon=24, # Forecast 24 steps ahead output_type="quantiles", quantiles=[0.1, 0.5, 0.9] # 10th, 50th (median), 90th percentiles ) # Generate forecast - model inferred automatically from request type response = client.forecast(request) # Access predictions print(response.quantiles.shape) # (32, 24, 3, 1) print(response.metadata) # Model version, inference time, etc.

# Shape: (batch_size, sequence_length, features) x = np.array([ [[1.0], [2.0], [3.0]], # Series 1 [[4.0], [5.0], [6.0]] # Series 2 ]) # Shape: (2, 3, 1)

# Shape: (n_samples, n_features) X_train = np.array([ [1.0, 2.0, 3.0], # Sample 1 [4.0, 5.0, 6.0], # Sample 2 ]) # Shape: (2, 3)

response.point # Shape: (batch_size, horizon, features)

response.quantiles # Shape: (batch_size, horizon, num_quantiles, features) # Example: (32, 24, 5, 1) = 32 series, 24 steps ahead, 5 quantiles, 1 feature

response.predictions # Shape: (n_samples,) # Classification: class labels or indices # Regression: continuous values

response.probabilities # Shape: (n_samples, n_classes) - classification only # Probability for each class

from faim_sdk import FlowStateForecastRequest request = FlowStateForecastRequest( x=data, horizon=24, model_version="latest", output_type="point", scale_factor=1.0, # Optional: normalization factor, for details check: https://huggingface.co/ibm-granite/granite-timeseries-flowstate-r1 prediction_type="mean" # Options: "mean", "median" ) response = client.forecast(request) print(response.point.shape) # (batch_size, 24, features)

from faim_sdk import Chronos2ForecastRequest # Quantile-based probabilistic forecast request = Chronos2ForecastRequest( x=data, horizon=24, output_type="quantiles", quantiles=[0.05, 0.25, 0.5, 0.75, 0.95] # Full distribution ) response = client.forecast(request) print(response.quantiles.shape) # (batch_size, 24, 5)

from faim_sdk import TiRexForecastRequest request = TiRexForecastRequest( x=data, horizon=24, output_type="point" ) response = client.forecast(request) print(response.point.shape) # (batch_size, 24, features)

from faim_sdk import TabularClient, LimiXPredictRequest import numpy as np # Initialize tabular client client = TabularClient(api_key="your-api-key") # Prepare tabular data (2D arrays) X_train = np.random.randn(100, 10).astype(np.float32) y_train = np.random.randint(0, 2, 100).astype(np.float32) X_test = np.random.randn(20, 10).astype(np.float32) # Create classification request request = LimiXPredictRequest( X_train=X_train, y_train=y_train, X_test=X_test, task_type="Classification", # or "Regression" use_retrieval=False # Set to True for retrieval-augmented inference ) # Generate predictions response = client.predict(request) print(response.predictions.shape) # (20,) print(response.probabilities.shape) # (20, n_classes) - classification only

from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split # Load dataset X, y = load_breast_cancer(return_X_y=True) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=42) # Convert to float32 X_train = X_train.astype(np.float32) X_test = X_test.astype(np.float32) y_train = y_train.astype(np.float32) # Create and send request request = LimiXPredictRequest( X_train=X_train, y_train=y_train, X_test=X_test, task_type="Classification" ) response = client.predict(request) # Evaluate from sklearn.metrics import accuracy_score accuracy = accuracy_score(y_test, response.predictions.astype(int)) print(f"Accuracy: {accuracy:.4f}")

from sklearn.datasets import fetch_california_housing # Load dataset house_data = fetch_california_housing() X, y = house_data.data, house_data.target # Split data (50/50 for demo) split_idx = len(X) // 2 X_train, X_test = X[:split_idx].astype(np.float32), X[split_idx:].astype(np.float32) y_train, y_test = y[:split_idx].astype(np.float32), y[split_idx:].astype(np.float32) # Create and send request request = LimiXPredictRequest( X_train=X_train, y_train=y_train, X_test=X_test, task_type="Regression" ) response = client.predict(request) # Evaluate from sklearn.metrics import mean_squared_error rmse = np.sqrt(mean_squared_error(y_test, response.predictions)) print(f"RMSE: {rmse:.4f}")

request = LimiXPredictRequest( X_train=X_train, y_train=y_train, X_test=X_test, task_type="Classification", use_retrieval=True # Enable RAI (slower but more accurate) ) response = client.predict(request)

response = client.forecast(request) # Access predictions based on output_type if response.point is not None: predictions = response.point # Shape: (batch_size, horizon, features) if response.quantiles is not None: quantiles = response.quantiles # Shape: (batch_size, horizon, num_quantiles) # Lower quantiles for uncertainty bounds lower_bound = quantiles[:, :, 0] # 10th percentile median = quantiles[:, :, 1] # 50th percentile (median) upper_bound = quantiles[:, :, 2] # 90th percentile if response.samples is not None: samples = response.samples # Shape: (batch_size, horizon, num_samples) # Access metadata print(response.metadata) # {'model_name': 'chronos2', 'model_version': '1.0', 'inference_time_ms': 123}

from faim_sdk import ( ForecastClient, Chronos2ForecastRequest, ValidationError, AuthenticationError, RateLimitError, ModelNotFoundError, ErrorCode ) try: request = Chronos2ForecastRequest(x=data, horizon=24, quantiles=[0.1, 0.5, 0.9]) response = client.forecast(request) except AuthenticationError as e: # Handle authentication failures (401, 403) print(f"Authentication failed: {e.message}") print(f"Request ID: {e.error_response.request_id}") except ValidationError as e: # Handle invalid request parameters (422) if e.error_code == ErrorCode.INVALID_SHAPE: print(f"Shape error: {e.error_response.detail}") # Fix shape and retry elif e.error_code == ErrorCode.MISSING_REQUIRED_FIELD: print(f"Missing field: {e.error_response.detail}") except RateLimitError as e: # Handle rate limiting (429) print("Rate limit exceeded - implementing exponential backoff") retry_after = e.error_response.metadata.get('retry_after', 60) time.sleep(retry_after) except ModelNotFoundError as e: # Handle model/version not found (404) print(f"Model not found: {e.message}")

import asyncio from faim_sdk import ForecastClient, Chronos2ForecastRequest async def forecast_multiple_series(): client = ForecastClient( api_key="your-api-key" ) # Create multiple requests requests = [ Chronos2ForecastRequest(x=data1, horizon=24), Chronos2ForecastRequest(x=data2, horizon=24), Chronos2ForecastRequest(x=data3, horizon=24), ] # Execute concurrently async with client: tasks = [ client.forecast_async(req) for req in requests ] responses = await asyncio.gather(*tasks) return responses # Run async forecasts responses = asyncio.run(forecast_multiple_series())