machine_learning

Hôm qua

Library "machine_learning"

euclidean(a, b)
  Parameters:
    a (array<float>)
    b (array<float>)

manhattan(a, b)
  Parameters:
    a (array<float>)
    b (array<float>)

cosine_similarity(a, b)
  Parameters:
    a (array<float>)
    b (array<float>)

cosine_distance(a, b)
  Parameters:
    a (array<float>)
    b (array<float>)

chebyshev(a, b)
  Parameters:
    a (array<float>)
    b (array<float>)

minkowski(a, b, p)
  Parameters:
    a (array<float>)
    b (array<float>)
    p (float)

dot_product(a, b)
  Parameters:
    a (array<float>)
    b (array<float>)

vector_norm(arr, p)
  Parameters:
    arr (array<float>)
    p (float)

sigmoid(x)
  Parameters:
    x (float)

sigmoid_derivative(x)
  Parameters:
    x (float)

tanh_derivative(x)
  Parameters:
    x (float)

relu(x)
  Parameters:
    x (float)

relu_derivative(x)
  Parameters:
    x (float)

leaky_relu(x, alpha)
  Parameters:
    x (float)
    alpha (float)

leaky_relu_derivative(x, alpha)
  Parameters:
    x (float)
    alpha (float)

elu(x, alpha)
  Parameters:
    x (float)
    alpha (float)

gelu(x)
  Parameters:
    x (float)

swish(x, beta)
  Parameters:
    x (float)
    beta (float)

softmax(arr)
  Parameters:
    arr (array<float>)

apply_activation(arr, activation_type, alpha)
  Parameters:
    arr (array<float>)
    activation_type (string)
    alpha (float)

normalize_minmax(arr, min_val, max_val)
  Parameters:
    arr (array<float>)
    min_val (float)
    max_val (float)

normalize_zscore(arr, mean_val, std_val)
  Parameters:
    arr (array<float>)
    mean_val (float)
    std_val (float)

normalize_matrix_cols(m)
  Parameters:
    m (matrix<float>)

scaler_fit(arr, method)
  Parameters:
    arr (array<float>)
    method (string)

scaler_fit_matrix(m, method)
  Parameters:
    m (matrix<float>)
    method (string)

scaler_transform(scaler, arr)
  Parameters:
    scaler (ml_scaler)
    arr (array<float>)

scaler_transform_matrix(scaler, m)
  Parameters:
    scaler (ml_scaler)
    m (matrix<float>)

clip(x, lo, hi)
  Parameters:
    x (float)
    lo (float)
    hi (float)

clip_array(arr, lo, hi)
  Parameters:
    arr (array<float>)
    lo (float)
    hi (float)

loss_mse(predicted, actual)
  Parameters:
    predicted (array<float>)
    actual (array<float>)

loss_rmse(predicted, actual)
  Parameters:
    predicted (array<float>)
    actual (array<float>)

loss_mae(predicted, actual)
  Parameters:
    predicted (array<float>)
    actual (array<float>)

loss_binary_crossentropy(predicted, actual)
  Parameters:
    predicted (array<float>)
    actual (array<float>)

loss_huber(predicted, actual, delta)
  Parameters:
    predicted (array<float>)
    actual (array<float>)
    delta (float)

gradient_step(weights, gradients, lr)
  Parameters:
    weights (array<float>)
    gradients (array<float>)
    lr (float)

adam_step(weights, gradients, m, v, lr, beta1, beta2, t, epsilon)
  Parameters:
    weights (array<float>)
    gradients (array<float>)
    m (array<float>)
    v (array<float>)
    lr (float)
    beta1 (float)
    beta2 (float)
    t (int)
    epsilon (float)

clip_gradients(gradients, max_norm)
  Parameters:
    gradients (array<float>)
    max_norm (float)

lr_decay(initial_lr, decay_rate, step)
  Parameters:
    initial_lr (float)
    decay_rate (float)
    step (int)

lr_cosine_annealing(initial_lr, min_lr, step, total_steps)
  Parameters:
    initial_lr (float)
    min_lr (float)
    step (int)
    total_steps (int)

knn_create(k, distance_type)
  Parameters:
    k (int)
    distance_type (string)

knn_fit(model, X, y)
  Parameters:
    model (ml_knn)
    X (matrix<float>)
    y (array<int>)

knn_predict(model, x)
  Parameters:
    model (ml_knn)
    x (array<float>)

