机器学习 预测温度

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import  torch
import torch.optim as optim
features = pd.read_csv('temps.csv')
print(features.head())
print('数据维度：',features.shape)
#处理时间数据
import datetime

years = features['year']
months = features['month']
days = features['day']
#datetime格式
dates = [str(int(year)) + '-' + str(int(month)) + '-' + str(int(day)) for year,month,day in zip(years,months,days)]
dates = [datetime.datetime.strptime(date,'%Y-%m-%d') for date in dates]
print(dates[ :5])


#准备画图
#指定默认风格
plt.style.use('fivethirtyeight')
#设置布局
fig,((ax1,ax2),(ax3,ax4)) = plt.subplots(nrows = 2,ncols = 2,figsize = (10,10) )
#标签值
ax1.plot(dates,features['actual'])
ax1.set_xlabel('');ax1.set_ylabel('Temperature');ax1.set_title('MAX Temp')
plt.plot()
# 昨天
ax2.plot(dates, features['temp_1'])
ax2.set_xlabel(''); ax2.set_ylabel('Temperature'); ax2.set_title('Previous Max Temp')
plt.plot()
# 前天
ax3.plot(dates, features['temp_2'])
ax3.set_xlabel('Date'); ax3.set_ylabel('Temperature'); ax3.set_title('Two Days Prior Max Temp')
plt.plot()
# 我的逗逼朋友
ax4.plot(dates, features['friend'])
ax4.set_xlabel('Date'); ax4.set_ylabel('Temperature'); ax4.set_title('Friend Estimate')
plt.plot()
plt.tight_layout(pad=2)
plt.show()

#独热编码
features = pd.get_dummies(features)
#输出前五个数据
print(features.head(5))

#在特征中去掉标签
labels = np.array(features['acttual'])
#名字单独保存一下，以备后患
feature_list = list(features.columns)
#features.columns 将返回一个迭代器，包含features的所有列名：
features = np.array(features)


#创建归一化变量x,它的取值是0.02，0.04,......,1
x = torch.tensor(features,requires_grad=True)
#创建一个归一化的预测变量y,它的取值是0.02，0.04,......,1
y = torch.tensor(labels, requires_grad = True)
#初始化所有神经网络的权重（weights) 和 阈值（biases)
sz=10
weights = torch.randn((1,sz),dtype=torch.double,requires_grad=True)#1*10的输入到隐含层的权重矩阵
biases = torch.randn(sz,dtype=torch.double,requires_grad=True)#尺度为10的隐含层节点偏执向量
weights2 = torch.randn((sz,1),dtype= torch.double,requires_grad=True)#10*1的隐含到输出层权重矩阵

learning_rate = 0.001
losses = []
#将 x 转换为（50,1）维度,以便和（1，10）的矩阵相乘
x = x.view(50,-1)
y = y.view(50,-1)

for i in range(100000):
    # 从输入层到隐含层的计算
    hidden = x * weights + biases
    # 将sigmoid函数作用在隐含层的每一个神经元上
    hidden = torch.sigmoid(hidden)
    # 隐含层输出到输出层，计算得到最终预测
    predictions = hidden.mm(weights2)  # + biases2.expand_as(y)
    # 通过与标签数据y比较，计算均方误差
    loss = torch.mean((predictions - y) ** 2)
    losses.append(loss.data.numpy())

    # 每隔10000个周期打印一下损失函数数值
    if i % 10000 == 0:
        print('loss:', loss)

    # 对损失函数进行梯度反传
    loss.backward()

    # 利用上一步计算中得到的weights，biases等梯度信息更新weights或biases中的data数值
    weights.data.add_(- learning_rate * weights.grad.data)
    biases.data.add_(- learning_rate * biases.grad.data)
    weights2.data.add_(- learning_rate * weights2.grad.data)

    # 清空所有变量的梯度值。
    # 因为pytorch中backward一次梯度信息会自动累加到各个变量上，因此需要清空，否则下一次迭代会累加，造成很大的偏差
    weights.grad.data.zero_()
    biases.grad.data.zero_()
    weights2.grad.data.zero_()

