A Coding Information to Construct Versatile Multi-Mannequin Workflows in GluonTS with Artificial Information, Analysis, and Superior Visualizations

def plot_advanced_forecasts(test_data, forecasts_dict, series_idx=0):
   """Superior plotting with a number of fashions and uncertainty bands"""
   fig, axes = plt.subplots(2, 2, figsize=(15, 10))
   fig.suptitle('Superior GluonTS Forecasting Outcomes', fontsize=16, fontweight="daring")
  
   if not forecasts_dict:
       fig.textual content(0.5, 0.5, 'No profitable forecasts to show',
               ha="middle", va="middle", fontsize=20)
       return fig
  
   if series_idx < len(test_data.label):
       ts_label = test_data.label[series_idx]
       ts_input = test_data.enter[series_idx]['target']
      
       colours = ['blue', 'red', 'green', 'purple', 'orange']
      
       ax1 = axes[0, 0]
       ax1.plot(vary(len(ts_input)), ts_input, 'k-', label="Historic", alpha=0.8, linewidth=2)
       ax1.plot(vary(len(ts_input), len(ts_input) + len(ts_label)),
               ts_label, 'k--', label="True Future", alpha=0.8, linewidth=2)
      
       for i, (title, forecasts) in enumerate(forecasts_dict.objects()):
           if series_idx < len(forecasts):
               forecast = forecasts[series_idx]
               forecast_range = vary(len(ts_input), len(ts_input) + len(forecast.imply))
              
               coloration = colours[i % len(colors)]
               ax1.plot(forecast_range, forecast.imply,
                       coloration=coloration, label=f'{title} Imply', linewidth=2)
              
               strive:
                   ax1.fill_between(forecast_range,
                                  forecast.quantile(0.1), forecast.quantile(0.9),
                                  alpha=0.2, coloration=coloration, label=f'{title} 80% CI')
               besides:
                   go 
      
       ax1.set_title('Multi-Mannequin Forecasts Comparability', fontsize=12, fontweight="daring")
       ax1.legend()
       ax1.grid(True, alpha=0.3)
       ax1.set_xlabel('Time Steps')
       ax1.set_ylabel('Worth')
      
       ax2 = axes[0, 1]
       if all_forecasts:
           first_model = listing(all_forecasts.keys())[0]
           if series_idx < len(all_forecasts[first_model]):
               forecast = all_forecasts[first_model][series_idx]
               ax2.scatter(ts_label, forecast.imply, alpha=0.7, s=60)
              
               min_val = min(min(ts_label), min(forecast.imply))
               max_val = max(max(ts_label), max(forecast.imply))
               ax2.plot([min_val, max_val], [min_val, max_val], 'r--', alpha=0.8)
              
               ax2.set_title(f'Prediction vs Precise - {first_model}', fontsize=12, fontweight="daring")
               ax2.set_xlabel('Precise Values')
               ax2.set_ylabel('Predicted Values')
               ax2.grid(True, alpha=0.3)
      
       ax3 = axes[1, 0]
       if all_forecasts:
           first_model = listing(all_forecasts.keys())[0]
           if series_idx < len(all_forecasts[first_model]):
               forecast = all_forecasts[first_model][series_idx]
               residuals = ts_label - forecast.imply
               ax3.hist(residuals, bins=15, alpha=0.7, coloration="skyblue", edgecolor="black")
               ax3.axvline(x=0, coloration="r", linestyle="--", linewidth=2)
               ax3.set_title(f'Residuals Distribution - {first_model}', fontsize=12, fontweight="daring")
               ax3.set_xlabel('Residuals')
               ax3.set_ylabel('Frequency')
               ax3.grid(True, alpha=0.3)
      
       ax4 = axes[1, 1]
       if evaluation_results:
           metrics = ['MASE', 'sMAPE'] 
           model_names = listing(evaluation_results.keys())
           x = np.arange(len(metrics))
           width = 0.35
          
           for i, model_name in enumerate(model_names):
               values = [evaluation_results[model_name].get(metric, 0) for metric in metrics]
               ax4.bar(x + i*width, values, width,
                      label=model_name, coloration=colours[i % len(colors)], alpha=0.8)
          
           ax4.set_title('Mannequin Efficiency Comparability', fontsize=12, fontweight="daring")
           ax4.set_xlabel('Metrics')
           ax4.set_ylabel('Worth')
           ax4.set_xticks(x + width/2 if len(model_names) > 1 else x)
           ax4.set_xticklabels(metrics)
           ax4.legend()
           ax4.grid(True, alpha=0.3)
       else:
           ax4.textual content(0.5, 0.5, 'No evaluationnresults obtainable',
                   ha="middle", va="middle", rework=ax4.transAxes, fontsize=14)
  
   plt.tight_layout()
   return fig


if all_forecasts and test_data.label:
   print("📈 Creating superior visualizations...")
   fig = plot_advanced_forecasts(test_data, all_forecasts, series_idx=0)
   plt.present()
  
   print(f"n🎉 Tutorial accomplished efficiently!")
   print(f"📊 Skilled {len(trained_models)} mannequin(s) on {len(df.columns) if 'df' in locals() else 10} time collection")
   print(f"🎯 Prediction size: 30 days")
  
   if evaluation_results:
       best_model = min(evaluation_results.objects(), key=lambda x: x[1]['MASE'])
       print(f"🏆 Greatest performing mannequin: {best_model[0]} (MASE: {best_model[1]['MASE']:.4f})")
  
   print(f"n🔧 Setting Standing:")
   print(f"  PyTorch Assist: {'✅' if TORCH_AVAILABLE else '❌'}")
   print(f"  MXNet Assist: {'✅' if MX_AVAILABLE else '❌'}")
  
else:
   print("⚠️  Creating demonstration plot with artificial information...")
  
   fig, ax = plt.subplots(1, 1, figsize=(12, 6))
  
   dates = pd.date_range('2020-01-01', durations=100, freq='D')
   ts = 100 + np.cumsum(np.random.regular(0, 2, 100)) + 20 * np.sin(np.arange(100) * 2 * np.pi / 30)
  
   ax.plot(dates[:70], ts[:70], 'b-', label="Historic Information", linewidth=2)
   ax.plot(dates[70:], ts[70:], 'r--', label="Future (Instance)", linewidth=2)
   ax.fill_between(dates[70:], ts[70:] - 5, ts[70:] + 5, alpha=0.3, coloration="crimson")
  
   ax.set_title('GluonTS Probabilistic Forecasting Instance', fontsize=14, fontweight="daring")
   ax.set_xlabel('Date')
   ax.set_ylabel('Worth')
   ax.legend()
   ax.grid(True, alpha=0.3)
  
   plt.tight_layout()
   plt.present()
  
   print("n📚 Tutorial demonstrates superior GluonTS ideas:")
   print("  • Multi-series dataset era")
   print("  • Probabilistic forecasting")
   print("  • Mannequin analysis and comparability")
   print("  • Superior visualization strategies")
   print("  • Strong error dealing with")