knn_predict_proba(model, x)
  Parameters:
    model (ml_knn)
    x (array<float>)

knn_batch_predict(model, X)
  Parameters:
    model (ml_knn)
    X (matrix<float>)

linreg_fit(X, y)
  Parameters:
    X (matrix<float>)
    y (array<float>)

ridge_fit(X, y, lambda)
  Parameters:
    X (matrix<float>)
    y (array<float>)
    lambda (float)

linreg_predict(model, x)
  Parameters:
    model (ml_linreg)
    x (array<float>)

linreg_predict_batch(model, X)
  Parameters:
    model (ml_linreg)
    X (matrix<float>)

linreg_score(model, X, y)
  Parameters:
    model (ml_linreg)
    X (matrix<float>)
    y (array<float>)

logreg_create(n_features, learning_rate, iterations)
  Parameters:
    n_features (int)
    learning_rate (float)
    iterations (int)

logreg_fit(model, X, y)
  Parameters:
    model (ml_logreg)
    X (matrix<float>)
    y (array<int>)

logreg_predict_proba(model, x)
  Parameters:
    model (ml_logreg)
    x (array<float>)

logreg_predict(model, x, threshold)
  Parameters:
    model (ml_logreg)
    x (array<float>)
    threshold (float)

logreg_batch_predict(model, X, threshold)
  Parameters:
    model (ml_logreg)
    X (matrix<float>)
    threshold (float)

nb_create(n_classes)
  Parameters:
    n_classes (int)

nb_fit(model, X, y)
  Parameters:
    model (ml_nb)
    X (matrix<float>)
    y (array<int>)

nb_predict_proba(model, x)
  Parameters:
    model (ml_nb)
    x (array<float>)

nb_predict(model, x)
  Parameters:
    model (ml_nb)
    x (array<float>)

nn_create(layers, activation)
  Parameters:
    layers (array<int>)
    activation (string)

nn_forward(model, x)
  Parameters:
    model (ml_nn)
    x (array<float>)

nn_predict_class(model, x)
  Parameters:
    model (ml_nn)
    x (array<float>)

accuracy(y_true, y_pred)
  Parameters:
    y_true (array<int>)
    y_pred (array<int>)

precision(y_true, y_pred, positive_class)
  Parameters:
    y_true (array<int>)
    y_pred (array<int>)
    positive_class (int)

recall(y_true, y_pred, positive_class)
  Parameters:
    y_true (array<int>)
    y_pred (array<int>)
    positive_class (int)

f1_score(y_true, y_pred, positive_class)
  Parameters:
    y_true (array<int>)
    y_pred (array<int>)
    positive_class (int)

r_squared(y_true, y_pred)
  Parameters:
    y_true (array<float>)
    y_pred (array<float>)

mse(y_true, y_pred)
  Parameters:
    y_true (array<float>)
    y_pred (array<float>)

rmse(y_true, y_pred)
  Parameters:
    y_true (array<float>)
    y_pred (array<float>)

mae(y_true, y_pred)
  Parameters:
    y_true (array<float>)
    y_pred (array<float>)

confusion_matrix(y_true, y_pred, n_classes)
  Parameters:
    y_true (array<int>)
    y_pred (array<int>)
    n_classes (int)

sliding_window(data, window_size)
  Parameters:
    data (array<float>)
    window_size (int)

train_test_split(X, y, test_ratio)
  Parameters:
    X (matrix<float>)
    y (array<int>)
    test_ratio (float)

create_binary_labels(data, threshold)
  Parameters:
    data (array<float>)
    threshold (float)

lag_matrix(data, n_lags)
  Parameters:
    data (array<float>)
    n_lags (int)

signal_to_position(prediction, threshold_long, threshold_short)
  Parameters:
    prediction (float)
    threshold_long (float)
    threshold_short (float)

confidence_sizing(probability, max_size, min_confidence)
  Parameters:
    probability (float)
    max_size (float)
    min_confidence (float)

kelly_sizing(win_rate, avg_win, avg_loss, max_fraction)
  Parameters:
    win_rate (float)
    avg_win (float)
    avg_loss (float)
    max_fraction (float)

sharpe_ratio(returns, risk_free_rate)
  Parameters:
    returns (array<float>)
    risk_free_rate (float)

sortino_ratio(returns, risk_free_rate)
  Parameters:
    returns (array<float>)
    risk_free_rate (float)

max_drawdown(equity)
  Parameters:
    equity (array<float>)

