PagesParamètres d'entrée · 14 / 29

Paramètres d'entrée

Les paramètres d'entrée vous permettent de transformer des valeurs situées dans le code de votre stratégie (par exemple une longueur de rétrospective ou un nombre maximal de positions longues ouvertes) en réglages que vous définissez depuis les fenêtres d'exécution, sans modifier le fichier chaque fois que vous voulez essayer un nouveau nombre. Le même mécanisme params s'applique à Run backtest (Backtests), Bulk forward (AutoTrading / QuantCloud) et aux paramètres d'algo du Chart forward test. Test est décrit dans Exécution du code ; les balayages à exécutions multiples sont traités dans Optimisation. Les params ne sont pas renseignés pour un simple Run.

Cette page couvre les deux moitiés de ce flux :

Déclarer des params dans votre fichier Python
Relier ces params aux fenêtres d'exécution pour pouvoir les définir, les enregistrer et les optimiser (voir aussi Préréglages d'exécution (.qcs))

Fonctionnement en un coup d'œil

Dans votre fichier de stratégie, vous importez un objet spécial params et lisez ses attributs (par ex. params.PERIOD).
L'IDE analyse votre code pour découvrir ces noms et les liste dans la fenêtre d'exécution (Test, bulk forward ou chart forward).
Vous saisissez un type et une valeur pour chaque nom dans la boîte de dialogue (ou vous définissez un balayage lorsque vous optimisez).
Au démarrage de l'exécution, le moteur remplit params avec vos valeurs avant l'exécution de votre script ; les valeurs sont donc disponibles dès l'importation de votre fichier.

Les entrées sont renseignées pour les fenêtres Run backtest, Bulk forward et Chart forward test. Elles ne sont pas renseignées pour un simple Run (/ws/run) — utilisez des valeurs par défaut avec hasattr si vous voulez que le même fichier fonctionne des deux façons. Voir Cycle de vie d'une stratégie pour savoir quand les params sont visibles par les rappels.

Déclarer des params dans votre stratégie

Ajoutez un seul import et référencez chaque nom de paramètre comme attribut de params :

from quantcraft.inputs import params

PERIOD = params.PERIOD if hasattr(params, "PERIOD") else 14
MAX_OPEN_LONGS = params.MAX_OPEN_LONGS if hasattr(params, "MAX_OPEN_LONGS") else 3
USE_FILTER = params.USE_FILTER if hasattr(params, "USE_FILTER") else True
LABEL = params.LABEL if hasattr(params, "LABEL") else "default"

Quelques règles s'appliquent :

Écrivez-le sous la forme from quantcraft.inputs import params. L'expression régulière de découverte accepte aussi les anciennes formes from quantcraft.inputs_module import params et from ide.inputs_module import params afin que les scripts existants continuent de fonctionner — voir Référence — mais le nouveau code doit utiliser quantcraft.inputs. Ce doit être la forme from … import params : import quantcraft.inputs as inp n'est pas détecté, et l'onglet Script n'apparaîtra donc pas.
L'exécuteur applique les valeurs de la fenêtre avant le chargement de votre script d'entrée, ce qui suffit pour from quantcraft.inputs import params dans le fichier de stratégie.
params est un unique objet « vivant ». Chaque exécution remplace les valeurs qu'il contient ; il montre donc toujours les entrées de cette exécution — y compris dans les modules utilitaires qui l'ont importé lors d'une exécution forward précédente, et séparément pour des exécutions forward actives en même temps. Une exécution lancée sans entrées voit un params vide, jamais les valeurs de l'exécution précédente.
Chaque nom de paramètre doit être un identifiant Python valide (A–Z, a–z, 0–9, _, ne commençant pas par un chiffre) ; tout autre est ignoré.
Chaque entrée doit comporter un jeton littéral params.NAME dans le source afin que l'IDE puisse la découvrir. Le client recherche par expression régulière params.<identifiant> ; les noms référencés uniquement via getattr(params, "NAME", default) ne sont pas découverts et n'apparaîtront pas dans l'onglet Script. getattr(params, "NAME", default) fonctionne bien à l'exécution — conservez simplement un params.NAME littéral sur la même ligne pour la découverte.
Vous pouvez utiliser params.NAME n'importe où dans le fichier — au niveau supérieur, dans on_init, dans on_bar, etc. Chaque référence unique devient une entrée sur laquelle la boîte de dialogue vous interrogera.
Il n'y a pas de schéma dans le module lui-même : les noms que vous référencez constituent le schéma.

À éviter (le formulaire ne listera pas le paramètre) :

MA_PERIOD = getattr(params, "MA_PERIOD", 24)  # no params.MA_PERIOD token
PERIOD = 14  # no params reference

Idiomes courants :

def on_init():
    global lookback
    lookback = int(params.PERIOD)

def on_bar(bar_index, bar, fundamentals=None, symbol=None):
    if bar.bars_back < lookback:
        return
    ...

Astuce : lisez la valeur une seule fois dans une variable locale/globale pour ne pas payer des accès d'attribut à chaque barre.

Relier la fenêtre Test / backtest

Ouvrez la boîte de dialogue Test depuis la barre d'outils de l'éditeur (le bouton Test). Lorsque votre fichier déclare des entrées params.NAME, un onglet Script apparaît avec des lignes de paramètres et Optimize. L'IDE a déjà analysé votre fichier actif à la recherche des références params.NAME ; chaque paramètre utilisé apparaît donc sous forme de ligne.

