精华内容
下载资源
问答
  • 线性回归 代码实现

    2017-08-07 12:14:31
    线性回归,通过TensorFlow实现
  • 线性回归实现
  • 一维线性回归代码实现""" import torch from torch.autograd import Variable import matplotlib.pyplot as plt import torch.nn as nn import torch.optim as optim import numpy as np class ...
    """一维线性回归代码实现"""
    
    import torch
    from torch.autograd import Variable
    import matplotlib.pyplot as plt
    import torch.nn as nn
    import torch.optim as optim
    import numpy as np
    
    class LinearRegression(nn.Module):
        def __init__(self):
            super(LinearRegression, self).__init__()
            self.linear = nn.Linear(1,1)
    
    
        def forward(self, x):
            out = self.linear(x)
            return out
    
    
    
    if __name__ == '__main__':
        x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], [9.779], [6.182], [7.59], [2.167], [7.042], [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)
    
        y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], [3.366], [2.596], [2.53], [1.221], [2.827], [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)
    
        x_train = torch.from_numpy(x_train)
        y_train = torch.from_numpy(y_train)
    
        if torch.cuda.is_available():
            model = LinearRegression().cuda()
        else:
            model = LinearRegression()
    
        criterion = nn.MSELoss()
        optimizer = optim.SGD(model.parameters(), lr=1e-3)
    
    
        num_epochs = 1000
        for epoch in range(num_epochs):
            if torch.cuda.is_available():
                inputs = Variable(x_train).cuda()
                target = Variable(y_train).cuda()
            else:
                inputs = Variable(x_train)
                target = Variable(y_train)
    
            # forward
            out = model.forward(inputs)
            loss = criterion(out, target)
            # backward
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
            if(epoch+1)%20==0:
                print('Epoch[{}/{}], loss: {:.6f}'.format(epoch+1, num_epochs, loss.item()))
    
        model.eval()
        model.cpu()
        predict = model(Variable(x_train))
        predict = predict.data.numpy()
        plt.plot(x_train.numpy(), y_train.numpy(), 'ro', label='Original data')
        plt.plot(x_train.numpy(), predict, label='Fitting Line')
        plt.show()
    

     结果图

     

    展开全文
  • pyTorch非线性回归代码实现

    千次阅读 2019-12-05 11:17:32
    import torch from torch . autograd import Variable import torch . nn . functional as F import matplotlib . pyplot as ...运行上述代码,图形会绘制10次,最后的输出如下:
    import torch
    from torch.autograd import Variable
    import torch.nn.functional as F
    import matplotlib.pyplot as plt
    
    # 从-1到1均匀生成100个数据
    tensor_x = torch.linspace(-1, 1, 100)
    '''
    这里是把一维矩阵转二维矩阵,dim=1表示从tensor_x.shape的第1个下标维度添加1维
    tensor_x.shape 是一维矩阵,大小是100,没有方向
    添加后shape变成了(100, 1)
    '''
    x = torch.unsqueeze(tensor_x, dim=1)
    # y = x的平方加上一些噪点, torch.rand()是生成一串指定size,大于等于0小于1的数据
    y = x.pow(2) + 0.2*torch.rand(x.size())
    
    # x = Variable(x)
    # y = Variable(y)
    
    # plt.scatter(x.data.numpy(), y.data.numpy())
    # plt.show()
    
    k = True
    
    class Net(torch.nn.Module):
        '''
        这是一个三层的神经网络
        '''
        def __init__(self, n_feature, n_hidden, n_output):
            '''
            初始化
            :param n_feature: 特征数
            :param n_hidden: 隐藏层神经元个数
            :param n_output: 输出数
            '''
            super(Net, self).__init__()
            # 参数一是前一层网络神经元的个数,参数二是该网络层神经元的个数
            self.hidden = torch.nn.Linear(n_feature, n_hidden)
            self.predict = torch.nn.Linear(n_hidden, n_output)
    
        def forward(self, x):
            # relu 激活函数,把小于或等于0的数直接等于0。此时得到第二层的神经网络数据
            # x = F.relu(self.hidden(x))
            x = F.relu(self.hidden(x))
            # 得到第三层神经网络输出数据
            x = self.predict(x)
            return x
    
    # 创建一个三层的神经网络, 每层的神经元数量分别是1, 10 ,1
    net = Net(1, 10, 1)
    
    # SGD是一种优化器,net.parameters()是神经网络中的所有参数,并设置学习率
    optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
    # 定义损失函数, MSELoss代表均方差
    loss_func = torch.nn.MSELoss()
    
    # 让plt变成实时打印,打开交互模式
    plt.ion()
    plt.show()
    
    for t in range(100):
        # 调用搭建好的神经网络模型,得到预测值
        prediction = net(x)
        # 用定义好的损失函数,得出预测值和真实值的loss
        loss = loss_func(prediction, y)
    
        # 每次都需要把梯度将为0
        optimizer.zero_grad()
        # 误差反向传递
        loss.backward()
        # 调用优化器进行优化,将参数更新值施加到 net 的 parameters 上
        optimizer.step()
    
        if t % 10 == 0:
            # 清除当前座标轴
            plt.cla()
            plt.scatter(x.data.numpy(), y.data.numpy())
            # r- 是红色 lw 是线宽
            plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
            '''
            给图形添加标签,0.5, 0 表示X轴和Y轴坐标,
            'Loss=%.4f'%loss.data.numpy()表示标注的内容,
            .4f表示保留小数点后四位
            fontdict是设置字体大小和颜色
            '''
            plt.text(0.5, 0, 'Loss=%.4f'%loss.data.numpy(), fontdict={'size':20, 'color': 'red'})
            # 间隔多久再次进行绘图
            plt.pause(0.1)
    

    运行上述代码,图形会绘制10次,最后的输出如下:

    在这里插入图片描述

    展开全文
  • 线性回归代码实现(matlab)

    万次阅读 2018-08-11 15:29:00
    1 代价函数实现(cost function) function J = computeCost(X, y, theta) %COMPUTECOST Compute cost for linear regression % J = COMPUTECOST(X, y, theta) computes the cost of using theta as the %...

    1 代价函数实现(cost function)

     

    function J = computeCost(X, y, theta)
    %COMPUTECOST Compute cost for linear regression
    %   J = COMPUTECOST(X, y, theta) computes the cost of using theta as the
    %   parameter for linear regression to fit the data points in X and y
    
    % Initialize some useful values
    m = length(y); % number of training examples
    
    % You need to return the following variables correctly 
    J = 0; 
    
    % ====================== YOUR CODE HERE ======================
    % Instructions: Compute the cost of a particular choice of theta
    %               You should set J to the cost.
    
    predictions = X * theta;
    sqrErrors = (predictions-y) .^ 2;
    
    J = 1/(2*m) * sum(sqrErrors);
    
    
    
    % =========================================================================
    
    end
    predictions = X * theta;
    sqrErrors = (predictions-y) .^ 2;
    
    J = 1/(2*m) * sum(sqrErrors);
    
    
    
    % =========================================================================
    
    end
    

      1.1 详细解释

    转化成了向量(矩阵)形式,如果用其他的语言,用循环应该可以实现

    predictions = X * theta;        % 这里的大X是矩阵
    X * theta;        % 这里的大X是矩阵
    

      

     

    sqrErrors = (predictions-y) .^ 2;
    

      

    2 梯度下降

    function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters)
    %GRADIENTDESCENT Performs gradient descent to learn theta
    %   theta = GRADIENTDESENT(X, y, theta, alpha, num_iters) updates theta by 
    %   taking num_iters gradient steps with learning rate alpha
    
    % Initialize some useful values
    m = length(y); % number of training examples
    J_history = zeros(num_iters, 1);
    
    for iter = 1:num_iters
    
        % ====================== YOUR CODE HERE ======================
        % Instructions: Perform a single gradient step on the parameter vector
        %               theta. 
        %
        % Hint: While debugging, it can be useful to print out the values
        %       of the cost function (computeCost) and gradient here.
        %
        theta_temp = theta;
        for j = 1:size(X, 2)
            theta_temp(j) = theta(j)-alpha*(1/m)*(X*theta - y)' * X(:, j);
        end
        theta = theta_temp;
    
    
    
    
    
        % ============================================================
    
        % Save the cost J in every iteration    
        J_history(iter) = computeCost(X, y, theta);
    
    end
    
    end
     theta_temp = theta;
        for j = 1:size(X, 2)
            theta_temp(j) = theta(j)-alpha*(1/m)*(X*theta - y)' * X(:, j);
        end
        theta = theta_temp;
    
    
    
    
    
        % ============================================================
    
        % Save the cost J in every iteration    
        J_history(iter) = computeCost(X, y, theta);
    
    end
    
    end
    

      2.1 解释

    J_history = zeros(num_iters, 1);

     

    theta_temp = theta;  
    

      把theta存起来。保证同时更新

    for j = 1:size(X, 2)
            theta_temp(j) = theta(j)-alpha*(1/m)*(X*theta - y)' * X(:, j);
        end
    

      更新theta    

    <strong>(X*theta - y)' 是转置</strong>

    (X*theta - y)' * X(:, j);
    

      这步是求和,相当于sum

     

      J_history(iter) = computeCost(X, y, theta);

    记录代价函数

    因为随着迭代次数的增加,代价函数收敛。theta也就确定了。

    代价函数的是降低,同时theta也在变化

    到后面代价函数的值已经不变化了。到收敛了

     

     
     
     
     
     
     
     
    展开全文
  • 线性回归(Linear Regression)是利用称为线性回归方程的最小平方函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析。...代码实现:import org.apache.spark.sql.SparkSessionimport org.apa...

      线性回归(Linear Regression)是利用称为线性回归方程的最小平方函数对一个或多个自变量因变量之间关系进行建模的一种回归分析

    这种函数是一个或多个称为回归系数的模型参数的线性组合。只有一个自变量的情况称为一元线性回归,大于一个自变量情况的叫做多元线性回归。

    代码实现:
    import org.apache.spark.sql.SparkSession
    import org.apache.spark.sql.DataFrame
    import org.apache.spark.ml.feature.VectorAssembler
    import org.apache.spark.ml.regression.LinearRegression

    object LinearRegression {
      def main(args: Array[String]) {
        //设置环境
      val spark = SparkSession.builder ().appName ("LinearRegressionTest").master ("local[2]").getOrCreate()
        val sc = spark.sparkContext
        val sqlContext = spark.sqlContext
        //准备训练集合
        val raw_data = sc.textFile("src/sparkMLlib/man.txt")
        val map_data = raw_data.map{x=>
          val mid = x.replaceAll(","," ,")
          val split_list = mid.substring(0,mid.length-1).split(",")
          for(x <- 0 until split_list.length){
            if(split_list(x).trim.equals("")) split_list(x) = "0.0" else split_list(x) = split_list(x).trim
          }
          ( split_list(1).toDouble,split_list(2).toDouble,split_list(3).toDouble,split_list(4).toDouble,
            split_list(5).toDouble,split_list(6).toDouble,split_list(7).toDouble,split_list(8).toDouble,
            split_list(9).toDouble,split_list(10).toDouble,split_list(11).toDouble)
        }
        val mid = map_data.sample(false,0.6,0)//随机取样,训练模型
        val df = sqlContext.createDataFrame(mid)
        val colArray = Array("c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11")
        val data = df.toDF("c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11")
        val assembler = new VectorAssembler().setInputCols(colArray).setOutputCol("features")
        val vecDF = assembler.transform(data)
        //准备预测集合
        val map_data_for_predict = map_data
        val df_for_predict = sqlContext.createDataFrame(map_data_for_predict)
        val data_for_predict = df_for_predict.toDF("c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11")
        val colArray_for_predict = Array("c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11")
        val assembler_for_predict = new VectorAssembler().setInputCols(colArray_for_predict).setOutputCol("features")
        val vecDF_for_predict: DataFrame = assembler_for_predict.transform(data_for_predict)
        // 建立模型,进行预测
        // 设置线性回归参数
        val lr1 = new LinearRegression()
        val lr2 = lr1.setFeaturesCol("features").setLabelCol("c5").setFitIntercept(true)
        // RegParam:正则化
        val lr3 = lr2.setMaxIter(10).setRegParam(0.3).setElasticNetParam(0.8)
        // 将训练集合代入模型进行训练
        val lrModel = lr3.fit(vecDF)
        // 输出模型全部参数
        lrModel.extractParamMap()
        //coefficients 系数 intercept 截距
        println(s"Coefficients: ${lrModel.coefficients} Intercept: ${lrModel.intercept}")
        // 模型进行评价
        val trainingSummary = lrModel.summary
        trainingSummary.residuals.show()
        println(s"均方根差: ${trainingSummary.rootMeanSquaredError}")//RMSE:均方根差
        println(s"判定系数: ${trainingSummary.r2}")//r2:判定系数,也称为拟合优度,越接近1越好
        val predictions = lrModel.transform(vecDF_for_predict)
        val predict_result = predictions.selectExpr("features","c5", "round(prediction,1) as prediction")
        predict_result.rdd.saveAsTextFile("src/sparkMLlib/manResult")
        sc.stop()
      }
    }

    性能评估:

    结果:

    展开全文
  • 1.最小二乘法求线性回归参数 线性回归公式 损失函数 最小二乘法求参数 令 ,, 因此,损失函数转换为 求导求出驻点得到 2.代码 package weka.classifiers.myAlgorithm; import weka.classifiers.Classifier; ...
  • 如果使用代码实现的话,可以不断迭代计算上面这个式子,如果“一步”的长度达到了精确度或者达到了迭代次数,就结束迭代。 下面的代码是通过梯度下降的思路求解一个2维的线性回归方程。有python、java和C++三个...
  • 机器学习中线性回归以及岭回归算法的实现,Python版本
  • 简单线性回归代码实现

    千次阅读 2019-03-02 17:38:41
    本篇介绍单变量线性回归代码实现。如下: 首先是梯度下降法: 参照吴恩达《机器学习》课程及课件,单变量线性回归模型(Hypothesis)、代价函数(Cost Function)、目标函数(Goal)如下: 代码实现如下: ...
  • 单变量线性回归 绘制散点图 相关系数R 拆分训练集和测试集 多变量线性回归 数据检验(判断是否可以做线性回归) 训练线性回归模型 先甩几个典型的线性回归的模型,帮助大家捡起那些年被忘记的数学。 ● 单...
  • 线性回归 c++代码实现

    热门讨论 2009-05-05 21:50:32
    线性回归 公式 线性回归 公式 线性回归 公式 线性回归 公式
  • 实现了多元线性回归模型matlab的代码
  • matlab 多元线性回归模型求解 实现对多影响因素的分析
  • 线性回归--代码实现

    千次阅读 2018-11-07 20:59:36
    线性回归 -- 代码实现 线性回归--公式推导 本次使用的数据集介绍: 图片: 数据集属性名称: 'subject#', 'age', 'sex', 'test_time', 'motor_UPDRS', 'total_UPDRS', 'Jitter(%)', 'Jitter(Abs)', 'Jitter:RAP'...
  • 线性回归代码实现

    2021-04-05 16:17:34
    那么今天就从里面最简单的线性回归(Simple linear regression)开始学起 最简单的理解就是通过一些列运算的到初中我们学的y=kx+b 第一步,描述数据(数据可视化) 比如我们通过散点图看到整个数据,好像是接近一条线...
  • 线性回归模型代码实现

    千次阅读 2020-02-13 19:30:05
    线性回归 线性回归基本要素 1.模型 根据房屋面积(平方米)以及房龄(年)预测房屋价格: 2.数据集 我们通常收集一系列的真实数据,例如多栋房屋的真实售出价格和它们对应的面积和房龄。对模型训练以及测试,一栋...
  • Python实现多元线性回归

    万次阅读 多人点赞 2018-04-12 21:39:25
    Python实现多元线性回归 线性回归介绍 线性回归是利用数理统计中回归分析,来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法,运用十分广泛。其表达形式为y = w'x+e,e为误差服从均值为0的...
  • 线性回归Octave实现

    2017-10-18 13:49:12
    在学习机器学习的时候,线性回归实现是比较简单的,我在这里面采用的是Octave来实现代码
  • 机器学习的一元线性回归算法的公式与代码实现,具体包括魔心表达式推导,损失函数凹凸性证明,模型评估等。
  • 多元线性回归代码

    2012-12-03 15:41:58
    代码实现了多元线性回归的一般过程,内容详尽,本人试验过,可以放心使用。该代码实现了多元线性回归的一般过程,内容详尽,本人试验过,可以放心使用。
  • 线性回归 c语言实现Linear regression models the relation between an explanatory (independent) variable and a scalar response (dependent) variable by fitting a linear equation. 线性回归通过拟合线性方程...
  • 简单的梯度下降应用,适合初学者参考,代码可运行
  • 线性回归与岭回归python代码实现

    万次阅读 2017-08-31 16:51:50
    一、标准线性回归   在线性回归中我们要求的参数为: 详细的推导可以参见:...所以代码实现主要就是实现上式,python代码如下: import numpy as np import pandas as pd import matplotlib.pyplo
  • 斯坦福机器学习第2课线性回归实现和测试代码及笔记, CSDN博客地址:http://blog.csdn.net/misscoder/article/details/50322477

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,206
精华内容 19,282
关键字:

线性回归代码实现