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 niestandardowe operatory w Lakeflow Designer.

Overview

Ten poradnik przeprowadza Cię przez tworzenie niestandardowego operatora za pomocą Python UDF. 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

Requirements

• Dostęp do Lakeflow Designer w przestrzeni roboczej z Unity Catalog. Zobacz Wymagania wstępne.
• USE CATALOG w katalogu main, oraz CREATE SCHEMA na main, lub USE SCHEMA oraz CREATE FUNCTION na istniejącym main.example_output schemacie. Aby użyć innego katalogu lub schematu, zastąp main.example_output w całym tekście. Zobacz odniesienie dotyczące uprawnień Unity Catalog.
• Zasób obliczeniowy, który może uruchamiać unity Catalog Python UDF-y. Zobacz funkcje definiowane przez użytkownika (UDF) w językach SQL i Python w Unity Catalog.

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: custom-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

Aby uzyskać wszystkie dostępne właściwości, typy danych, widżety i opcje, zobacz odniesienie do niestandardowego operatora YAML.

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: custom-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 .custom_operators.yaml:

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

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>`;

Krok 7: Użyj operatora w Lakeflow Designer

1. W przygotowaniu danych wizualnych otwórz menu Operatorów w lewym panelu i znajdź operatora Compound Amount .
2. Przeciągnij operator na obszar roboczy i podłącz do niego wejście.
3. Kliknij dwukrotnie operatora, aby otworzyć panel konfiguracyjny, a następnie wypełnij jego pola.
4. Wybierz operatora, aby podglądać jego wyniki w panelu wyjściowym.

Panel konfiguracyjny operatora obejmuje:

• 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.

Dodatkowe zasoby

• Operatorzy niestandardowi w Lakeflow Designer
• Pisanie logiki dla niestandardowych operatorów Lakeflow Designer
• Niestandardowa referencja operatora YAML