Aller au contenu principal
Dernière mise à jour le

Didacticiel : Opérateur de calcul d'intérêt composé

Dans ce tutoriel, vous créez un opérateur Python UDF pour Lakeflow Designer qui calcule les intérêts composés. Utilisez cet exemple pour apprendre les bases de la création d'opérateurs qui transforment des valeurs ou des colonnes individuelles. Pour en savoir plus, consultez les opérateurs définis par l’utilisateur dans Lakeflow Designer.

Présentation​

Ce tutoriel vous guide à travers la création d'un opérateur défini par l'utilisateur en utilisant une UDF Python. L'opérateur calcule la valeur future d'un investissement en utilisant la formule d'intérêt composé, A = P × (1 + r/n)^(n×t), où :

  • P = Principal (montant initial)
  • r = Taux d'intérêt annuel (en décimal)
  • n = Nombre de périodes de capitalisation par an
  • t = Temps en années

Étape 1 : Écrire et tester la fonction Python​

Tout d'abord, définissez la fonction Python principale qui effectue le calcul. Testez-le dans une cellule de notebook pour vous assurer qu'il fonctionne correctement.

Python
def compound_amount(principal: float,
                    annual_rate: float,
                    compounds_per_year: int,
                    years: float) -> float:
    """
    Compute compound interest future value.

    A = P * (1 + r/n)^(n*t)

    principal: starting amount (P)
    annual_rate: annual nominal rate as decimal (r), e.g. 0.05
    compounds_per_year: compounding periods per year (n), e.g. 12
    years: time in years (t), can be fractional
    """
    import math
    if principal is None or annual_rate is None or compounds_per_year is None or years is None:
        return None

    if compounds_per_year <= 0:
        raise ValueError("compounds_per_year must be > 0")

    return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                 compounds_per_year * years)

Vous pouvez tester la fonction avec le code suivant :

Python
# $1,000 invested at 5% annual rate, compounded monthly for 10 years
compound_amount(1000, 0.05, 12, 10)
# Expected result: ~1647.01

Étape 2 : Créez le YAML pour l'opérateur​

La configuration YAML définit la manière dont l'opérateur apparaît dans Lakeflow Designer. Pour cet opérateur :

  • **Principal** utilise un expression widget afin que les utilisateurs puissent sélectionner une colonne de leurs données.
  • **Taux annuel**, **Composés par an** et **Années** utilisent number des widgets avec default et des contraintes.
  • L'opérateur dispose d'un port d'entrée qui fournit des données de colonne pour le paramètre d'expression.
YAML
schema: user-defined-operator-v0.1.0
type: uc-udf
name: Compound Amount
id: finance.compound_amount
version: '1.0.0'
description: >
  Computes the future value of an investment using compound interest.
  Formula: A = P * (1 + r/n)^(n*t)
config:
  type: object
  properties:
    principal:
      type: string
      format: expression
      title: Principal
      examples:
        - 'Select principal column or expression'
      x-ui:
        widget: expression
        port: in
    annual_rate:
      type: number
      title: Annual rate (decimal)
      default: 0.05
      minimum: 0
      examples:
        - 'e.g. 0.05 for 5%'
      x-ui:
        widget: number
    compounds_per_year:
      type: number
      title: Compounds per year
      default: 12
      minimum: 1
      examples:
        - 'e.g. 12 for monthly'
      x-ui:
        widget: number
    years:
      type: number
      title: Years
      default: 10
      minimum: 0
      examples:
        - 'Time in years (t)'
      x-ui:
        widget: number
  required:
    - principal
    - annual_rate
    - compounds_per_year
    - years
  additionalProperties: false
ports:
  input:
    - name: in
      title: Input
  output:
    - name: out
      title: Output

Voir référence YAML de l'opérateur défini par l'utilisateur pour un guide complet de toutes les propriétés, types de données, widgets et options disponibles.

Étape 3 : créez la fonction Unity Catalog​

