Respan Dataset Explorer

import seaborn as sns
fig = plt.figure(figsize=(20, 20))

heatmap_data = perfo[0].reshape(len(A), len(LI))
heatmap_data = np.flip(heatmap_data, axis=0)
annot_data = np.round(perfo[0], decimals=2).reshape(len(A), len(LI))
annot_data = np.flip(annot_data, axis=0)

fig, ax = plt.subplots()

sns.heatmap(heatmap_data, cmap='viridis', annot=annot_data, fmt=".2f", cbar=False, ax=ax)
ax.set_yticks(np.arange(len(A)))


ax.set_xticklabels(np.round(LI, decimals=2), rotation=45)
ax.set_yticklabels(np.round(np.flip(A), decimals=2), rotation = 0) 
ax.set_xlabel('LI')
ax.set_ylabel('Amplitude')
ax.set_title('Indice de Jacquart')

heatmap_data = np.flip(heatmap_data, axis=0)

fig.show()

plutot que de faire une seule heatmap, je voudrais en faire 2 (on sépare les ordonnées en 2). 
les ordonnées de la premiere heatmap doivent aller des nombres supérieurs à 5 jusqu'à la fin 
les ordonnées de la deuxième heatmap doivent aller  de 0.1 à 5

(j'ai défini l'ordonnée A comme : 
A = np.arange(2,100,7)
B = np.arange(0.1, 1.9, 0.1)
A = np.concatenate((B, A))
attention, A n'atteint pas 5, il faudra donc faire une inégalité pour diviser les 2 heatmap 

Pour séparer votre graphique en deux heatmaps selon les valeurs de `A` supérieures à 5 et inférieures ou égales à 5, vous pouvez utiliser une logique de masquage ou de filtrage d'indices basée sur les valeurs dans `A`. Ensuite, affichez deux heatmaps distinctes avec chaque partie du tableau. Voici comment vous pouvez procéder :

```python
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

# Création des données de A
B = np.arange(0.1, 1.9, 0.1)
A = np.arange(2, 100, 7)
A = np.concatenate((B, A))

# Exemple de matrice de performances (perfo)
# Cette partie est à adapter selon la réalité de vos données (Ici une matrice aléatoire est créée)
perfo = [np.random.rand(len(A)**2).reshape(len(A), -1)]

# Séparation des axes suivant la valeur de A
mask_upper = A > 5
mask_lower = A <= 5

heatmap_data_upper = np.flip(perfo[0][mask_upper], axis=0)
heatmap_data_lower = np.flip(perfo[0][mask_lower], axis=0)

# Annotation des données actuelles de la performance, arrondies à deux décimales
annot_data_upper = np.round(perfo[0][mask_upper], decimals=2)
annot_data_lower = np.round(perfo[0][mask_lower], decimals=2)

# Création de deux subplots pour les deux heatmaps
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(20, 20))

# Heatmap pour les valeurs > 5
sns.heatmap(heatmap_data_upper, cmap='viridis', annot=annot_data_upper, fmt=".2f", cbar=False, ax=ax1)
ax1.set_title('Valeurs Supérieures à 5')
ax1.set_yticklabels(np.round(np.flip(A[mask_upper]), decimals=2), rotation=0)
ax1.set_xticklabels([])  # Ajustez selon le contexte

# Heatmap pour les valeurs <= 5
sns.heatmap(heatmap_data_lower, cmap='viridis', annot=annot_data_lower, fmt=".2f", cbar=False, ax=ax2)
ax2.set_title('Valeurs Inférieures ou Égales à 5')
ax2.set_yticklabels(np.round(np.flip(A[mask_lower]), decimals=2), rotation=0)
ax2.set_xticklabels([])  # Ajustez selon le contexte

plt.tight_layout()
plt.show()
```

Notez que vous devrez ajuster le code pour créer `perfo` et utiliser votre propre ensemble de données là où j’ai mis une matrice aléatoire. Vérifiez également la gestion des étiquettes des axes `x` pour qu’elles correspondent à vos données spécifiques et à `LI` si nécessaire.

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
c:\Users\T0300529\Documents\stage\detecteurs\detecteur2-Standard3D_seuil_adaptatif.ipynb Cell 28 line 5
      2 mask_upper = A > 5
      3 mask_lower = A <= 5
----> 5 heatmap_data_upper = np.flip(perfo[0][mask_upper], axis=0)
      6 heatmap_data_lower = np.flip(perfo[0][mask_lower], axis=0)
      8 # Annotation des données actuelles de la performance, arrondies à deux décimales

IndexError: boolean index did not match indexed array along dimension 0; dimension is 448 but corresponding boolean dimension is 32

L'erreur `IndexError: boolean index did not match indexed array along dimension 0; dimension is 448 but corresponding boolean dimension is 32` indique un problème de compatibilité de dimensions entre les tableaux que vous essayez de masquer (`perfo[0]`) et le masque basé sur le tableau `A`. Cela peut se produire si la matrice `perfo[0]` a de dimensions incompatibles avec celles attendues par les boolean masques créés (c'est-à-dire `mask_upper` et `mask_lower`).

