慕ke Java版数据结构和算法+AI算法和技能

java

import Jama.Matrix;

public class LinearRegression {

    private double[] coefficients;

    // 添加偏置项（特征矩阵中插入全1列）

    private double[][] addIntercept(double[][] X) {

        int nSamples = X.length;

        int nFeatures = X[0].length;

        double[][] X_with_intercept = new double[nSamples][nFeatures + 1];

        for (int i = 0; i < nSamples; i++) {

            X_with_intercept[i][0] = 1; // 偏置项

            System.arraycopy(X[i], 0, X_with_intercept[i], 1, nFeatures);

        }

        return X_with_intercept;

    }

    // 计算系数（最小二乘法）

    private double[] calculateCoefficients(double[][] X, double[] y) {

        int nFeatures = X[0].length;

        double[][] XtX = new double[nFeatures][nFeatures];

        double[] XtY = new double[nFeatures];

        // 计算XtX和XtY

        for (int i = 0; i < X.length; i++) {

            for (int j = 0; j < nFeatures; j++) {

                for (int k = 0; k < nFeatures; k++) {

                    XtX[j][k] += X[i][j] * X[i][k];

                }

                XtY[j] += X[i][j] * y[i];

            }

        }

        // 解线性方程组

        return solveLinearEquation(XtX, XtY);

    }

    // 解线性方程组（使用Jama库）

    private double[] solveLinearEquation(double[][] A, double[] b) {

        Matrix matrixA = new Matrix(A);

        Matrix matrixB = new Matrix(b, b.length);

        Matrix solution = matrixA.solve(matrixB);

        double[] result = new double[solution.getRowDimension()];

        for (int i = 0; i < result.length; i++) {

            result[i] = solution.get(i, 0);

        }

        return result;

    }

    // 训练模型

    public void fit(double[][] X, double[] y) {

        double[][] X_with_intercept = addIntercept(X);

        coefficients = calculateCoefficients(X_with_intercept, y);

    }

    // 预测

    public double[] predict(double[][] X) {

        if (coefficients == null) {

            throw new IllegalStateException("模型尚未训练，请先调用fit方法。");

        }

        double[][] X_with_intercept = addIntercept(X);

        double[] predictions = new double[X_with_intercept.length];

        for (int i = 0; i < X_with_intercept.length; i++) {

            predictions[i] = calculatePrediction(X_with_intercept[i]);

        }

        return predictions;

    }

    // 计算单个预测值

    private double calculatePrediction(double[] features) {

        double prediction = 0;

        for (int i = 0; i < coefficients.length; i++) {

            prediction += features[i] * coefficients[i];

        }

        return prediction;

    }

    // 示例：训练并预测

    public static void main(String[] args) {

        LinearRegression model = new LinearRegression();

        // 训练数据（面积与房价）

        double[][] X = {{50}, {70}, {100}}; // 面积

        double[] y = {150, 200, 300};       // 房价

        model.fit(X, y);

        // 预测新数据

        double[][] testData = {{60}, {80}};

        double[] predictions = model.predict(testData);

        for (int i = 0; i < predictions.length; i++) {

            System.out.printf("预测房价（%d平方米）: %.2f万元%n", 

                             (int) testData[i][0], predictions[i]);

        }

    }

}

java

public class NeuralNetwork {

    private int numInputs;

    private int numHidden;

    private int numOutputs;

    private double[][] weightsInputToHidden;

    private double[][] weightsHiddenToOutput;

    // 初始化权重

    private void initializeWeights() {

        // 随机初始化权重（范围：-0.5到0.5）

        for (int i = 0; i < numInputs; i++) {

            for (int j = 0; j < numHidden; j++) {

                weightsInputToHidden[i][j] = Math.random() - 0.5;

            }

        }

        for (int i = 0; i < numHidden; i++) {

            for (int j = 0; j < numOutputs; j++) {

                weightsHiddenToOutput[i][j] = Math.random() - 0.5;

            }

        }

    }

    // 构造函数

    public NeuralNetwork(int numInputs, int numHidden, int numOutputs) {

        this.numInputs = numInputs;

        this.numHidden = numHidden;

        this.numOutputs = numOutputs;

        weightsInputToHidden = new double[numInputs][numHidden];

        weightsHiddenToOutput = new double[numHidden][numOutputs];

        initializeWeights();

    }

    // Sigmoid激活函数

    private double sigmoid(double x) {

        return 1 / (1 + Math.exp(-x));

    }

    // 前向传播

    public double[] predict(double[] inputs) {

        double[] hiddenOutputs = new double[numHidden];

        double[] outputs = new double[numOutputs];

        // 计算隐藏层输出

        for (int i = 0; i < numHidden; i++) {

            double sum = 0;

            for (int j = 0; j < numInputs; j++) {

                sum += inputs[j] * weightsInputToHidden[j][i];

            }

            hiddenOutputs[i] = sigmoid(sum);

        }

        // 计算输出层输出

        for (int i = 0; i < numOutputs; i++) {

            double sum = 0;

            for (int j = 0; j < numHidden; j++) {

                sum += hiddenOutputs[j] * weightsHiddenToOutput[j][i];

            }

            outputs[i] = sigmoid(sum);

        }

        return outputs;

    }

    // 示例：训练与预测（简化版，未实现反向传播）

    public static void main(String[] args) {

        NeuralNetwork nn = new NeuralNetwork(2, 3, 1); // 输入层2节点，隐藏层3节点，输出层1节点

        // 示例输入（假设为二分类问题）

        double[] input1 = {0, 0};

        double[] input2 = {1, 0};

        double[] input3 = {0, 1};

        double[] input4 = {1, 1};

        // 预测

        System.out.println("预测结果（输入[0,0]）: " + nn.predict(input1)[0]);

        System.out.println("预测结果（输入[1,0]）: " + nn.predict(input2)[0]);

        System.out.println("预测结果（输入[0,1]）: " + nn.predict(input3)[0]);

        System.out.println("预测结果（输入[1,1]）: " + nn.predict(input4)[0]);

    }

}