AI决策树算法（C++ 11）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <iostream>

// 定义一个决策树节点
struct TreeNode {
    std::string value;
    TreeNode* left;
    TreeNode* right;

    TreeNode(std::string val) {
        value = val;
        left = nullptr;
        right = nullptr;
    }
};

// 决策树的预测函数
std::string predict(TreeNode* root, std::string input) {
    if (root == nullptr) {
        return "";
    }

    if (root->left == nullptr && root->right == nullptr) {
        return root->value;
    }

    std::string feature = root->value;
    if (input == feature) {
        return predict(root->left, input);
    } else {
        return predict(root->right, input);
    }
}

int main() {
    // 构建一个简单的决策树
    TreeNode* root = new TreeNode("Outlook");
    root->left = new TreeNode("Sunny");
    root->right = new TreeNode("Rainy");
    root->left->left = new TreeNode("Hot");
    root->left->right = new TreeNode("Cool");
    root->right->left = new TreeNode("Windy");
    root->right->right = new TreeNode("Humid");

    // 输入一个特征，预测结果
    std::string input = "Sunny";
    std::string result = predict(root, input);
    std::cout << "预测结果: " << result << std::endl;

    // 释放内存
    delete root->left->left;
    delete root->left->right;
    delete root->right->left;
    delete root->right->right;
    delete root->left;
    delete root->right;
    delete root;

    return 0;
}
使用tensorflow库来实现一个简单的神经网络模型的训练和预测
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
#include <tensorflow/c/c_api.h>

int main() {
    // 创建一个tensorflow会话
    TF_SessionOptions* session_options = TF_NewSessionOptions();
    TF_Session* session = TF_NewSession(session_options, tf_status);

    // 加载模型
    TF_Graph* graph = TF_NewGraph();
    TF_Status* status = TF_NewStatus();
    const char* model_path = "model.pb";
    TF_Buffer* graph_def = read_model_from_file(model_path);
    TF_ImportGraphDefOptions* import_options = TF_NewImportGraphDefOptions();
    TF_GraphImportGraphDef(graph, graph_def, import_options, status);
    TF_DeleteBuffer(graph_def);
    TF_DeleteImportGraphDefOptions(import_options);

    // 创建输入tensor和输出tensor
    TF_Output input_op = {TF_GraphOperationByName(graph, "input"), 0};
    TF_Output output_op = {TF_GraphOperationByName(graph, "output"), 0};
    TF_Tensor* input_tensor = create_input_tensor();

    // 运行模型
    TF_Tensor* output_tensor = nullptr;
    TF_SessionRun(session, nullptr, &input_op, &input_tensor, 1, &output_op, &output_tensor, 1, nullptr, 0, nullptr, status);

    // 处理输出结果
    float* output_data = static_cast<float*>(TF_TensorData(output_tensor));
    std::cout << "预测结果: " << output_data[0] << std::endl;

    // 释放资源
    TF_DeleteTensor(input_tensor);
    TF_DeleteTensor(output_tensor);
    TF_DeleteStatus(status);
    TF_DeleteGraph(graph);
    TF_CloseSession(session, status);
    TF_DeleteSession(session, status);
    TF_DeleteSessionOptions(session_options);

    return 0;
}

———————— Powered by Shihaoran ————————————————-