Samouczek: operator kalkulatora odsetek złożonych

W tym samouczku utworzysz operator UDF w języku Python dla narzędzia Lakeflow Designer, który oblicza odsetki składane. Skorzystaj z tego przykładu, aby poznać podstawy tworzenia operatorów, które przekształcają pojedyncze wartości lub kolumny. Aby dowiedzieć się więcej, zobacz Operatory zdefiniowane przez użytkownika w programie Lakeflow Designer.

Overview

W tym samouczku opisano krok po kroku, jak utworzyć operator zdefiniowany przez użytkownika przy użyciu funkcji UDF języka Python. Operator oblicza przyszłą wartość inwestycji przy użyciu formuły odsetek złożonych, A = P × (1 + r/n)^(n×t)gdzie:

  • P = Kapitał początkowy (kwota początkowa)
  • r = roczna stopa procentowa (jako dziesiętna)
  • n = liczba okresów kapitalizacji w ciągu roku
  • t = czas w latach

Krok 1: Pisanie i testowanie funkcji Python

Najpierw zdefiniuj podstawową funkcję Python, która wykonuje obliczenia. Przetestuj to w komórce notatnika, aby upewnić się, że działa poprawnie.

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)

Przetestuj funkcję na przykładowej inwestycji: 1 000 USD przy rocznej stopie 5%, kumulowanej miesięcznie przez 10 lat. Wynik powinien być mniej więcej 1647.01.

compound_amount(1000, 0.05, 12, 10)

Krok 2. Tworzenie kodu YAML dla operatora

Konfiguracja YAML definiuje sposób wyświetlania operatora w projektancie lakeflow. Dla tego operatora:

  • Principal korzysta z widżetu expression, aby użytkownicy mogli wybrać kolumnę w swoich danych
  • Roczna stawka, związki na rok i lata używają number widżetów z wartościami domyślnymi i ograniczeniami
  • Operator ma jeden port wejściowy, który dostarcza dane kolumn dla parametru wyrażenia
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

Zobacz Dokumentację YAML operatora zdefiniowanego przez użytkownika , aby zapoznać się z kompleksowym przewodnikiem dotyczącym wszystkich dostępnych właściwości, typów danych, widżetów i opcji.

Krok 3. Utwórz funkcję w Unity Catalog

Połącz schemat YAML i funkcję w Pythonie w pojedynczej instrukcji CREATE FUNCTION. Konfiguracja YAML znajduje się w docstringu na początku ciała funkcji.

Przykład tworzy funkcję w main.example_output. Najpierw stwórz schemat, jeśli nie istnieje:

CREATE SCHEMA IF NOT EXISTS main.example_output

CREATE OR REPLACE FUNCTION main.example_output.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)
$$

Krok 4. Testowanie funkcji

Testuj funkcję UC bezpośrednio za pomocą SQL. Te zapytania sprawdzają trzy scenariusze:

  • 1000 dolarów przy 5% rocznie, kapitalizowanych co miesiąc przez 10 lat, co daje około 1647.01
  • 1000 dolarów przy oprocentowaniu 5% z roczną kapitalizacją przez 1 rok, co daje 1050.00
  • 1 000 dolarów przy 15% rocznie, kapitalizowanych miesięcznie przez 1 rok, co daje w przybliżeniu 1160.75
SELECT main.example_output.compound_amount(1000, 0.05, 12, 10);
SELECT main.example_output.compound_amount(1000, 0.05, 1, 1);
SELECT main.example_output.compound_amount(1000, 0.15, 12, 1);

Krok 5. Rejestrowanie operatora

Dodaj operator do pliku .user_defined_operators.yaml:

operators:
  - catalog: main
    schema: example_output
    functionName: compound_amount

Note

Jeśli zdefiniujesz ten plik w folderze użytkownika, zostanie on wyświetlony tylko dla Ciebie. Aby uzyskać więcej informacji, zobacz Jak sprawić, by operator był wykrywalny.

Krok 6. Konfigurowanie uprawnień

Udziel dostępu użytkownikom, którzy muszą używać tego operatora:

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

Używanie operatora w programie Lakeflow Designer

Po zarejestrowaniu operator pojawi się w narzędziu Lakeflow Designer z:

  • Lista rozwijana do wybrania kolumny głównej z danych wejściowych
  • Liczba danych wejściowych dla częstotliwości, częstotliwości złożonej i lat (z rozsądnymi wartościami domyślnymi)

Użytkownicy mogą zastosować tego operatora, aby obliczyć przyszłe wartości dla całych kolumn danych inwestycyjnych.

  • Last updated on