Пример #1
0
void ForestClassification::loadFromFileInternal(std::ifstream& infile) {

    // Read number of variables
    size_t num_variables_saved;
    infile.read((char*) &num_variables_saved, sizeof(num_variables_saved));

    // Read treetype
    TreeType treetype;
    infile.read((char*) &treetype, sizeof(treetype));
    if (treetype != TREE_CLASSIFICATION) {
        throw std::runtime_error("Wrong treetype. Loaded file is not a classification forest.");
    }

    // Read class_values
    readVector1D(class_values, infile);

    for (size_t i = 0; i < num_trees; ++i) {

        // Read data
        std::vector<std::vector<size_t>> child_nodeIDs;
        readVector2D(child_nodeIDs, infile);
        std::vector<size_t> split_varIDs;
        readVector1D(split_varIDs, infile);
        std::vector<double> split_values;
        readVector1D(split_values, infile);

        // If dependent variable not in test data, change variable IDs accordingly
        if (num_variables_saved > num_variables) {
            for (auto& varID : split_varIDs) {
                if (varID >= dependent_varID) {
                    --varID;
                }
            }
        }

        // Create tree
        Tree* tree = new TreeClassification(child_nodeIDs, split_varIDs, split_values, &class_values, &response_classIDs,
                                            &is_ordered_variable);
        trees.push_back(tree);
    }
}
Пример #2
0
void ForestSurvival::loadFromFileInternal(std::ifstream& infile) {

  // Read number of variables
  size_t num_variables_saved;
  infile.read((char*) &num_variables_saved, sizeof(num_variables_saved));

  // Read treetype
  TreeType treetype;
  infile.read((char*) &treetype, sizeof(treetype));
  if (treetype != TREE_SURVIVAL) {
    throw std::runtime_error("Wrong treetype. Loaded file is not a survival forest.");
  }

  // Read status_varID
  infile.read((char*) &status_varID, sizeof(status_varID));

  // Read unique timepoints
  unique_timepoints.clear();
  readVector1D(unique_timepoints, infile);

  for (size_t i = 0; i < num_trees; ++i) {

    // Read data
    std::vector<std::vector<size_t>> child_nodeIDs;
    readVector2D(child_nodeIDs, infile);
    std::vector<size_t> split_varIDs;
    readVector1D(split_varIDs, infile);
    std::vector<double> split_values;
    readVector1D(split_values, infile);

    // Read chf
    std::vector<size_t> terminal_nodes;
    readVector1D(terminal_nodes, infile);
    std::vector<std::vector<double>> chf_vector;
    readVector2D(chf_vector, infile);

    // Convert chf to vector with empty elements for non-terminal nodes
    std::vector<std::vector<double>> chf;
    chf.resize(child_nodeIDs[0].size(), std::vector<double>());
//    for (size_t i = 0; i < child_nodeIDs.size(); ++i) {
//      chf.push_back(std::vector<double>());
//    }
    for (size_t j = 0; j < terminal_nodes.size(); ++j) {
      chf[terminal_nodes[j]] = chf_vector[j];
    }

    // If dependent variable not in test data, change variable IDs accordingly
    if (num_variables_saved > num_variables) {
      for (auto& varID : split_varIDs) {
        if (varID >= dependent_varID) {
          --varID;
        }
      }
    }
    if (num_variables_saved > num_variables + 1) {
      for (auto& varID : split_varIDs) {
        if (varID >= status_varID) {
          --varID;
        }
      }
    }

    // Create tree
    Tree* tree = new TreeSurvival(child_nodeIDs, split_varIDs, split_values, chf, &unique_timepoints,
        &response_timepointIDs, &is_ordered_variable);
    trees.push_back(tree);
  }
}