机器学习(ML)系列一之 Linear Regression

一、线性回归

1、模型

2、损失函数

3、优化函数-梯度下降

#!/usr/bin/env python
# coding: utf-8
import torch
import time

# init variable a, b as 1000 dimension vector
n = 1000
a = torch.ones(n)
b = torch.ones(n)
# define a timer class to record time
class Timer(object):
    """Record multiple running times."""
    def __init__(self):
        self.times = []
        self.start()

    def start(self):
        # start the timer
        self.start_time = time.time()

    def stop(self):
        # stop the timer and record time into a list
        self.times.append(time.time() - self.start_time)
        return self.times[-1]

    def avg(self):
        # calculate the average and return
        return sum(self.times)/len(self.times)

    def sum(self):
        # return the sum of recorded time
        return sum(self.times)
timer = Timer()
c = torch.zeros(n)
for i in range(n):
    c[i] = a[i] + b[i]
‘%.5f sec‘ % timer.stop()

timer.start()
d = a + b
‘%.5f sec‘ % timer.stop()

# import packages and modules
get_ipython().run_line_magic(‘matplotlib‘, ‘inline‘)
import torch
from IPython import display
from matplotlib import pyplot as plt
import numpy as np
import random

print(torch.__version__)

# ### 线性回归模型从零开始的实现

# set input feature number
num_inputs = 2
# set example number
num_examples = 1000

# set true weight and bias in order to generate corresponded label
true_w = [2, -3.4]
true_b = 4.2

features = torch.randn(num_examples, num_inputs,
                      dtype=torch.float32)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()),
                       dtype=torch.float32)

# ### 使用图像来展示生成的数据

plt.scatter(features[:, 1].numpy(), labels.numpy(), 1);

# ### 读取数据集

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)  # random read 10 samples
    for i in range(0, num_examples, batch_size):
        j = torch.LongTensor(indices[i: min(i + batch_size, num_examples)]) # the last time may be not enough for a whole batch
        yield  features.index_select(0, j), labels.index_select(0, j)

batch_size = 10

for X, y in data_iter(batch_size, features, labels):
    print(X, ‘\n‘, y)
    break

# ### 模型初始化

w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, 1)), dtype=torch.float32)
b = torch.zeros(1, dtype=torch.float32)

w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

# ### 定义模型
# 定义用来训练参数的训练模型:
# $$ \mathrm{price} = w_{\mathrm{area}} \cdot \mathrm{area} + w_{\mathrm{age}} \cdot \mathrm{age} + b $$

# In[19]:

def linreg(X, w, b):
    return torch.mm(X, w) + b

# ### 定义损失函数
# 我们使用的是均方误差损失函数:
# $$l^{(i)}(\mathbf{w}, b) = \frac{1}{2} \left(\hat{y}^{(i)} - y^{(i)}\right)^2,$$

# In[16]:

def squared_loss(y_hat, y):
    return (y_hat - y.view(y_hat.size())) ** 2 / 2

# ### 定义优化函数
# 在这里优化函数使用的是小批量随机梯度下降:
# $$(\mathbf{w},b) \leftarrow (\mathbf{w},b) - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \partial_{(\mathbf{w},b)} l^{(i)}(\mathbf{w},b)$$

# In[17]:

def sgd(params, lr, batch_size):
    for param in params:
        param.data -= lr * param.grad / batch_size # ues .data to operate param without gradient track

# ### 训练
# 当数据集、模型、损失函数和优化函数定义完了之后就可来准备进行模型的训练了。

# In[20]:

# super parameters init
lr = 0.03
num_epochs = 5

net = linreg
loss = squared_loss

# training
for epoch in range(num_epochs):  # training repeats num_epochs times
    # in each epoch, all the samples in dataset will be used once

    # X is the feature and y is the label of a batch sample
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()
        # calculate the gradient of batch sample loss
        l.backward()
        # using small batch random gradient descent to iter model parameters
        sgd([w, b], lr, batch_size)
        # reset parameter gradient
        w.grad.data.zero_()
        b.grad.data.zero_()
    train_l = loss(net(features, w, b), labels)
    print(‘epoch %d, loss %f‘ % (epoch + 1, train_l.mean().item()))

# In[21]:

w, true_w, b, true_b

# ### 线性回归模型使用pytorch的简洁实现

# In[22]:

import torch
from torch import nn
import numpy as np
torch.manual_seed(1)

print(torch.__version__)
torch.set_default_tensor_type(‘torch.FloatTensor‘)

# ### 生成数据集
# 在这里生成数据集跟从零开始的实现中是完全一样的。