分段解析

1.

导入库和数据：

python

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import  torch
import torch.optim as optim
features = pd.read_csv('temps.csv')
print(features.head())
print('数据维度：',features.shape)

这部分代码首先导入了所需的库，然后读取了一个名为'temps.csv'的文件作为数据集。使用head函数打印了数据的前5行，并使用shape属性获得了数据的维度。

2.

处理时间数据：

python

import datetime

years = features['year']
months = features['month']
days = features['day']
#datetime格式
dates = [str(int(year)) + '-' + str(int(month)) + '-' + str(int(day)) for year,month,day in zip(years,months,days)]
dates = [datetime.datetime.strptime(date,'%Y-%m-%d') for date in dates]
print(dates[ :5])

这部分代码提取了features中的'year'、'month'和'day'列，并将其转换为datetime格式。

3.

绘制图形：

python

plt.style.use('fivethirtyeight')
fig,((ax1,ax2),(ax3,ax4)) = plt.subplots(nrows = 2,ncols = 2,figsize = (10,10) )
#标签值
ax1.plot(dates,features['actual'])
ax1.set_xlabel('');ax1.set_ylabel('Temperature');ax1.set_title('MAX Temp')
plt.plot()
# 昨天
ax2.plot(dates, features['temp_1'])
ax2.set_xlabel(''); ax2.set_ylabel('Temperature'); ax2.set_title('Previous Max Temp')
plt.plot()
# 前天
ax3.plot(dates, features['temp_2'])
ax3.set_xlabel('Date'); ax3.set_ylabel('Temperature'); ax3.set_title('Two Days Prior Max Temp')
plt.plot()
# 我的逗逼朋友
ax4.plot(dates, features['friend'])
ax4.set_xlabel('Date'); ax4.set_ylabel('Temperature'); ax4.set_title('Friend Estimate')
plt.plot()
plt.tight_layout(pad=2)
plt.show()

这个部分代码使用Matplotlib绘制了一个包含4个子图的图形。每个子图展示了一个特征相对于时间的变化情况。

4.

独热编码：

独热编码（One-Hot Encoding）是一种广泛应用于机器学习和统计模型中的特征编码技术。对于类别型特征，独热编码可以将其转换为虚拟变量，以便于模型处理。

假设有一个包含两个类别型特征（A和B）的DataFrame：

	A	B
0	Cat	Dog
1	Dog	Cat
2	Bird	Cat
3	Cat	Bird

使用pd.get_dummies函数对其进行独热编码，将会创建一个新的DataFrame，其中类别型特征A和B被转换为虚拟变量：

	A_Cat	A_Dog	A_Bird	B_Cat	B_Dog	B_Bird
0	1	0	0	1	0	0
1	0	1	0	0	1	0
2	0	0	1	1	0	0
3	1	0	0	0	0	1

在这个新的DataFrame中，每一列都是一个虚拟变量，表示某个样本属于特定类别的可能性。例如，在第0行，A_Cat=1表示样本A属于类别"Cat"，而A_Dog=0和A_Bird=0表示样本A不属于类别"Dog"和"Bird"。类似的，B_Cat=1表示样本B属于类别"Cat"，而B_Dog=0和B_Bird=0表示样本B不属于类别"Dog"和"Bird"。

这样就可以将类别型特征转换为数值型特征，以便用于机器学习和统计模型中。而且，独热编码还保留了类别型特征之间的互斥关系，即在任何给定样本中，只能有一个类别特征取值为1，其他取值均为0。

python

features = pd.get_dummies(features)
print(features.head(5))

这个部分使用Pandas的get_dummies函数对features数据进行了独热编码，将类别型特征转换为虚拟变量。然后打印了新数据的前5行。

5.

准备神经网络：