Combinez le schéma YAML et la fonction Python en une seule instruction CREATE FUNCTION. La configuration YAML se trouve dans la docstring au début du corps de la fonction.

SQL
CREATE OR REPLACE FUNCTION main.my_schema.compound_amount(
    principal DOUBLE,
    annual_rate DOUBLE,
    compounds_per_year INT,
    years FLOAT)
RETURNS DOUBLE
LANGUAGE PYTHON
AS $$
  """
  schema: user-defined-operator-v0.1.0
  type: uc-udf
  name: Compound Amount
  id: finance.compound_amount
  version: "1.0.0"
  description: >
    Computes the future value of an investment using compound interest.
    Formula: A = P * (1 + r/n)^(n*t)
  config:
    type: object
    properties:
      principal:
        type: string
        format: expression
        title: Principal
        examples:
          - "Select principal column or expression"
        x-ui:
          widget: expression
          port: in
      annual_rate:
        type: number
        title: Annual rate (decimal)
        default: 0.05
        minimum: 0
        examples:
          - "e.g. 0.05 for 5%"
        x-ui:
          widget: number
      compounds_per_year:
        type: number
        title: Compounds per year
        default: 12
        minimum: 1
        examples:
          - "e.g. 12 for monthly"
        x-ui:
          widget: number
      years:
        type: number
        title: Years
        default: 10
        minimum: 0
        examples:
          - "Time in years (t)"
        x-ui:
          widget: number
    required:
      - principal
      - annual_rate
      - compounds_per_year
      - years
    additionalProperties: false
  ports:
    input:
      - name: in
        title: Input
    output:
      - name: out
        title: Output
  """

  def compound_amount(principal: float,
                      annual_rate: float,
                      compounds_per_year: int,
                      years: float) -> float:
      import math
      if principal is None or annual_rate is None or compounds_per_year is None or years is None:
          return None

      if compounds_per_year <= 0:
          raise ValueError("compounds_per_year must be > 0")

      return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                   compounds_per_year * years)

  return compound_amount(principal, annual_rate, compounds_per_year, years)
$$

Étape 4 : Testez la fonction​

Testez la fonction UC directement avec SQL :

SQL
-- Test 1: $1,000 at 5% compounded monthly for 10 years
SELECT main.my_schema.compound_amount(1000, 0.05, 12, 10)
-- Expected: ~1647.01

-- Test 2: $1,000 at 5% compounded annually for 1 year
SELECT main.my_schema.compound_amount(1000, 0.05, 1, 1)
-- Expected: 1050.00

-- Test 3: $1,000 at 15% compounded monthly for 1 year
SELECT main.my_schema.compound_amount(1000, 0.15, 12, 1)
-- Expected: ~1160.75

Étape 5 : Enregistrez l'opérateur​

Ajoutez l'opérateur à votre fichier .user_defined_operators.yaml :

YAML
operators:
  - catalog: main
    schema: my_schema
    functionName: compound_amount
remarque

Si vous définissez ce fichier dans votre dossier utilisateur, il n'apparaît que pour vous. Pour plus d'informations, consultez Rendez votre opérateur visible.

Étape 6 : Configurez les autorisations​

Accordez l’accès aux utilisateurs qui doivent utiliser cet opérateur :

SQL
GRANT USE SCHEMA ON SCHEMA main.my_schema TO `<user>`;
GRANT EXECUTE ON FUNCTION main.my_schema.compound_amount TO `<user>`;

Utilisez l'opérateur dans Lakeflow Designer​

Une fois enregistré, l'opérateur apparaît dans Lakeflow Designer avec :

  • Une liste déroulante pour sélectionner la colonne principale de vos données d'entrée
  • Champs numériques pour le taux, la fréquence de composition et les années (avec des default raisonnables)

Les utilisateurs peuvent appliquer cet opérateur pour calculer les valeurs futures de colonnes entières de données d'investissement.

Sur cette page