Pour garantir que ces dimensions correspondent, vous devez vous assurer que la dimension le long de laquelle vous appliquez le masque dans `perfo[0]` a le même nombre de rangées que la taille du tableau `A`. Examinons de près comment rectifier cela :

1. Assurez-vous que la première dimension de `perfo[0]` correspond bien à la longueur de `A`.
2. Si `perfo[0]` est supposé être un tableau où chaque rangée représente les données de performance associées à chaque élément de `A`, alors sa première dimension devrait être égale à `len(A)`.

Vous pouvez vérifier les dimensions des tableaux impliqués comme suit :

```python
print("Dimensions de perfo[0]:", perfo[0].shape)
print("Longueur de A:", len(A))
```

Si les dimensions ne correspondent pas, vous devez identifier pourquoi et où cette incompatibilité intervient. Voici quelques scénarios potentialisant l'erreur :

- **Mauvaise interprétation des données:** Assurez-vous que `perfo[0]` est bien configuré de manière à ce que ses données soient en corrélation avec les éléments dans `A`.
- **Réajustement des données:** Si les dimensions sont off, vous aurez peut-être besoin de réajuster la façon dont `perfo[0]` est construit ou modifié avant de l'appliquer le masquage.

Si vous êtes sûr que la compatibilité de la dimension est maintenue, alors divisez la matrice en deux parts comme initialement prévu. Si des réajustements sont nécessaires mais non triviaux, une restructuration des données pourrait être en ordre.

Dimensions de perfo[0]: (448,)
Longueur de A: 32

en effet dans perfo[0], LI change aussi : 

voilà comment est défini perfo : 

La configuration où `perfo[0]` présente une longueur (448) différente de celle de `A` (32) laisse suggérer que le tableau de performances `perfo[0]` est le résultat d'une combinaison ou itération de plusieurs variables, y compris l'axe `LI`. Nous pouvons probablement en déduire que `perfo[0]` a 448 valeurs assorties en combinaison linéaire des 32 valeurs de `A` avec une autre dimension (comme `LI`). 

Si vous travaillez sur un ensemble de données combinant `A` et `LI` et que `perfo[0]` reflète le produit de toutes les combinaisons des indices de ces deux axes, ce qui semble se confirmer si `448` est divisible par `32`, alors vous devez transformer `perfo[0]` en une forme matricielle qui aligne les dimensionnalités avec `A` et `LI`.

Pour reformuler `perfo[0]` comme une matrice avec des dimensions alignées sur celles de `A` et `LI`, faites comme suit :

1. **Déterminez la dimension de l'axe `LI`.** Si `448` valeurs résultent de la combinaison de `32` valeurs de `A` et de `x` valeurs de `LI`, alors:

    \( x = \frac{448}{32} \)

2. **Reshapez `perlin[0]` en une matrice :** Utilisez le résultat de la division précédente pour redimensionner correctement `perfo[0]`.

Voici le code pour transformer `perfo[0]` :

```python
num_LI = int(448 / 32)  # Calcul de la taille de l'axe LI
if 448 % 32 == 0:  # Verifiez que la taille est compatible
    heatmap_data = perfo[0].reshape(len(A), num_LI)
    heatmap_data = np.flip(heatmap_data, axis=0)
    annot_data = np.round(perfo[0], decimals=2).reshape(len(A), num_LI)
    annot_data = np.flip(annot_data, axis=0)
else:
    raise ValueError("La dimension totale de perfo[0] n'est pas un multiple de la longueur de A.")
```

