• 用c动态数组(实现权重矩阵可视化)实现手撸神经网络230902

    变量即内存、指针使用的架构原理：

    1、用结构struct记录 网络架构，如 float*** ws 为权重矩阵的指针（指针地址）；

    2、用 = (float*)malloc (Num * sizeof(float)) 给 具体变量分配内存；

    3、用 = (float**)malloc( Num* sizeof(float*) ) 给 指向 具体变量（一维数组）的指针…… 给分配 存放指针的变量……

    ……见代码

    1. // test22动态数组22多维数组23三维随机数230101.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    2.  
    3. #include 
    4. using namespace std;
    5.  
    6. typedef struct {
    7.     float*** ws;
    8.     int num1;
    9.     float** layer_outputs;
    10.  
    11. }NeuralN;
    12.  
    13. //初始化 神经网络的 weights权重矩阵等
    14. NeuralN init(int* t01, int num02) {
    15.     NeuralN nn;
    16.     nn.num1 = num02;
    17.  
    18.     nn.ws = (float***)malloc((num02 - 1) * sizeof(float**) );
    19.  
    20.     srand(time(NULL));
    21.  
    22.     cout << " [num02:" << num02 << endl;
    23.  
    24.     for (int i = 0; i <(num02 - 1); ++i) {
    25.         nn.ws[i] = (float**)malloc( t01[i] * sizeof(float*) );  //为指针分配内存
    26.         for (int j = 0; j < t01[i]; ++j) {
    27.             nn.ws[i][j] = (float*)malloc( t01[i  + 1  ] * sizeof(float) ); //为变量 分配内存
    28.             for (int k = 0; k < t01[i + 1]; k++) {
    29.                 //下一句 使用变量、即使用内存!（使用变量的内存）
    30.                 nn.ws[i][j][k] = (float)rand() / RAND_MAX;
    31.             }//for330k
    32.         }//for220j
    33.  
    34.     }//for110i
    35.  
    36.     return nn;
    37.  
    38. }//init
    39.  
    40. int main()
    41. {
    42.     int t001[] = { 2,8, 7,6, 1 ,2,1};
    43.  
    44. //#define Num4    4
    45.     //用 for(ForEach)的方法，计数、数出 动态数组长度
    46.     int Len_t001 = 0; for (int ii : t001) { ++Len_t001; }
    47.  
    48.     int Numm = Len_t001;
    49.     cout << "Numm:"<
    50.  
    51.     NeuralN nn = init(t001, Numm);// Num4);
    52.  
    53.     //
    54.     //    for(float  ii: (nn.ws[0][1]) )
    55.     //
    56.     //显示三维的 张量（即 三维数组 的 内容）
    57.     for (int i = 0; i < Numm - 1; ++i) {
    58. //        nn.layer_outputs[i + 1] = (float*)malloc(t001[i + 1] * sizeof(float));
    59.         printf("_{ i%d_", i);
    60.         for (int j = 0; j < t001[i + 1]; ++j) {
    61. //            nn.layer_outputs[i + 1][j] = 0;
    62.             printf("[j%d", j);
    63.             for (int k = 0; k < t001[i]; ++k) {
    64.  
    65.                 printf("(k%d(%.1f,", k, nn.ws[i][k][j]);
    66.             }//
    67.             printf("_} \n");
    68.  
    69.         }//for220j
    70.         printf("\n");
    71.     }//for110i
    72.  
    73.     std::cout << "Hello World!\n";
    74. }//main

    第二版本231001

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #define LEARNING_RATE  0.05//0.05
    7.  
    8. // Sigmoid and its derivative
    9. float sigmoid(float x) { return 1 / (1 + exp(-x));}
    10.  
    11. float sigmoid_derivative(float x) {
    12.     //float sig = sigmoid(x);
    13.     float sig = 1.0 / (exp(-x) + 1);
    14.     return sig * (1 - sig);
    15. }
    16.  
    17. typedef struct {
    18.     float*** weights;
    19.     int num_layers;
    20.     int* layer_sizes;
    21.     float** layer_outputs;
    22.     float** deltas;
    23. } NeuralNetwork;
    24.  
    25. NeuralNetwork initialize_nn(int* topology, int num_layers) {
    26.     NeuralNetwork nn;
    27.     nn.num_layers = num_layers;
    28.     nn.layer_sizes = topology;
    29.  
    30.     // Allocate memory for weights, layer outputs, and deltas
    31.     nn.weights = (float***)malloc((num_layers - 1) * sizeof(float**));
    32.     nn.layer_outputs = (float**)malloc(num_layers * sizeof(float*));
    33.     nn.deltas = (float**)malloc((num_layers - 1) * sizeof(float*));
    34.  
    35.     srand(time(NULL));
    36.     for (int i = 0; i < num_layers - 1; i++) {
    37.         nn.weights[i] = (float**)malloc(topology[i] * sizeof(float*));
    38.         nn.deltas[i] = (float*)malloc(topology[i + 1] * sizeof(float));
    39.         for (int j = 0; j < topology[i]; j++) {
    40.             nn.weights[i][j] = (float*)malloc(topology[i + 1] * sizeof(float));
    41.             for (int k = 0; k < topology[i + 1]; k++) {
    42.                 nn.weights[i][j][k] = ((float)rand() / RAND_MAX) * 2.0f - 1.0f;  // Random weights between -1 and 1
    43.             }
    44.         }//for220j
    45.     }//for110i
    46.     return nn;
    47. }//NeuralNetwork initialize_nn
    48.  
    49. float* feedforward(NeuralNetwork* nn, float* input) {
    50.     nn->layer_outputs[0] = input;
    51.     for (int i = 0; i < nn->num_layers - 1; i++) {
    52.         nn->layer_outputs[i + 1] = (float*)malloc(nn->layer_sizes[i + 1] * sizeof(float));
    53.         for (int j = 0; j < nn->layer_sizes[i + 1]; j++) {
    54.             nn->layer_outputs[i + 1][j] = 0;
    55.             for (int k = 0; k < nn->layer_sizes[i]; k++) {
    56. //                int A01 = 01;
    57.                 nn->layer_outputs[i + 1][j] += nn->layer_outputs[i][k] * nn->weights[i][k][j];
    58.  
    59.             }//for330k
    60.             nn->layer_outputs[i + 1][j] = sigmoid(nn->layer_outputs[i + 1][j]);
    61.         }//for220j
    62.     }//for110i
    63.     return nn->layer_outputs[nn->num_layers - 1];
    64. }//feedforward
    65.  
    66.  
    67. void feedLoss(NeuralNetwork* nn, float* target) {
    68.  
    69.     //显示权重矩阵:
    70.     //nn->layer_outputs[0] = input;
    71.     for (int i = 0; i < nn->num_layers - 1; i++) {
    72.         nn->layer_outputs[i + 1] = (float*)malloc(nn->layer_sizes[i + 1] * sizeof(float));
    73.         for (int j = 0; j < nn->layer_sizes[i + 1]; j++) {
    74.             nn->layer_outputs[i + 1][j] = 0;
    75.             for (int k = 0; k < nn->layer_sizes[i]; k++) {
    76.                 //                int A01 = 01;
    77.                 //nn->layer_outputs[i + 1][j] += nn->layer_outputs[i][k] * nn->weights[i][k][j];
    78.                 if (0 < nn->weights[i][k][j]) { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE); // FOREROUND_RED);
    79.             }
    80.                 else { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);   // BLUE);
    81.         }
    82.                         printf("(%.4f,", nn->weights[i][k][j]);
    83.                 //    A01 = 22;
    84.             }
    85.             printf("] \n");
    86.             nn->layer_outputs[i + 1][j] = sigmoid(nn->layer_outputs[i + 1][j]);
    87.         }//for220j
    88.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    89.         printf("};\n");
    90.     }//for110i
    91.     printf("_]};\n \n");
    92.     //
    93.  
    94.     int Last01 = nn->num_layers - 1;
    95.     // Calculate output layer deltas
    96.     for (int i = 0; i < nn->layer_sizes[Last01]; ++i ) {
    97.         float error = target[i] - nn->layer_outputs[Last01][i];
    98.             printf("[i%d:%f]  ", i, error);
    99. //        nn->deltas[Last01 - 1][i] = error * sigmoid_derivative(nn->layer_outputs[Last01][i]);
    100.     }
    101.  
    102.     // Calculate hidden layer deltas
    103.  
    104. }//backpropagate(NeuralNetwork* nn, float* target
    105.  
    106.  
    107. void backpropagate(NeuralNetwork* nn, float* target) {
    108.     int Last01 = nn->num_layers - 1;
    109.  
    110.     // Calculate output layer deltas//计算输出层变化
    111.     for (int i = 0; i < nn->layer_sizes[Last01]; i++) {
    112.         float error = target[i] - nn->layer_outputs[Last01][i];
    113.         nn->deltas[Last01 - 1][i] = error * sigmoid_derivative(nn->layer_outputs[Last01][i]);
    114.     }
    115.  
    116.     // Calculate hidden layer deltas//计算隐藏层变化
    117.     for (int i = Last01 - 1; i > 0; i--) {
    118.         for (int j = 0; j < nn->layer_sizes[i]; j++) {
    119.             float sum = 0;
    120.             for (int k = 0; k < nn->layer_sizes[i + 1]; k++) {
    121.                 sum += nn->weights[i][j][k] * nn->deltas[i][k];
    122.             }
    123.             nn->deltas[i - 1][j] = sum * sigmoid_derivative(nn->layer_outputs[i][j]);
    124.         }
    125.     }
    126.  
    127.     // Adjust weights
    128.     for (int i = 0; i < Last01; i++) {
    129.         for (int j = 0; j < nn->layer_sizes[i]; j++) {
    130.             for (int k = 0; k < nn->layer_sizes[i + 1]; k++) {
    131.                 nn->weights[i][j][k] += LEARNING_RATE * nn->deltas[i][k] * nn->layer_outputs[i][j];
    132.             }
    133.         }
    134.     }//
    135. }//backpropagate(NeuralNetwork* nn, float* target
    136.  
    137. void train(NeuralNetwork* nn, float inputs[][2], float* targets, int num_samples, int num_epochs) {
    138.     float* outputs;
    139.     bool whetherOutputLoss = 0;
    140. #define Num10000 100000
    141.     for (int epoch = 0; epoch < num_epochs; epoch++) {
    142.         if (0 == (epoch % Num10000)  ) { whetherOutputLoss = 1; }
    143.         for (int i = 0; i < num_samples; i++) {
    144.             //float* outputs = 
    145.             feedforward(nn, inputs[i]);
    146.             //
    147.             if (whetherOutputLoss) { feedLoss(nn, &targets[i]); } //当抽样时机到的时候,才显示
    148.             //
    149.             backpropagate(nn, &targets[i]);
    150.         }//
    151.         if (whetherOutputLoss) {printf("\n");
    152.                                 whetherOutputLoss = 0;
    153.                                 }
    154.  
    155.     }//for110i
    156. }//void train
    157.  
    158. int main() {
    159. //    int topology[] = { 2, 4, 3, 1 };
    160. //    NeuralNetwork nn = initialize_nn(topology, 4);
    161.  
    162. #define numLayer5   4
    163.     //5
    164.     //9
    165.     //6
    166.     //7
    167.     int topology[] = { 2, /*128,*/ /*64,*/ /*32,*/ /*16,*/  /*8,*/ 3, 2, 1 };
    168.     //                  1, 2,   3, 4,   5,  6, 7, 8, 9
    169.     NeuralNetwork nn = initialize_nn(topology, numLayer5);  // 4);
    170.  
    171. #define Num4 4
    172.     float inputs[Num4][2] = { {1, 1}, {0, 0}, {1, 0}, {0, 1} };
    173.     float targets[Num4] = { 0, 0, 1, 1 };
    174.  
    175. #define Num200000 200000
    176. //    train(&nn, inputs, targets, 4, 10000);
    177.     train(&nn, inputs, targets, Num4, Num200000);
    178.  
    179. //#define Num4 4
    180.  
    181.     float test_inputs[Num4][2] = { {0,0}, {1, 0}, {1, 1}, {0, 1} };
    182.     for (int i = 0; i < Num4; i++) {
    183.         float* output = feedforward(&nn, test_inputs[i]);
    184.         printf("Output for [%f, %f]: %f\n", test_inputs[i][0], test_inputs[i][1], output[0]);
    185.         free(output);
    186.     }
    187.  
    188.     // Free memory
    189.     for (int i = 0; i < nn.num_layers - 1; i++) {
    190.         for (int j = 0; j < nn.layer_sizes[i]; j++) {
    191.             free(nn.weights[i][j]);
    192.         }
    193.         free(nn.weights[i]);
    194.         free(nn.deltas[i]);
    195.     }
    196.     free(nn.weights);
    197.     free(nn.deltas);
    198.     free(nn.layer_outputs);
    199.  
    200.     return 0;
    201. }//main

    第一版本230901

    1. #include 
    2. #include 
    3. //#include 
    4. #include 
    5. #include 
    6.  
    7. #define LEARNING_RATE  0.05
    8. //0.05
    9.  
    10. // Sigmoid and its derivative
    11. float sigmoid(float x) { return 1 / (1 + exp(-x));}
    12.  
    13. float sigmoid_derivative(float x) {
    14.     //float sig = sigmoid(x);
    15.     float sig = 1.0 / (exp(-x) + 1);
    16.     return sig * (1 - sig);
    17. }
    18.  
    19. typedef struct {
    20.     float*** weights;
    21.     int num_layers;
    22.     int* layer_sizes;
    23.     float** layer_outputs;
    24.     float** deltas;
    25. } NeuralNetwork;
    26.  
    27. NeuralNetwork initialize_nn(int* topology, int num_layers) {
    28.     NeuralNetwork nn;
    29.     nn.num_layers = num_layers;
    30.     nn.layer_sizes = topology;
    31.  
    32.     // Allocate memory for weights, layer outputs, and deltas
    33.     nn.weights = (float***)malloc((num_layers - 1) * sizeof(float**));
    34.     nn.layer_outputs = (float**)malloc(num_layers * sizeof(float*));
    35.     nn.deltas = (float**)malloc((num_layers - 1) * sizeof(float*));
    36.  
    37.     srand(time(NULL));
    38.     for (int i = 0; i < num_layers - 1; i++) {
    39.         nn.weights[i] = (float**)malloc(topology[i] * sizeof(float*));
    40.         nn.deltas[i] = (float*)malloc(topology[i + 1] * sizeof(float));
    41.         for (int j = 0; j < topology[i]; j++) {
    42.             nn.weights[i][j] = (float*)malloc(topology[i + 1] * sizeof(float));
    43.             for (int k = 0; k < topology[i + 1]; k++) {
    44.                 nn.weights[i][j][k] = ((float)rand() / RAND_MAX) * 2.0f - 1.0f;  // Random weights between -1 and 1
    45.             }
    46.         }//for220j
    47.     }//for110i
    48.     return nn;
    49. }//NeuralNetwork initialize_nn
    50.  
    51. float* feedforward(NeuralNetwork* nn, float* input) {
    52.     nn->layer_outputs[0] = input;
    53.     for (int i = 0; i < nn->num_layers - 1; i++) {
    54.         nn->layer_outputs[i + 1] = (float*)malloc(nn->layer_sizes[i + 1] * sizeof(float));
    55.         for (int j = 0; j < nn->layer_sizes[i + 1]; j++) {
    56.             nn->layer_outputs[i + 1][j] = 0;
    57.             for (int k = 0; k < nn->layer_sizes[i]; k++) {
    58. //                int A01 = 01;
    59.                 nn->layer_outputs[i + 1][j] += nn->layer_outputs[i][k] * nn->weights[i][k][j];
    60.             //    A01 = 22;
    61.             }
    62.             nn->layer_outputs[i + 1][j] = sigmoid(nn->layer_outputs[i + 1][j]);
    63.         }//for220j
    64.     }//for110i
    65.     return nn->layer_outputs[nn->num_layers - 1];
    66. }//feedforward
    67.  
    68.  
    69. void feedLoss(NeuralNetwork* nn, float* target) {
    70.  
    71.     //显示权重矩阵:
    72.     //nn->layer_outputs[0] = input;
    73.     for (int i = 0; i < nn->num_layers - 1; i++) {
    74.         nn->layer_outputs[i + 1] = (float*)malloc(nn->layer_sizes[i + 1] * sizeof(float));
    75.         for (int j = 0; j < nn->layer_sizes[i + 1]; j++) {
    76.             nn->layer_outputs[i + 1][j] = 0;
    77.             for (int k = 0; k < nn->layer_sizes[i]; k++) {
    78.                 //                int A01 = 01;
    79.                 //nn->layer_outputs[i + 1][j] += nn->layer_outputs[i][k] * nn->weights[i][k][j];
    80.                 if (0 < nn->weights[i][k][j]) { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE); // FOREROUND_RED);
    81.             }
    82.                 else { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);   // BLUE);
    83.         }
    84.                         printf("(%.4f,", nn->weights[i][k][j]);
    85.                 //    A01 = 22;
    86.             }
    87.             printf("] \n");
    88.             nn->layer_outputs[i + 1][j] = sigmoid(nn->layer_outputs[i + 1][j]);
    89.         }//for220j
    90.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    91.         printf("};\n");
    92.     }//for110i
    93.     printf("_]};\n");
    94.     //
    95.  
    96.     int Last01 = nn->num_layers - 1;
    97.     // Calculate output layer deltas
    98.     for (int i = 0; i < nn->layer_sizes[Last01]; ++i ) {
    99.         float error = target[i] - nn->layer_outputs[Last01][i];
    100.             printf("[i%d:%f]  ", i, error);
    101. //        nn->deltas[Last01 - 1][i] = error * sigmoid_derivative(nn->layer_outputs[Last01][i]);
    102.     }
    103.  
    104.     // Calculate hidden layer deltas
    105.  
    106. }//backpropagate(NeuralNetwork* nn, float* target
    107.  
    108.  
    109. void backpropagate(NeuralNetwork* nn, float* target) {
    110.     int Last01 = nn->num_layers - 1;
    111.  
    112.     // Calculate output layer deltas//计算输出层变化
    113.     for (int i = 0; i < nn->layer_sizes[Last01]; i++) {
    114.         float error = target[i] - nn->layer_outputs[Last01][i];
    115.         nn->deltas[Last01 - 1][i] = error * sigmoid_derivative(nn->layer_outputs[Last01][i]);
    116.     }
    117.  
    118.     // Calculate hidden layer deltas//计算隐藏层变化
    119.     for (int i = Last01 - 1; i > 0; i--) {
    120.         for (int j = 0; j < nn->layer_sizes[i]; j++) {
    121.             float sum = 0;
    122.             for (int k = 0; k < nn->layer_sizes[i + 1]; k++) {
    123.                 sum += nn->weights[i][j][k] * nn->deltas[i][k];
    124.             }
    125.             nn->deltas[i - 1][j] = sum * sigmoid_derivative(nn->layer_outputs[i][j]);
    126.         }
    127.     }
    128.  
    129.     // Adjust weights
    130.     for (int i = 0; i < Last01; i++) {
    131.         for (int j = 0; j < nn->layer_sizes[i]; j++) {
    132.             for (int k = 0; k < nn->layer_sizes[i + 1]; k++) {
    133.                 nn->weights[i][j][k] += LEARNING_RATE * nn->deltas[i][k] * nn->layer_outputs[i][j];
    134.             }
    135.         }
    136.     }//
    137. }//backpropagate(NeuralNetwork* nn, float* target
    138.  
    139. void train(NeuralNetwork* nn, float inputs[][2], float* targets, int num_samples, int num_epochs) {
    140.     float* outputs;
    141.     bool whetherOutputLoss = 0;
    142. #define Num10000 50000
    143.     for (int epoch = 0; epoch < num_epochs; epoch++) {
    144.         if (0 == (epoch % Num10000)  ) { whetherOutputLoss = 1; }
    145.         for (int i = 0; i < num_samples; i++) {
    146.             //float* outputs = 
    147.             feedforward(nn, inputs[i]);
    148.             //
    149.             if (whetherOutputLoss) { feedLoss(nn, &targets[i]); }
    150.             //
    151.             backpropagate(nn, &targets[i]);
    152.         }//
    153.         if (whetherOutputLoss) {printf("\n");
    154.                                 whetherOutputLoss = 0;
    155.                                 }
    156.  
    157.     }//for110i
    158. }//void train
    159.  
    160. int main() {
    161. //    int topology[] = { 2, 4, 3, 1 };
    162. //    NeuralNetwork nn = initialize_nn(topology, 4);
    163.  
    164. #define numLayer5   4
    165.     //5
    166.     //9
    167.     //6
    168.     //7
    169.     int topology[] = { 2, /*128,*/ /*64,*/ /*32,*/ /*16,*/  /*8,*/ 3, 2, 1 };
    170.     //                  1, 2,   3, 4,   5,  6, 7, 8, 9
    171.     NeuralNetwork nn = initialize_nn(topology, numLayer5);  // 4);
    172.  
    173. #define Num4 4
    174.     float inputs[Num4][2] = { {1, 1}, {0, 0}, {1, 0}, {0, 1} };
    175.     float targets[Num4] = { 0, 0, 1, 1 };
    176.  
    177. #define Num200000 200000
    178. //    train(&nn, inputs, targets, 4, 10000);
    179.     train(&nn, inputs, targets, Num4, Num200000);
    180.  
    181. //#define Num4 4
    182.  
    183.     float test_inputs[Num4][2] = { {0,0}, {1, 0}, {1, 1}, {0, 1} };
    184.     for (int i = 0; i < Num4; i++) {
    185.         float* output = feedforward(&nn, test_inputs[i]);
    186.         printf("Output for [%f, %f]: %f\n", test_inputs[i][0], test_inputs[i][1], output[0]);
    187.         free(output);
    188.     }
    189.  
    190.     // Free memory
    191.     for (int i = 0; i < nn.num_layers - 1; i++) {
    192.         for (int j = 0; j < nn.layer_sizes[i]; j++) {
    193.             free(nn.weights[i][j]);
    194.         }
    195.         free(nn.weights[i]);
    196.         free(nn.deltas[i]);
    197.     }
    198.     free(nn.weights);
    199.     free(nn.deltas);
    200.     free(nn.layer_outputs);
    201.  
    202.     return 0;
    203. }//main

    1. (-0.1291,(0.7803,]
    2. (-0.6326,(0.5078,]
    3. };
    4. (-0.1854,(-0.5262,(0.8464,]
    5. (0.4913,(0.0774,(0.1000,]
    6. };
    7. (0.7582,(-0.7756,]
    8. };
    9. _]};
    10. [i0:-0.500000]  (0.5459,(0.0427,]
    11. (-0.1289,(0.7804,]
    12. (-0.6327,(0.5076,]
    13. };
    14. (-0.1859,(-0.5268,(0.8458,]
    15. (0.4919,(0.0780,(0.1005,]
    16. };
    17. (0.7553,(-0.7786,]
    18. };
    19. _]};
    20. [i0:-0.500000]  (0.5459,(0.0427,]
    21. (-0.1289,(0.7804,]
    22. (-0.6327,(0.5076,]
    23. };
    24. (-0.1864,(-0.5273,(0.8453,]
    25. (0.4924,(0.0785,(0.1011,]
    26. };
    27. (0.7524,(-0.7815,]
    28. };
    29. _]};
    30. [i0:0.500000]  (0.5458,(0.0427,]
    31. (-0.1291,(0.7804,]
    32. (-0.6326,(0.5076,]
    33. };
    34. (-0.1859,(-0.5268,(0.8458,]
    35. (0.4919,(0.0780,(0.1005,]
    36. };
    37. (0.7553,(-0.7786,]
    38. };
    39. _]};
    40. [i0:0.500000]
    41. (0.5679,(-0.3593,]
    42. (-0.8321,(1.1025,]
    43. (-0.5647,(0.1703,]
    44. };
    45. (-0.5384,(-1.1479,(0.8445,]
    46. (0.2658,(0.1725,(-0.1653,]
    47. };
    48. (1.1137,(-0.7693,]
    49. };
    50. _]};
    51. [i0:-0.500000]  (0.5682,(-0.3590,]
    52. (-0.8317,(1.1029,]
    53. (-0.5651,(0.1699,]
    54. };
    55. (-0.5391,(-1.1487,(0.8437,]
    56. (0.2663,(0.1730,(-0.1647,]
    57. };
    58. (1.1107,(-0.7722,]
    59. };
    60. _]};
    61. [i0:-0.500000]  (0.5682,(-0.3590,]
    62. (-0.8317,(1.1029,]
    63. (-0.5651,(0.1699,]
    64. };
    65. (-0.5399,(-1.1495,(0.8429,]
    66. (0.2668,(0.1735,(-0.1642,]
    67. };
    68. (1.1078,(-0.7751,]
    69. };
    70. _]};
    71. [i0:0.500000]  (0.5679,(-0.3590,]
    72. (-0.8321,(1.1029,]
    73. (-0.5647,(0.1699,]
    74. };
    75. (-0.5391,(-1.1487,(0.8437,]
    76. (0.2663,(0.1730,(-0.1647,]
    77. };
    78. (1.1107,(-0.7722,]
    79. };
    80. _]};
    81. [i0:0.500000]
    82. (6.5241,(-6.2462,]
    83. (-6.5361,(6.8406,]
    84. (0.2226,(0.6834,]
    85. };
    86. (-3.2613,(-3.6355,(2.0290,]
    87. (0.8144,(0.6639,(-0.7503,]
    88. };
    89. (4.2499,(-0.6959,]
    90. };
    91. _]};
    92. [i0:-0.500000]  (6.5288,(-6.2415,]
    93. (-6.5309,(6.8458,]
    94. (0.2196,(0.6804,]
    95. };
    96. (-3.2642,(-3.6385,(2.0261,]
    97. (0.8149,(0.6644,(-0.7498,]
    98. };
    99. (4.2469,(-0.6989,]
    100. };
    101. _]};
    102. [i0:-0.500000]  (6.5288,(-6.2415,]
    103. (-6.5309,(6.8458,]
    104. (0.2196,(0.6804,]
    105. };
    106. (-3.2671,(-3.6414,(2.0231,]
    107. (0.8154,(0.6649,(-0.7494,]
    108. };
    109. (4.2440,(-0.7018,]
    110. };
    111. _]};
    112. [i0:0.500000]  (6.5241,(-6.2415,]
    113. (-6.5361,(6.8458,]
    114. (0.2226,(0.6804,]
    115. };
    116. (-3.2642,(-3.6385,(2.0260,]
    117. (0.8149,(0.6644,(-0.7498,]
    118. };
    119. (4.2469,(-0.6989,]
    120. };
    121. _]};
    122. [i0:0.500000]
    123. (114.9971,(-113.4876,]
    124. (-112.8603,(114.3747,]
    125. (0.6990,(0.7116,]
    126. };
    127. (-31.6319,(-31.7725,(45.2379,]
    128. (11.9645,(11.6226,(-25.5372,]
    129. };
    130. (22.2722,(-15.6809,]
    131. };
    132. _]};
    133. [i0:-0.500000]  (115.2866,(-113.1981,]
    134. (-112.5715,(114.6635,]
    135. (0.2422,(0.2548,]
    136. };
    137. (-31.6473,(-31.7879,(45.2226,]
    138. (11.9753,(11.6335,(-25.5264,]
    139. };
    140. (22.2693,(-15.6838,]
    141. };
    142. _]};
    143. [i0:-0.500000]  (115.2866,(-113.1981,]
    144. (-112.5715,(114.6635,]
    145. (0.2422,(0.2548,]
    146. };
    147. (-31.6626,(-31.8033,(45.2072,]
    148. (11.9861,(11.6443,(-25.5155,]
    149. };
    150. (22.2663,(-15.6867,]
    151. };
    152. _]};
    153. [i0:0.500000]  (114.9968,(-113.1981,]
    154. (-112.8605,(114.6635,]
    155. (0.6987,(0.2548,]
    156. };
    157. (-31.6473,(-31.7879,(45.2226,]
    158. (11.9753,(11.6335,(-25.5264,]
    159. };
    160. (22.2693,(-15.6838,]
    161. };
    162. _]};
    163. [i0:0.500000]
    164. Output for [0.000000, 0.000000]: 0.005787
    165. Output for [1.000000, 0.000000]: 0.993864
    166. Output for [1.000000, 1.000000]: 0.011066
    167. Output for [0.000000, 1.000000]: 0.993822

  • 相关阅读:
    Kubernetes后台数据库etcd：安装部署etcd集群，数据备份与恢复
    react dispatch不生效的坑
    湖南源点调研 为什么中小企业产品上市前一定要做市场调研？
    这3种人适合学习人工智能，看看你在不在其中？
    使用Fiddler进行移动端抓包和模拟弱网络测试
    聊聊logback的LevelFilter
    C盘扩容好帮手——傲梅分区助手
    Python：了解python基础知识
    MyBatis的各种查询功能
    ArrayList分析1：循环、扩容、版本
  • 原文地址：https://blog.csdn.net/aw344/article/details/133579523