GaussDB高智能--库内AI引擎：机器学习算法的训练和推理

Create Model price_model using logistic_regression Features size, lot Target price < 1000 from Houses;

Select address, Predict By price_model(Features size, lot), size from houses;

typedef struct Matrix {
    size_t  rows;
    size_t  columns;
    bool    transposed;
    size_t  allocated;
    float*  data; // consecutive rows, each as a sequence of values (one for each column)
    float   cache[MATRIX_CACHE]; // default is 64 entries
} Matrix;

typedef struct SGD {
    Plan         plan;
    AlgorithmML algorithm;
    int          targetcol;    // 0-index into the current projection
    int          max_seconds;    // maximum execution time
    // hyperparameters
    int          max_iterations; // maximum number of iterations
    int          batch_size;
    double       learning_rate;
    double       decay;          // (0:1], learning rate decay
    double       tolerance;      // [0:1], 0 means to run all iterations
    // for SVM
    double       lambda;         // regularization strength
} SGD;

typedef struct SGDState {
    ScanState               ss;     /* its first field is NodeTag */
    
    // tuple description
    TupleDesc               tupdesc;
    int                     n_features; // number of features
    // dependant var binary values
    int                     num_classes;
    Datum                   binary_classes[2];
    // training state
    bool                    done;   // when finished
    Matrix                  weights;
    double                  learning_rate;
    int                     n_iterations;
    int                     usecs;          // execution time
    int                     processed;  // tuples
    int                     discarded;
    float                   loss;
    Scores                  scores;
} SGDState;

typedef void (*f_sgd_gradients)(const SGD* sgd_node, const Matrix* features, const Matrix* dep_var, Matrix* weights, Matrix* gradients);
typedef double (*f_sgd_test)(const SGD* sgd_node, const Matrix* features, const Matrix* dep_var, const Matrix* weights, Scores* scores);
typedef void (*f_sgd_predict)(const SGD* sgd_node, const Matrix* features, const Matrix* weights, Matrix* predictions);
typedef struct SGDAlgorithm {
    const char*         name;
    int                 flags;
    int                 metrics;
    // values for binary algorithms, .g. (0,1) for logistic regression or (-1,1) for svm classifier
    float               min_class;
    float               max_class;
    // callbacks for hooks
    f_sgd_gradients     gradients_callback;  // update gradients
    f_sgd_test          test_callback;    // compute loss function
    f_sgd_predict       predict_callback;  // predict targets
} SGDAlgorithm;

sgd_predict:
Extract weights and classes
Extract tuple
Compute prediction (through predict callback of the algorithm)
If algorithm is not linear regression then
Extract classes
Convert prediction to one known class
  End if
Return result

typedef struct Centroid {
    IncrementalStatistics statistics;
    ArrayType* coordinates = nullptr;
    uint32_t id = 0U;
} Centroid;

struct KMeans{
    Plan plan;
    AlgorithmML algorithm;
    KMeansDescriptor description;
    KMeansHyperparameters parameters;
};

struct KMeansDescription{
    char const* name = nullptr;
    SeedingFunction seeding = KMEANS_RANDOM_SEED;
    DistanceFunction distance = KMEANS_L2_SQUARED;
    uint32_t n_features = 0U;
    uint32_t batch_size = 0U;
    uint32_t verbose = 0U;
}

struct KMeansHyperParameter{
    uint32_t num_centroids = 0U;
    uint32_t num_iterations = 0U;
    double tolerance = 0.000001;
};

typedef struct KMeansStateDescription{
    Centroid* centroids[2] = {nullptr};
    ArrayType* bbox_min = nullptr;
    ArrayType* bbox_max = nullptr;
    double (*distance)(double const*, double const*, uint32_t const dimension) = nullptr;
    IncrementalStatistics solution_statistics[2];
    uint64_t num_good_points = 0UL;
    uint64_t num_dead_points = 0UL;
    uint32_t current_iteration = 0U;
    uint32_t current_centroid = 0U;
    uint32_t dimension = 0U;
    uint32_t num_centroids = 0U;
    bool verbose = false;
} KMeansStateDescription

GradientDescent gd_pca = {
        {
                PCA,
                "pca",
                ALGORITHM_ML_UNSUPERVISED | ALGORITHM_ML_RESCANS_DATA,
                gd_metrics_loss,
                gd_get_hyperparameters_PCA,
                gd_make_hyperparameters_PCA,
                gd_update_hyperparameters,
                gd_create,
                gd_run,
                gd_end,
                gd_predict_prepare,
                gd_predict,
                PCA_explain
        },
        false,
        FLOAT8ARRAYOID, // default return type
        0., // default feature
        0.,
        0.,
        nullptr,
        gd_init_optimizer_PCA,
        nullptr,
        nullptr,
        nullptr,
        PCA_gradients,
        PCA_test,
        PCA_predict,
        nullptr,
};

PCA_predict:
Extract weights and classes
Extract tuple
Compute prediction (through predict callback of the algorithm)
If algorithm is classification then：
Extract classes
Convert prediction to one known class
  End if
Return result