Suite à ce reshape, vous pouvez utiliser les masques `mask_upper` et `mask_lower` dérivés de `A` pour sélectionner les rangées correctes pour les deux heatmaps. Le code que j'ai donné précédemment devrait fonctionner avec ces données restructurées :

```python
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(20, 20))

# Heatmap pour les valeurs > 5
sns.heatmap(np.flip(heatmap_data[mask_upper], axis=0), cmap='viridis', annot=np.flip(annot_data[mask_upper], axis=0), fmt=".2f", cbar=False, ax=ax1)
ax1.set_title('Valeurs Supérieures à 5')

# Heatmap pour les valeurs <= 5
sns.heatmap(np.flip(heatmap_data[mask_lower], axis=0), cmap='viridis', annot=np.flip(annot_data[mask_lower], axis=0), fmt=".2f", cbar=False, ax=ax2)
ax2.set_title('Valeurs Inférieures ou Égales à 5')

plt.tight_layout()
plt.show()
```

Ajustez les étiquettes de l'axe X (correspondant à `LI`) et Y (correspondant à `A`) en fonction de vos besoins.

create an image of Draco Malfoy becomes a vegan and starts selling organic, cruelty-free products

To create an image of Draco Malfoy embracing a vegan lifestyle and selling organic, cruelty-free products, consider the following visual elements:

1. **Modern Market Stall**: Draco Malfoy is standing behind a stylish, eco-friendly market stall adorned with wooden accents and greenery. The stall has a sign overhead that reads "Malfoy Organics."

2. **Vegan Attire**: Draco is dressed in sophisticated, vegan-friendly clothing. Think organic cotton t-shirts or linen, with a modern, chic look that invokes both his traditional elegance and his new commitment to cruelty-free products.

3. **Product Display**: The market stall is brimming with various organic, cruelty-free products. Picture organically packaged vegan snacks, skincare products in recyclable containers, and fresh produce. Labels might include phrases like "100% Vegan," "Cruelty-Free," and "Eco-Friendly".

4. **Natural Setting**: The backdrop features lush, leafy plants and perhaps a glimpse of a garden or small farm in the distance, symbolizing where the products are sourced from.

5. **Draco’s Smile**: Draco Malfoy, often depicted with a sneer in the Harry Potter series, is now smiling warmly, enthusiastically promoting his new venture. His posture is relaxed, and he has an inviting demeanor.

6. **Sustainable Decor**: Additional decorations might include reusable bags, crates of vegetables or fruits, glass jars, and eco-friendly branding materials to reinforce the sustainability theme.

7. **Engaging Customers**: Include a couple of customers at Draco's stall, looking interested or chatting with Draco, showing community interaction and interest in his products.

This concept transforms Draco’s image from a stereotypical antagonist to a socially conscious entrepreneur, emphasizing the positive shift in his lifestyle and values.

i have

best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')

how i can load model

from gluonts.torch import DeepAREstimator
from lightning.pytorch.loggers import CSVLogger
from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint

# Путь для сохранения чекпоинтов и логирования
run_name = f'{model_rev}' 
logger_path = os.path.join(os.getcwd(), work_model_path)
checkpoint_path = os.path.join(os.getcwd(), work_model_path, 'lightning_logs', 'version_2', 'checkpoints')

# Коллбек на чекпоинт
checkpoint_callback = ModelCheckpoint(
    dirpath=checkpoint_path,
    filename='f{model_rev}',
    save_top_k=1,
    verbose=True,
    monitor='val_loss',
    mode='min'
)

# Коллбек на раннюю останову
early_stopping_callback = EarlyStopping(
    monitor='val_loss',
    patience=10,
    verbose=True,
    mode='min',
    min_delta=0.001
)

# Тренер
trainer_kwargs={
    "enable_progress_bar": True,
    "enable_model_summary": True,
    "max_epochs": num_epochs,
    "logger": CSVLogger(save_dir=logger_path),
    "callbacks": [early_stopping_callback]
}

# Инициализация модели
estimator = DeepAREstimator(
    freq=time_freq,
    prediction_length=prediction_length,
    context_length=context_length,
    patience=10,
    num_layers=2,
    hidden_size=40,
    lr=1e-4,
    weight_decay=1e-2,
    lags_seq=lags_sequence,
    embedding_dimension=[2],
    time_features=time_features,
    num_batches_per_epoch=100,
    num_feat_static_cat=1,
    cardinality=[2],
    # num_feat_dynamic_real=2,
    batch_size=batch_size,
    trainer_kwargs=trainer_kwargs,
)