# In[23]:

num_inputs = 2
num_examples = 1000

true_w = [2, -3.4]
true_b = 4.2

features = torch.tensor(np.random.normal(0, 1, (num_examples, num_inputs)), dtype=torch.float)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float)

# ### 读取数据集

# In[24]:

import torch.utils.data as Data

batch_size = 10

# combine featues and labels of dataset
dataset = Data.TensorDataset(features, labels)

# put dataset into DataLoader
data_iter = Data.DataLoader(
    dataset=dataset,            # torch TensorDataset format
    batch_size=batch_size,      # mini batch size
    shuffle=True,               # whether shuffle the data or not
    num_workers=2,              # read data in multithreading
)

# In[27]:

for X, y in data_iter:
    print(X, ‘\n‘, y)
    break

# ### 定义模型

# In[28]:

class LinearNet(nn.Module):
    def __init__(self, n_feature):
        super(LinearNet, self).__init__()      # call father function to init
        self.linear = nn.Linear(n_feature, 1)  # function prototype: `torch.nn.Linear(in_features, out_features, bias=True)`

    def forward(self, x):
        y = self.linear(x)
        return y

net = LinearNet(num_inputs)
print(net)

# In[29]:

# ways to init a multilayer network
# method one
net = nn.Sequential(
    nn.Linear(num_inputs, 1)
    # other layers can be added here
    )

# method two
net = nn.Sequential()
net.add_module(‘linear‘, nn.Linear(num_inputs, 1))
# net.add_module ......

# method three
from collections import OrderedDict
net = nn.Sequential(OrderedDict([
          (‘linear‘, nn.Linear(num_inputs, 1))
          # ......
        ]))

print(net)
print(net[0])

# ### 初始化模型参数

# In[30]:

from torch.nn import init

init.normal_(net[0].weight, mean=0.0, std=0.01)
init.constant_(net[0].bias, val=0.0)  # or you can use `net[0].bias.data.fill_(0)` to modify it directly

# In[31]:

for param in net.parameters():
    print(param)

# ### 定义损失函数

# In[32]:

loss = nn.MSELoss()    # nn built-in squared loss function
                       # function prototype: `torch.nn.MSELoss(size_average=None, reduce=None, reduction=‘mean‘)`

# ### 定义优化函数

# In[33]:

import torch.optim as optim

optimizer = optim.SGD(net.parameters(), lr=0.03)   # built-in random gradient descent function
print(optimizer)  # function prototype: `torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)`

# In[34]:

##trainning
num_epochs = 3
for epoch in range(1, num_epochs + 1):
    for X, y in data_iter:
        output = net(X)
        l = loss(output, y.view(-1, 1))
        optimizer.zero_grad() # reset gradient, equal to net.zero_grad()
        l.backward()
        optimizer.step()
    print(‘epoch %d, loss: %f‘ % (epoch, l.item()))

# In[35]:

# result comparision
dense = net[0]
print(true_w, dense.weight.data)
print(true_b, dense.bias.data)

# In[ ]:

  

原文地址:https://www.cnblogs.com/jaww/p/12297848.html

时间: 2024-10-08 12:32:14

机器学习(ML)系列一之 Linear Regression的相关文章

Stanford机器学习---第二讲. 多变量线性回归 Linear Regression with multiple variable

原文:http://blog.csdn.net/abcjennifer/article/details/7700772 本栏目(Machine learning)包括单参数的线性回归.多参数的线性回归.Octave Tutorial.Logistic Regression.Regularization.神经网络.机器学习系统设计.SVM(Support Vector Machines 支持向量机).聚类.降维.异常检测.大规模机器学习等章节.所有内容均来自Standford公开课machine

机器学习笔记01:线性回归(Linear Regression)和梯度下降(Gradient Decent)

最近在Coursera上看吴大神的Machine Learning,感觉讲的真的很棒.所以觉得应该要好好做做笔记,一方面是加强自己对ML中一些方法的掌握程度和理解,另一方面也能方便自己或者同样爱好ML的同学. 线性回归(Linear Regression) 线性回归(Linear Regression)应该是机器学习中最基本的东西了.所谓回归,想必大家在高中时期的课程里面就接触过,给定一系列离散的点(x0,y0),求一条直线 f(x)=ax+b 以使得最小.在machine learning 中

机器学习之多变量线性回归(Linear Regression with multiple variables)

