program.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2023, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <raft/core/handle.hpp>
#include <random>
 
#include "common.h"
 
namespace cuml {
namespace genetic {
 
struct program {
  explicit program();
 
  ~program();
 
  explicit program(const program& src);
 
  program& operator=(const program& src);
 
  node* nodes;
  int len;
  int depth;
  float raw_fitness_;
  metric_t metric;
  mutation_t mut_type;
};  // struct program
 
typedef program* program_t;
 
void execute(const raft::handle_t& h,
             const program_t& d_progs,
             const int n_rows,
             const int n_progs,
             const float* data,
             float* y_pred);
 
void compute_metric(const raft::handle_t& h,
                    int n_rows,
                    int n_progs,
                    const float* y,
                    const float* y_pred,
                    const float* w,
                    float* score,
                    const param& params);
 
void find_fitness(const raft::handle_t& h,
                  program_t& d_prog,
                  float* score,
                  const param& params,
                  const int n_rows,
                  const float* data,
                  const float* y,
                  const float* sample_weights);
 
void find_batched_fitness(const raft::handle_t& h,
                          int n_progs,
                          program_t& d_progs,
                          float* score,
                          const param& params,
                          const int n_rows,
                          const float* data,
                          const float* y,
                          const float* sample_weights);
 
void set_fitness(const raft::handle_t& h,
                 program_t& d_prog,
                 program& h_prog,
                 const param& params,
                 const int n_rows,
                 const float* data,
                 const float* y,
                 const float* sample_weights);
 
void set_batched_fitness(const raft::handle_t& h,
                         int n_progs,
                         program_t& d_progs,
                         std::vector<program>& h_progs,
                         const param& params,
                         const int n_rows,
                         const float* data,
                         const float* y,
                         const float* sample_weights);
 
float get_fitness(const program& prog, const param& params);
 
int get_depth(const program& p_out);
 
void build_program(program& p_out, const param& params, std::mt19937& rng);
 
void point_mutation(const program& prog, program& p_out, const param& params, std::mt19937& rng);
 
void crossover(const program& prog,
               const program& donor,
               program& p_out,
               const param& params,
               std::mt19937& rng);
 
void subtree_mutation(const program& prog, program& p_out, const param& params, std::mt19937& rng);
 
void hoist_mutation(const program& prog, program& p_out, const param& params, std::mt19937& rng);
}  // namespace genetic
}  // namespace cuml