python

labels = np.array(features['acttual'])
feature_list = list(features.columns)
features = np.array(features)

x = torch.tensor(features,requires_grad=True)
y = torch.tensor(labels, requires_grad = True)

sz=10
weights = torch.randn((1,sz),dtype=torch.double,requires_grad=True)#1*10的输入到隐含层的权重矩阵
biases = torch.randn(sz,dtype=torch.double,requires_grad=True)#尺度为10的隐含层节点偏执向量
weights2 = torch.randn((sz,1),dtype= torch.double,requires_grad=True)#10*1的隐含到输出层权重矩阵

这个部分首先将features和labels转换为NumPy数组，然后将它们转换为PyTorch张量。定义了神经网络的权重和阈值，并将其初始化为随机数。sz变量可能表示隐藏层神经元的数量，这里设为10。

6.

设置学习率和损失函数：

python

learning_rate = 0.001
losses = []
#将 x 转换为（50,1）维度,以便和（1，10）的矩阵相乘
x = x.view(50,-1)
y = y.view(50,-1)

for i in range(100000):
    # 从输入层到隐含层的计算
    hidden = x * weights + biases
    # 将sigmoid函数作用在隐含层的每一个神经元上
    hidden = torch.sigmoid(hidden)
    # 隐含层输出到输出层，计算得到最终预测
    predictions = hidden.mm(weights2)  # + biases2.expand_as(y)
    # 通过与标签数据y比较，计算均方误差
    loss = torch.mean((predictions - y) ** 2)
    losses.append(loss.data.numpy())

    # 每隔10000个周期打印一下损失函数数值
    if i % 10000 == 0:
        print('loss:', loss)

    # 对损失函数进行梯度反传
    loss.backward()

    # 利用上一步计算中得到的weights，biases等梯度信息更新weights或biases中的data数值
    weights.data.add_(- learning_rate * weights.grad.data)
    biases.data.add_(- learning_rate * biases.grad.data)
    weights2.data.add_(- learning_rate * weights2.grad.data)

    # 清空所有变量的梯度值。
    # 因为pytorch中backward一次梯度信息会自动累加到各个变量上，因此需要清空，否则下一次迭代会累加，造成很大的偏差
    weights.grad.data.zero_()
    biases.grad.data.zero_()
    weights2.grad.data.zero_()

 

首先，设置学习率为0.001，并创建一个空列表losses用于存储训练过程中的损失值。

接下来，将输入x和标签y的形状调整为（50，-1），以便与形状为（1，10）的权重矩阵相乘。

在循环中，进行前向传播并计算损失。对于每个样本，我们根据输入x和权重weights计算隐含层的值，然后使用Sigmoid激活函数。接下来，将隐含层的输出与权重weights2相乘，得到预测值predictions。通过计算预测值与实际标签y的均方误差（MSE）来计算损失。

在反向传播阶段，使用loss.backward()计算损失关于模型参数的梯度。接着，使用梯度下降法更新权重和偏置参数。

在每一个迭代周期（这里是10000），打印损失函数的值。最后，清空梯度以准备下一个迭代周期。

这段代码模拟了一个简单的神经网络训练过程。通过不断迭代更新权重，可以使模型的预测结果逐渐接近真实标签，从而最小化损失函数。在训练完成后，我们可以使用训练好的模型进行预测。

 简单总结

这段代码首先使用PyTorch读取和处理csv数据，进行一些数据预处理（如独热编码等）。然后，它将数据转换为PyTorch张量，用于神经网络的计算。接着，代码定义了一个神经网络模型，包括初始化权重、偏置等。

在训练循环中，代码遍历数据集，进行前向传播、损失计算、后向传播和优化器更新等步骤。这部分代码是一个简化的训练循环，实际应用中可能需要加入更多的功能，例如模型验证、正则化等。

以上是对代码的一个概述，如果需要了解具体细节，可以从头开始阅读和理解每一行代码。