1. Multiple features(多维特征) 在机器学习之单变量线性回归(Linear Regression with One Variable)我们提到过的线性回归中,我们只有一个单一特征量(变量)--房屋面积x.我们希望使用这个特征量来预测房子的价格.我们的假设在下图中用蓝线划出: 不妨思考一下,如果我们不仅仅知道房屋面积(作为预测房屋价格的特征量(变量)),我们还知道卧室的数量.楼层的数量以及房屋的使用年限,那么这就给了我们更多可以用来预测房屋价格的信息. 即,支持多变量的假设为:

机器学习 (一) 单变量线性回归 Linear Regression with One Variable

文章内容均来自斯坦福大学的Andrew Ng教授讲解的Machine Learning课程,本文是针对该课程的个人学习笔记,如有疏漏,请以原课程所讲述内容为准.感谢博主Rachel Zhang和 JerryLead 的个人笔记,为我做个人学习笔记提供了很好的参考和榜样. § 1.  单变量线性回归 Linear Regression with One Variable 1. 代价函数Cost Function 在单变量线性回归中,已知有一个训练集有一些关于x.y的数据(如×所示),当我们的预测值

机器学习基石——第9-10讲.Linear Regression

本栏目(机器学习)下机器学习基石专题是个人对Coursera公开课机器学习基石(2014)的学习心得与笔记.所有内容均来自Coursera公开课Machine Learning Foundations中Hsuan-Tien Lin林轩田老师的讲解.(https://class.coursera.org/ntumlone-002/lecture) 第9讲-------Linear Regression 从这一节开始,开始涉及到How Can Machines Learn的问题了. 一.Linear

机器学习---线性回归(Machine Learning Linear Regression)

线性回归是机器学习中最基础的模型,掌握了线性回归模型,有利于以后更容易地理解其它复杂的模型. 线性回归看似简单,但是其中包含了线性代数,微积分,概率等诸多方面的知识.让我们先从最简单的形式开始. 一元线性回归(Simple Linear Regression): 假设只有一个自变量x(independent variable,也可称为输入input, 特征feature),其与因变量y(dependent variable,也可称为响应response, 目标target)之间呈线性关系,当然x

Stanford公开课机器学习---2.单变量线性回归(Linear Regression with One Variable)

单变量线性回归(Linear Regression with One Variable) 2.1 模型表达(Model Representation) m 代表训练集中实例的数量 x 代表特征/输入变量 y 代表目标变量/输出变量 (x,y) 代表训练集中的实例 (x(i),y(i) ) 代表第 i 个观察实例 h 代表学习算法的解决方案或函数也称为假设(hypothesis) 单变量线性回归:只含有一个特征/输入变量 x hθ=θ0+θ1x 2.2 代价函数(Cost Function) 目标

机器学习基石笔记-Lecture 9 Linear regression

线性回归的任务是对于一个输入,给出输出的实数,保证和真实输出相差越小越好.因为假设空间是线性的,所以最后的g会是直线或者平面. 通常的误差衡量方法是使用平方误差 接下来的问题是如何最小化 Ein 将Ein写成矩阵形式, 注意到Ein是w的函数,是连续的.可微的.凸函数. 对w求偏导使之为0则可以求出最优点.  这是一个关于w的一次方程. 在  不可逆时,它的 pseudo-inverse仍然存在,只是会有多个,选取其中一个去得到w即可. 线性回归是一个学习算法吗? 先来看一看它的Ein H也可以

Stanford公开课机器学习---3.多变量线性回归 (Linear Regression with multiple variable)

3.多变量线性回归 (Linear Regression with multiple variable) 3.1 多维特征(Multiple Features) n 代表特征的数量 x(i)代表第 i 个训练实例,是特征矩阵中的第 i 行,是一个向量(vector). x(i)j代表特征矩阵中第 i 行的第 j 个特征,也就是第 i 个训练实例的第 j 个特征. 多维线性方程: hθ=θ0+θ1x+θ2x+...+θnx 这个公式中有 n+1 个参数和 n 个变量,为了使得公式能够简化一些,引入

【模式识别与机器学习】——PART2 机器学习——统计学习基础——Regularized Linear Regression

来源:https://www.cnblogs.com/jianxinzhou/p/4083921.html 1. The Problem of Overfitting (1) 还是来看预测房价的这个例子,我们先对该数据做线性回归,也就是左边第一张图.如果这么做,我们可以获得拟合数据的这样一条直线,但是,实际上这并不是一个很好的模型.我们看看这些数据,很明显,随着房子面积增大,住房价格的变化趋于稳定或者说越往右越平缓.因此线性回归并没有很好拟合训练数据. 我们把此类情况称为欠拟合(underfit