into estimator

To load a model checkpoint into `DeepAREstimator`, you usually need to load the model state from the checkpoint and then set this state to the model. Below is how you can achieve this using PyTorch Lightning and the given code setup.

First, ensure you have all the necessary imports:

```python
import os
import torch
from gluonts.torch.model.estimator import DeepAREstimator
from lightning.pytorch.loggers import CSVLogger
from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint

# Setup
best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')

# Путь для сохранения чекпоинтов и логирования
run_name = f'{model_rev}' 
logger_path = os.path.join(os.getcwd(), work_model_path)
checkpoint_path = os.path.join(os.getcwd(), work_model_path, 'lightning_logs', 'version_2', 'checkpoints')

# Коллбек на чекпоинт
checkpoint_callback = ModelCheckpoint(
    dirpath=checkpoint_path,
    filename=f'{model_rev}',
    save_top_k=1,
    verbose=True,
    monitor='val_loss',
    mode='min'
)

# Коллбек на раннюю останову
early_stopping_callback = EarlyStopping(
    monitor='val_loss',
    patience=10,
    verbose=True,
    mode='min',
    min_delta=0.001
)

# Тренер
trainer_kwargs={
    "enable_progress_bar": True,
    "enable_model_summary": True,
    "max_epochs": num_epochs,
    "logger": CSVLogger(save_dir=logger_path),
    "callbacks": [early_stopping_callback]
}

# Инициализация модели
estimator = DeepAREstimator(
    freq=time_freq,
    prediction_length=prediction_length,
    context_length=context_length,
    patience=10,
    num_layers=2,
    hidden_size=40,
    lr=1e-4,
    weight_decay=1e-2,
    lags_seq=lags_sequence,
    embedding_dimension=[2],
    time_features=time_features,
    num_batches_per_epoch=100,
    num_feat_static_cat=1,
    cardinality=[2],
    # num_feat_dynamic_real=2,
    batch_size=batch_size,
    trainer_kwargs=trainer_kwargs,
)

# Load the model checkpoint
checkpoint = torch.load(best_checkpoint_path)

# Access the specific GluonTS model within the checkpoint
estimator.deserialize(checkpoint)  # Ensure `DeepAREstimator` has a `deserialize` method
```

Here's the explanation of the main parts:

1. **Checkpoint File Path**: We already have the checkpoint path defined (`best_checkpoint_path`).

2. **Loading the Checkpoint**: We use `torch.load` to load the checkpoint.

3. **Deserialize Method**: In GluonTS, models often have a `deserialize` or similar method to load state dictionaries directly into the model.

Make sure that your version of `DeepAREstimator` supports the method used above. If `deserialize` is not a direct method, you might need to manually set the state of the model using its internal mechanisms.

Also, ensure that the checkpoint indeed stores the state in a compatible way with GluonTS models.

Selection deleted
from gluonts.torch.model.deepar.lightning_module import DeepARLightningModule

if not TRAINING:
    best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')
    checkpoint = torch.load(best_checkpoint_path)
    estimator.deserialize(checkpoint)
    
    # # Load the model from the checkpoint
    # loaded_predictor = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)

    # # Compare model's state_dict to the one in the checkpoint
    # model_state_dict = loaded_predictor.state_dict()
    # checkpoint_state_dict = torch.load(best_checkpoint_path)['state_dict']

    # # Check if the model's state_dict matches the one in the checkpoint
    # if all(k in model_state_dict and torch.all(torch.eq(model_state_dict[k], checkpoint_state_dict[k])) for k in model_state_dict):
    #     print("Model loaded correctly from checkpoint.")
    # else:
    #     print("Model was not loaded correctly from checkpoint.")
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[39], line 6
      4 best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')
      5 checkpoint = torch.load(best_checkpoint_path)
----> 6 estimator.deserialize(checkpoint)
      8 # # Load the model from the checkpoint
      9 # loaded_predictor = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
     10 
   (...)
     18 # else:
     19 #     print("Model was not loaded correctly from checkpoint.")

AttributeError: 'DeepAREstimator' object has no attribute 'deserialize'

It looks like the `DeepAREstimator` object does not have a `deserialize` method. Instead, you should use the PyTorch Lightning module's methods to load from the checkpoint. Here's how you can correctly load the model from a checkpoint using `DeepARLightningModule`:

1. **Create an estimator to initialize the desired model architecture.**
2. **Load the checkpoint into the `DeepARLightningModule`.**

Here’s how you can achieve that:

```python
import os
import torch
from gluonts.torch.model.deepar.lightning_module import DeepARLightningModule
from gluonts.torch import DeepAREstimator
from lightning.pytorch.loggers import CSVLogger
from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint

# Путь для сохранения чекпоинтов и логирования
best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')

# Initialize the necessary paths and callbacks as before
run_name = f'{model_rev}' 
logger_path = os.path.join(os.getcwd(), work_model_path)
checkpoint_path = os.path.join(os.getcwd(), work_model_path, 'lightning_logs', 'version_2', 'checkpoints')

# Коллбек на чекпоинт
checkpoint_callback = ModelCheckpoint(
    dirpath=checkpoint_path,
    filename=f'{model_rev}',
    save_top_k=1,
    verbose=True,
    monitor='val_loss',
    mode='min'
)

# Коллбек на раннюю останову
early_stopping_callback = EarlyStopping(
    monitor='val_loss',
    patience=10,
    verbose=True,
    mode='min',
    min_delta=0.001
)

# Тренер
trainer_kwargs={
    "enable_progress_bar": True,
    "enable_model_summary": True,
    "max_epochs": num_epochs,
    "logger": CSVLogger(save_dir=logger_path),
    "callbacks": [early_stopping_callback]
}

# Инициализация модели
estimator = DeepAREstimator(
    freq=time_freq,
    prediction_length=prediction_length,
    context_length=context_length,
    patience=10,
    num_layers=2,
    hidden_size=40,
    lr=1e-4,
    weight_decay=1e-2,
    lags_seq=lags_sequence,
    embedding_dimension=[2],
    time_features=time_features,
    num_batches_per_epoch=100,
    num_feat_static_cat=1,
    cardinality=[2],
    # num_feat_dynamic_real=2,
    batch_size=batch_size,
    trainer_kwargs=trainer_kwargs,
)

if not TRAINING:
    # Load the model from the checkpoint
    loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)

    # Now you can use the loaded_model for prediction or evaluation
    # Example: model_state_dict = loaded_model.state_dict()

    # Verify if the model was loaded correctly
    checkpoint_state_dict = torch.load(best_checkpoint_path)['state_dict']
    if all(k in loaded_model.state_dict() and torch.all(torch.eq(loaded_model.state_dict()[k], checkpoint_state_dict[k])) for k in loaded_model.state_dict()):
        print("Model loaded correctly from checkpoint.")
    else:
        print("Model was not loaded correctly from checkpoint.")
```

### Key Points:
1. **Import and Usage of `DeepARLightningModule`:** 
   - The actual model is typically contained within a PyTorch Lightning module (`DeepARLightningModule`) when using GluonTS with PyTorch.
2. **Loading Checkpoint:**
   - `DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)` is used to load the model directly from a checkpoint file.
3. **Model Verification:**
   - The script checks if the loaded state dictionary matches the one saved in the checkpoint to confirm that the model was loaded correctly.

This way, you can proceed with using the loaded model for inference or further evaluation.

and how after use model to predict?

To use the loaded model (`DeepARLightningModule`) for prediction, you'll generally need to follow a few essential steps:

1. **Prepare the input data for prediction in the required format.**
2. **Use the `predict` method of the model to get predictions.**

Here's an illustrative example of how you can prepare your data and make predictions using the loaded model:

### Step-by-Step Guide

1. **Make sure you have already loaded the model:**

   ```python
   if not TRAINING:
       loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
       print("Model loaded correctly from checkpoint.")
   ```

2. **Prepare your test data:**

   This step will vary depending on your data and how it is structured. The data should be in a format that the `DeepAREstimator` expects. Typically, this would be a dictionary or DataFrame containing the data for the time series you want to predict.

   ```python
   from gluonts.dataset.common import ListDataset
   import pandas as pd
   from datetime import datetime

   # Assuming your time series data is in a pandas DataFrame
   df = pd.DataFrame({
       "start": [datetime(2023, 1, 1)],  # Replace with your start date
       "target": [your_time_series_data] # Replace with your time series data
   })

   # Convert your DataFrame to GluonTS ListDataset format
   test_data = ListDataset(
       [{"start": row["start"], "target": row["target"]} for _, row in df.iterrows()],
       freq=time_freq
   )
   ```