atr_stop_loss(entry_price, atr, multiplier, is_long)
  Parameters:
    entry_price (float)
    atr (float)
    multiplier (float)
    is_long (bool)

risk_reward_take_profit(entry_price, stop_loss, ratio)
  Parameters:
    entry_price (float)
    stop_loss (float)
    ratio (float)

ensemble_vote(predictions)
  Parameters:
    predictions (array<int>)

ensemble_weighted_average(predictions, weights)
  Parameters:
    predictions (array<float>)
    weights (array<float>)

smooth_prediction(current, previous, alpha)
  Parameters:
    current (float)
    previous (float)
    alpha (float)

regime_classifier(volatility, trend_strength, vol_threshold, trend_threshold)
  Parameters:
    volatility (float)
    trend_strength (float)
    vol_threshold (float)
    trend_threshold (float)

ml_knn
  Fields:
    k (series int)
    distance_type (series string)
    X_train (matrix<float>)
    y_train (array<int>)

ml_linreg
  Fields:
    coefficients (array<float>)
    intercept (series float)
    lambda (series float)

ml_logreg
  Fields:
    weights (array<float>)
    bias (series float)
    learning_rate (series float)
    iterations (series int)

ml_nn
  Fields:
    layers (array<int>)
    weights (matrix<float>)
    biases (array<float>)
    weight_offsets (array<int>)
    bias_offsets (array<int>)
    activation (series string)

ml_nb
  Fields:
    class_priors (array<float>)
    means (matrix<float>)
    variances (matrix<float>)
    n_classes (series int)

ml_scaler
  Fields:
    min_vals (array<float>)
    max_vals (array<float>)
    means (array<float>)
    stds (array<float>)
    method (series string)

ml_train_result
  Fields:
    loss_history (array<float>)
    final_loss (series float)
    converged (series bool)
    iterations_run (series int)

ml_prediction
  Fields:
    class_label (series int)
    probability (series float)
    probabilities (array<float>)
    value (series float)

Hôm qua

Phát hành các Ghi chú

Machine Learning Library for PineScript v6

A comprehensive machine learning library providing classification, regression, neural networks, and trading utilities for TradingView's PineScript.

---
Constants

| Constant | Description |
|---------------------|--------------------------------------------------|
| EPSILON_TINY | Smallest epsilon (1e-15) for numerical stability |
| EPSILON_SMALL | Small epsilon (1e-10) for numerical stability |
| EPSILON_MEDIUM | Medium epsilon (1e-8) for numerical stability |
| LOG_2PI | Precomputed log(2*PI) for Gaussian calculations |
| MAX_ITERATIONS | Default max iterations for algorithms (100) |
| MAX_MATRIX_ELEMENTS | PineScript matrix element limit (100,000) |

---
User-Defined Types

| Type | Description |
|-----------------|---------------------------------------|
| ml_knn | K-Nearest Neighbors model |
| ml_linreg | Linear/Ridge regression model |
| ml_logreg | Logistic regression model |
| ml_nn | Multi-layer perceptron neural network |
| ml_nb | Gaussian Naive Bayes classifier |
| ml_scaler | Data scaler for normalization |
| ml_train_result | Training result with loss history |
| ml_prediction | Prediction result with probabilities |

---
Functions

Distance Functions

- euclidean(a, b) - Euclidean (L2) distance
- manhattan(a, b) - Manhattan (L1) distance
- cosine_similarity(a, b) - Cosine similarity (-1 to 1)
- cosine_distance(a, b) - Cosine distance (0 to 2)
- chebyshev(a, b) - Chebyshev (L-infinity) distance
- minkowski(a, b, p) - Minkowski distance of order p
- dot_product(a, b) - Dot product of two vectors
- vector_norm(arr, p) - P-norm of a vector

Activation Functions

- sigmoid(x) - Sigmoid activation (0 to 1)
- sigmoid_derivative(x) - Derivative of sigmoid
- tanh_derivative(x) - Derivative of tanh
- relu(x) - ReLU activation
- relu_derivative(x) - Derivative of ReLU
- leaky_relu(x, alpha) - Leaky ReLU activation
- leaky_relu_derivative(x, alpha) - Derivative of Leaky ReLU
- elu(x, alpha) - ELU activation
- gelu(x) - GELU activation
- swish(x, beta) - Swish activation
- softmax(arr) - Softmax for probability distribution
- apply_activation(arr, type, alpha) - Apply activation to array

Preprocessing / Scaling