Pour chaque ligne, vous définissez :

Colonne	Ce que vous saisissez
Parameter	Le nom (en lecture seule — il provient de votre code).
Type	L'un de `int`, `float`, `str`, `bool` (les alias `integer`, `number`, `boolean` sont aussi acceptés dans l'échange).
Value	La valeur à utiliser pour l'exécution.

Remarques sur les choix de Type :

int / integer — nombres entiers (par ex. 14) ; les séparateurs de milliers sont acceptés (1,000 → 1000).
float / number — décimaux (par ex. 0.5, 1e-3) ; les virgules dans les nombres sont supprimées.
bool / boolean — true / false, yes / no, y / n, on / off et 1 / 0 (quelle que soit la casse). Toute autre valeur arrête l'exécution avec invalid boolean: …. La fenêtre propose True/False.
str — texte libre, conservé tel quel (sans les espaces autour).

Au démarrage du backtest, la boîte de dialogue regroupe vos lignes et les envoie au moteur. Le moteur définit les valeurs sur params avant l'exécution de votre on_init() ; ainsi :

from quantcraft.inputs import params
PERIOD = params.PERIOD   # <- already filled by the time this line executes

Si un nom de paramètre n'a pas de ligne dans la boîte de dialogue (vous avez supprimé l'entrée, ou votre fichier référence un tout nouveau nom que vous n'avez pas encore défini), params n'aura pas cet attribut et une lecture brute de params.NAME lèvera AttributeError. Ajoutez la ligne dans la boîte de dialogue et relancez — ou utilisez le motif hasattr + valeur par défaut else présenté plus haut (qui conserve le jeton params.NAME pour la découverte).

Les valeurs de votre boîte de dialogue sont mémorisées d'une exécution à l'autre ; vous n'avez donc pas à les ressaisir à chaque fois. Enregistrez et rechargez des jeux complets de paramètres avec les Préréglages d'exécution (.qcs).

Optimiser les paramètres

Dans l'onglet Script, activez Optimize pour exécuter votre stratégie de nombreuses fois avec différentes combinaisons de paramètres. Choisissez Brute force ou Genetic :

Force brute

Pour chaque ligne de paramètre, la boîte de dialogue ajoute des colonnes Step et Max lorsque c'est pertinent :

int / float — définissez une grille discrète : valeur de départ → pas → max.
bool — true et false sont tous deux essayés.
str — maintenu fixe (les paramètres de type chaîne ne forment pas de grille).

Le moteur exécute chaque combinaison de ces valeurs discrètes et rapporte chaque exécution séparément dans la vue Test Results.

Utile pour de petites grilles (une poignée de paramètres avec quelques valeurs chacun). Les combinaisons explosent vite — gardez un espace de recherche modeste.

Génétique

Pour de plus grands espaces de recherche, passez à Genetic afin qu'une recherche évolutive trouve de bonnes combinaisons sans essayer chaque case :

Population size — nombre de combinaisons de paramètres évaluées à chaque génération.
Generations — nombre de générations à exécuter (chacune correspond à une population complète de backtests).
Elitism — meilleurs individus copiés sans modification dans la génération suivante.
Crossover rate (0–1) — probabilité que deux parents produisent un enfant mixte.
Mutation rate (0–1) — probabilité qu'un gène saute vers une autre valeur.
Fitness metric — métrique à optimiser (Sharpe, Sortino, rendement total, etc.).
Random seed (facultatif) — reproductibilité de la population et des opérateurs.

Les deux modes affichent la progression en direct dans le panneau de sortie (une barre de progression dans l'en-tête) et un bouton Stop pour mettre fin à une longue exécution.

Lorsque l'optimisation se termine, la vue Test Results affiche les exécutions triées selon votre métrique d'adéquation, et vous pouvez explorer chacune d'elles.

Conseils

Les noms sont découverts à partir de votre fichier : si une ligne n'apparaît pas, vérifiez vos références params.NAME et que vous importez params depuis quantcraft.inputs (les anciens chemins quantcraft.inputs_module et ide.inputs_module sont aussi reconnus, pour les scripts existants).
Gardez des noms en UPPER_SNAKE_CASE — par convention, ils se lisent comme des constantes dans votre code.
Indiquez des types cohérents dans la boîte de dialogue pour que la conversion fasse ce que vous attendez (par ex. ne définissez pas int pour une valeur comme 0.5).
Les booléens ne sont pas sensibles à la casse — True, true, 1, yes valent tous vrai.
Utilisez Optimize pour les recherches de paramètres, pas des scripts d'éditeur : la force brute est exhaustive, la génétique est destinée aux grands espaces.
Un simple Run ne renseigne pas les params : lorsque vous cliquez sur Run, params n'est pas rempli. Utilisez des valeurs par défaut hasattr (avec un jeton params.NAME littéral) si vous voulez que le même fichier fonctionne pour Run comme pour Test :

from quantcraft.inputs import params PERIOD = params.PERIOD if hasattr(params, "PERIOD") else 14
Les exécutions forward suivent les mêmes règles de découverte — les fenêtres bulk forward et chart forward recherchent params.NAME de la même manière que la boîte de dialogue de backtest.

8 min de lectureSuggérer une modification ↗