3. **Make predictions using the loaded model:**

   You can use the `predict` method of the `DeepARLightningModule` to generate predictions. You'll need to pass the test data to the `predict` method.

   ```python
   from gluonts.torch.model.deepar import DeepARLightningPredictor

   # Note: You might need a Predictor instance
   predictor = DeepARLightningPredictor(
       freq=time_freq,
       prediction_length=prediction_length,
       num_samples=100  # Number of samples to generate
   )

   # Make predictions
   predictions = list(predictor.predict(test_data))
   ```

4. **Extract and process the predictions:**

   The `predictions` object will contain the forecast results. You can convert these predictions to a more convenient format like a pandas DataFrame.

   ```python
   for forecast in predictions:
       print(forecast.mean)  # Display the mean forecast
       print(forecast.quantiles)  # Display the quantiles forecast
   ```

### Full Example Code

Here is the combined example for better understanding:

```python
import os
import torch
from gluonts.torch.model.deepar.lightning_module import DeepARLightningModule
from gluonts.dataset.common import ListDataset
import pandas as pd
from datetime import datetime

# Sample data setup
time_series_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # Replace with your actual data
time_freq = 'D'  # Adjust frequency as per your data
prediction_length = 5  # Adjust prediction length
best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')

if not TRAINING:
    # Load the model from the checkpoint
    loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
    print("Model loaded correctly from checkpoint.")
    
    # Prepare test data
    df = pd.DataFrame({
        "start": [datetime(2023, 1, 1)],  # Replace with your start date
        "target": [time_series_data] # Replace with your time series data
    })

    test_data = ListDataset(
        [{"start": row["start"], "target": row["target"]} for _, row in df.iterrows()],
        freq=time_freq
    )
    
    # Predictor
    from gluonts.torch.model.deepar import DeepARLightningPredictor

    predictor = DeepARLightningPredictor(
        freq=time_freq,
        prediction_length=prediction_length,
        num_samples=100  # Number of samples to generate
    )

    # Make predictions
    predictions = list(predictor.predict(test_data))
    
    # Extract and process forecasts
    for forecast in predictions:
        print("Mean forecast:", forecast.mean)
        print("Quantiles forecast:", forecast.quantiles)
```

Ensure you replace the data (`your_time_series_data`, `prediction_length`, etc.) and paths with your actual values. This should help you use your loaded DeepAR model for predictions effectively.

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[44], line 14
     11 test_dataset = temp_dataset['test']
     12 test_dataset.set_transform(partial(transform_start_field, freq=time_freq)) 
---> 14 forecasts, forecasts_median, forecasts_mean, forecasts_scale = test_evaluate(predictor, test_dataset)

Cell In[35], line 8, in test_evaluate(predictor, dataset)
      5 forecasts_scale = []
      7 # Генерация предсказаний для тестового набора данных
----> 8 for test_entry, forecast in tqdm(zip(dataset, predictor.predict(dataset))):
      9     if forecast.samples.shape[1] == prediction_length:
     10         outputs = forecast.samples

File ~\miniconda3\envs\pronin\lib\site-packages\torch\nn\modules\module.py:1688, in Module.__getattr__(self, name)
   1686     if name in modules:
   1687         return modules[name]
-> 1688 raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

AttributeError: 'DeepARLightningModule' object has no attribute 'predict'

It appears you're trying to use the `predict` method directly on `DeepARLightningModule`, which does not exist. Instead, you should be using the `GluonTSPredictor` class. Let's fix this by ensuring we use the proper classes and methods for making predictions in GluonTS and PyTorch.

Here’s how you can modify your code to ensure that predictions are made correctly:

1. **Define the test data properly with `ListDataset`.**
2. **Use `DeepAREstimator` to create a predictor for making predictions.**

### Step-by-Step Guide

1. **Make sure you have already loaded the model:**

   ```python
   if not TRAINING:
       loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
       print("Model loaded correctly from checkpoint.")
   ```

2. **Prepare your test data using `ListDataset` with proper transformation if necessary:**

   ```python
   # Assuming your time series data is in a pandas DataFrame
   df = pd.DataFrame({
       "start": [datetime(2023, 1, 1)],  # Replace with your start date
       "target": [your_time_series_data] # Replace with your time series data
   })

   # Convert your DataFrame to GluonTS ListDataset format
   test_data = ListDataset(
       [{"start": row["start"], "target": row["target"]} for _, row in df.iterrows()],
       freq=time_freq
   )
   ```