- normalize_minmax(arr, min, max) - Min-max normalization [0,1]
- normalize_zscore(arr, mean, std) - Z-score standardization
- normalize_matrix_cols(m) - Standardize matrix columns
- scaler_fit(arr, method) - Fit scaler to array
- scaler_fit_matrix(m, method) - Fit scaler to matrix
- scaler_transform(scaler, arr) - Transform array with scaler
- scaler_transform_matrix(scaler, m) - Transform matrix with scaler
- clip(x, lo, hi) - Clip value to range
- clip_array(arr, lo, hi) - Clip array values

Loss Functions

- loss_mse(predicted, actual) - Mean Squared Error
- loss_rmse(predicted, actual) - Root Mean Squared Error
- loss_mae(predicted, actual) - Mean Absolute Error
- loss_binary_crossentropy(predicted, actual) - Binary Cross-Entropy
- loss_huber(predicted, actual, delta) - Huber loss

Optimization

- gradient_step(weights, gradients, lr) - SGD step
- adam_step(weights, gradients, m, v, lr, ...) - Adam optimizer step
- clip_gradients(gradients, max_norm) - Gradient clipping
- lr_decay(initial_lr, decay_rate, step) - Learning rate decay
- lr_cosine_annealing(initial_lr, min_lr, step, total) - Cosine annealing

K-Nearest Neighbors

- knn_create(k, distance_type) - Create KNN model
- knn_fit(model, X, y) - Fit KNN with training data
- knn_predict(model, x) - Predict single sample
- knn_predict_proba(model, x) - Predict class probabilities
- knn_batch_predict(model, X) - Predict multiple samples

Linear Regression

- linreg_fit(X, y) - Fit OLS linear regression
- ridge_fit(X, y, lambda) - Fit Ridge regression
- linreg_predict(model, x) - Predict single value
- linreg_predict_batch(model, X) - Predict multiple values
- linreg_score(model, X, y) - Calculate R-squared

Logistic Regression

- logreg_create(n_features, lr, iterations) - Create model
- logreg_fit(model, X, y) - Fit with gradient descent
- logreg_predict_proba(model, x) - Predict probability
- logreg_predict(model, x, threshold) - Predict class
- logreg_batch_predict(model, X, threshold) - Batch prediction

Naive Bayes

- nb_create(n_classes) - Create Gaussian Naive Bayes
- nb_fit(model, X, y) - Fit model
- nb_predict_proba(model, x) - Predict class probabilities
- nb_predict(model, x) - Predict class label

Neural Network

- nn_create(layers, activation) - Create MLP network
- nn_forward(model, x) - Forward propagation
- nn_predict_class(model, x) - Predict class label

Metrics

- accuracy(y_true, y_pred) - Classification accuracy
- precision(y_true, y_pred, positive_class) - Precision score
- recall(y_true, y_pred, positive_class) - Recall score
- f1_score(y_true, y_pred, positive_class) - F1 score
- r_squared(y_true, y_pred) - R-squared for regression
- mse(y_true, y_pred) - Mean Squared Error
- rmse(y_true, y_pred) - Root Mean Squared Error
- mae(y_true, y_pred) - Mean Absolute Error
- confusion_matrix(y_true, y_pred, n_classes) - Confusion matrix

Data Utilities

- sliding_window(data, window_size) - Create sliding window matrix
- train_test_split(X, y, test_ratio) - Split into train/test sets
- create_binary_labels(data, threshold) - Create binary labels
- lag_matrix(data, n_lags) - Create lag features

Trading Utilities

- signal_to_position(prediction, long_thresh, short_thresh) - Convert to position signal
- confidence_sizing(probability, max_size, min_confidence) - Size by confidence
- kelly_sizing(win_rate, avg_win, avg_loss, max_fraction) - Kelly Criterion sizing
- sharpe_ratio(returns, risk_free_rate) - Annualized Sharpe ratio
- sortino_ratio(returns, risk_free_rate) - Annualized Sortino ratio
- max_drawdown(equity) - Maximum drawdown
- atr_stop_loss(entry, atr, multiplier, is_long) - ATR-based stop loss
- risk_reward_take_profit(entry, stop_loss, ratio) - R:R take profit
- ensemble_vote(predictions) - Majority voting
- ensemble_weighted_average(predictions, weights) - Weighted average
- smooth_prediction(current, previous, alpha) - EMA smoothing
- regime_classifier(volatility, trend_strength, ...) - Market regime classification