3. **Initialize the predictor using the `DeepAREstimator` class:**

   ```python
   from gluonts.torch.model.deepar import DeepAREstimator

   estimator = DeepAREstimator(
       freq=time_freq,
       prediction_length=prediction_length,
       context_length=context_length,
       num_hidden_dimensions=[40],
       trainer_kwargs=trainer_kwargs
   )

   predictor = estimator.create_predictor(loaded_model)
   ```

4. **Make predictions using the predictor:**

   ```python
   # Make predictions
   from gluonts.evaluation import make_evaluation_predictions
   
   forecast_it, ts_it = make_evaluation_predictions(
       dataset=test_data,  # test dataset
       predictor=predictor,  # predictor
       num_eval_samples=100  # number of samples for each time series
   )

   forecasts = list(forecast_it)
   tss = list(ts_it)
   ```

5. **Extract and process the predictions:**

   ```python
   for forecast in forecasts:
       print(forecast.mean)  # Display the mean forecast
       print(forecast.quantiles)  # Display the quantiles forecast
   ```

### Full Example Code

```python
import os
import torch
from gluonts.torch.model.deepar.lightning_module import DeepARLightningModule
from gluonts.torch.model.deepar import DeepAREstimator
from gluonts.dataset.common import ListDataset
from gluonts.evaluation import make_evaluation_predictions
import pandas as pd
from datetime import datetime

# Sample data setup
time_series_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # Replace with your actual data
time_freq = 'D'  # Adjust frequency as per your data
prediction_length = 5  # Adjust prediction length
context_length = 5
num_hidden_dimensions=[40]  # Adjust hidden dimensions as per your model
best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')
trainer_kwargs={"max_epochs": 10}

if not TRAINING:
    # Load the model from the checkpoint
    loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
    print("Model loaded correctly from checkpoint.")
    
    # Prepare test data
    df = pd.DataFrame({
        "start": [datetime(2023, 1, 1)],  # Replace with your start date
        "target": [time_series_data] # Replace with your time series data
    })

    test_data = ListDataset(
        [{"start": row["start"], "target": row["target"]} for _, row in df.iterrows()],
        freq=time_freq
    )
    
    # Estimator to create predictor
    estimator = DeepAREstimator(
        freq=time_freq,
        prediction_length=prediction_length,
        context_length=context_length,
        num_hidden_dimensions=num_hidden_dimensions,
        trainer_kwargs=trainer_kwargs
    )

    predictor = estimator.create_predictor(loaded_model)

    # Make predictions
    forecast_it, ts_it = make_evaluation_predictions(
        dataset=test_data,
        predictor=predictor,
        num_eval_samples=100
    )

    forecasts = list(forecast_it)
    tss = list(ts_it)
    
    # Extract and process forecasts
    for forecast in forecasts:
        print("Mean forecast:", forecast.mean)
        print("Quantiles forecast:", forecast.quantiles)
```

This example provides a full workflow for loading a trained model from a checkpoint and making predictions on new data. Make sure you replace the sample data and paths with your actual data and paths.

from gluonts.torch.model.deepar.lightning_module import DeepARLightningModule

if not TRAINING:
    best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')
    loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
    predictor = estimator.create_predictor(loaded_model)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[45], line 6
      4 best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')
      5 loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
----> 6 predictor = estimator.create_predictor(loaded_model)

TypeError: DeepAREstimator.create_predictor() missing 1 required positional argument: 'module'

The `DeepAREstimator`'s `create_predictor` method expects the trained model module as its argument. However, you're calling it without specifying the required argument. Let's break down the proper way to use this method for creating a predictor.

### Key Steps to Correct the Issue:

1. **Initialize the Estimator:** Ensure the `DeepAREstimator` is correctly initialized.
2. **Create and Use the Predictor:** Call the `create_predictor` method with the correct arguments, passing the loaded model.

Here is the corrected example:

```python
import os
import torch
from gluonts.torch.model.deepar import DeepAREstimator
from gluonts.torch.model.deepar.lightning_module import DeepARLightningModule
from gluonts.dataset.common import ListDataset
from gluonts.evaluation import make_evaluation_predictions
import pandas as pd
from datetime import datetime

# Sample data setup
time_series_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # Replace with your actual data
time_freq = 'D'  # Adjust frequency as per your data
prediction_length = 5  # Adjust prediction length
context_length = 5
num_hidden_dimensions = [40]  # Adjust hidden dimensions as per your model
checkpoint_path = "path/to/checkpoint"  # Replace with your actual path
best_checkpoint_path = os.path.join(checkpoint_path, 'epoch=44-step=4500.ckpt')
trainer_kwargs = {"max_epochs": 10}

if not TRAINING:
    # Load the model from the checkpoint
    loaded_model = DeepARLightningModule.load_from_checkpoint(best_checkpoint_path)
    print("Model loaded correctly from checkpoint.")
    
    # Initialize the estimator
    estimator = DeepAREstimator(
        freq=time_freq,
        prediction_length=prediction_length,
        context_length=context_length,
        num_hidden_dimensions=num_hidden_dimensions,
        trainer_kwargs=trainer_kwargs
    )

    # Create the predictor using the trained module
    predictor = estimator.create_predictor(loaded_model)

    # Prepare test data
    df = pd.DataFrame({
        "start": [datetime(2023, 1, 1)],  # Replace with your start date
        "target": [time_series_data]  # Replace with your time series data
    })

    test_data = ListDataset(
        [{"start": row["start"], "target": row["target"]} for _, row in df.iterrows()],
        freq=time_freq
    )

    # Make predictions
    forecast_it, ts_it = make_evaluation_predictions(
        dataset=test_data,
        predictor=predictor,
        num_eval_samples=100
    )

    forecasts = list(forecast_it)
    tss = list(ts_it)
    
    # Extract and process forecasts
    for forecast in forecasts:
        print("Mean forecast:", forecast.mean)
        print("Quantiles forecast:", forecast.quantiles)
```

### Explanation:

1. **Loading the Model:**
   - We load the model from the checkpoint using `DeepARLightningModule.load_from_checkpoint`.

2. **Initializing the Estimator:**
   - The `DeepAREstimator` is initialized with the necessary parameters.

3. **Creating the Predictor:**
   - We use the `estimator.create_predictor` method, passing the `loaded_model` as the required argument. This step will set up the predictor properly with the pre-trained model.

4. **Preparing the Test Data:**
   - Test data is prepared and formatted into a `ListDataset`.

5. **Making Predictions:**
   - Using `make_evaluation_predictions`, we generate predictions from the test data and the predictor.

6. **Processing Forecasts:**
   - The forecasts can be extracted and printed out.

This setup ensures that your model is correctly loaded and predictions are made efficiently. Make sure you change paths and placeholder data with your actual data and paths.

create an image of Draco Malfoy becomes a vegan and starts selling organic, cruelty-free products

While I can't create images directly, I can certainly help you visualize the concept! Imagine Draco Malfoy, once known for his haughty persona and pure-blood supremacy, now transformed into a dedicated vegan advocate. 

**Draco's Appearance:**
- Draco has a more approachable and relaxed demeanor.
- His hair, once perfectly slicked back, is now styled in a casual, slightly messy look.
- He wears eco-friendly, stylish clothing—perhaps a simple yet fashionable organic cotton shirt paired with sustainable jeans.
- On his wrist, he sports a bracelet made from recycled materials.

**Store Setting:**
- The store is bright and welcoming, with large windows allowing natural light to flood in.
- Shelves are lined with neatly organized, artisanal, and eco-conscious products.
- Products range from cruelty-free cosmetics and skincare to organic teas and plant-based snacks.
- Labels and packaging are minimalist, adorned with earthy tones and handwritten text showcasing their organic and cruelty-free status.

**Store Signage:**
- A beautifully crafted wooden sign hangs above the entrance with the store’s name: "Malfoy’s Green Emporium."
- Inside, informative posters highlight the benefits of vegan lifestyle and ethical consumerism.

**Audience Interaction:**
- Draco stands behind the counter, engaging warmly with customers, offering samples, and providing information on the ethical sourcing of the products.
- A small seating area near the window allows patrons to enjoy a vegan coffee or tea while reading pamphlets on sustainable living.

**Additional Touches:**
- In the background, soft instrumental music creates a calming atmosphere.
- The air is filled with the subtle, pleasant scent of essential oils.

This imagery perfectly captures the essence of Draco Malfoy's new passion for veganism and organic, cruelty-free products.