“AI”第二课堂笔记（阿里天池）

本文链接：https://blog.csdn.net/plkdthfs12138/article/details/140759011

，

one-Hot编码

一、什么是one-hot编码？

One-Hot编码，又称为一位有效编码，主要是采用N位状态寄存器来对N个状态进行编码，每个状态都由他独立的寄存器位，并且在任意时候只有一位有效。
One-Hot编码是分类变量作为二进制向量的表示。这首先要求将分类值映射到整数值。然后，每个整数值被表示为二进制向量，除了整数的索引之外，它都是零值，它被标记为1。

# 定义One-Hot编码函数
def oneHotEncode(df, colNames):
    for col in colNames:
        dummies = pd.get_dummies(df[col], prefix=col)
        df = pd.concat([df, dummies],axis=1)
        df.drop([col], axis=1, inplace=True)
    return df

损失函数

criterion = nn.MSELoss()

ReLU

公式：f(x)=max(0,x)

为了训练深层神经网络，需要一个激活函数神经网络，它看起来和行为都像一个线性函数，但实际上是一个非线性函数，允许学习数据中的复杂关系。该函数还必须提供更灵敏的激活和输入，避免饱和。

因此，ReLU出现了，采用 ReLU 可以是深度学习革命中为数不多的里程碑之一。ReLU激活函数是一个简单的计算，如果输入大于0，直接返回作为输入提供的值；如果输入是0或更小，返回值0。

# 定义网络结构
class Network(nn.Module):
    def __init__(self, in_dim, hidden_1, hidden_2, hidden_3, hidden_4):
        super().__init__()
        self.layers = nn.Sequential(

            #创建连接层，id_dim为输入维度,hidden_1为输出维度
            nn.Linear(in_dim, hidden_1),

            #添加一个一维批量归一化层(nn.BatchNorm1d)，作用在hidden_1维度上
            nn.BatchNorm1d(hidden_1),

            #激活函数
            nn.ReLU(),
            nn.Linear(hidden_1, hidden_2),
            nn.BatchNorm1d(hidden_2),
            nn.ReLU(),
            nn.Linear(hidden_2, hidden_3),
            nn.BatchNorm1d(hidden_3),
            nn.ReLU(),
            nn.Linear(hidden_3, hidden_4),
            nn.BatchNorm1d(hidden_4),
            nn.ReLU(),
            nn.Linear(hidden_4, 1)
        )

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

一个神经网络的结构， ReLU作为激活函数缓解梯度消失

特征缩放（归一化）

特征缩放（Feature Scaling），也称为归一化（Normalization）或标准化（Standardization），是机器学习和数据分析中常用的数据预处理步骤。特征缩放的目的是将数据调整到一个统一的尺度，使得不同的特征在数值上具有可比性，从而提高算法的收敛速度和性能。以下是两种常见的特征缩放方法：

1. 归一化（Min-Max Normalization）

归一化将特征的值缩放到一个特定的范围内，通常是 [0, 1]。这种方法对于处理具有不同数值范围的特征特别有用。XX 是原始数据点，XminXmin 和 XmaxXmax 分别是该特征列的最小值和最大值。

2. 标准化（Z-Score Normalization）

标准化通过减去平均值（mean）并除以标准差（standard deviation）来转换特征值，使得结果具有均值为 0 和标准差为 1 的分布。μμ 是特征列的均值，σσ 是标准差。

特征缩放的应用场景：

提高模型性能：某些算法（如支持向量机、神经网络等）对特征的尺度敏感，特征缩放可以提高这些模型的性能。
避免数值问题：在计算均值和方差时，特征缩放可以避免由于数值范围过大导致的数值稳定性问题。
加速收敛：在梯度下降等优化算法中，特征缩放有助于加快收敛速度。

在Python中的实现：

使用Pandas和Scikit-learn库可以很容易地实现特征缩放：

import pandas as pd
from sklearn.preprocessing import MinMaxScaler, StandardScaler

# 假设df是一个DataFrame
df = pd.DataFrame({
    'Feature1': [10, 20, 30, 40, 50],
    'Feature2': [5, 15, 25, 35, 45]
})

# 归一化
min_max_scaler = MinMaxScaler()
df_normalized = min_max_scaler.fit_transform(df)

# 标准化
standard_scaler = StandardScaler()
df_standardized = standard_scaler.fit_transform(df)

# 转换回DataFrame
df_normalized = pd.DataFrame(df_normalized, columns=df.columns)
df_standardized = pd.DataFrame(df_standardized, columns=df.columns)

神经网络（训练集，验证集，测试集）

%matplotlib inline
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
import pandas as pd
import zipfile  
import re
import numpy as np
import torch

test_data = pd.read_csv('used_car_testB_20200421.csv', sep=' ')
train_data = pd.read_csv('used_car_train_20200313.csv', sep=' ')
test_data.to_csv('used_car_testB.csv')
train_data.to_csv('used_car_train.csv')

data = pd.concat([train_data, test_data])

data = data.replace('-', '-1')
data.notRepairedDamage = data.notRepairedDamage.astype('float32')
data.loc[data['power']>600,'power'] = 600

进行数据的读取与数据的预处理，把空缺替换成-1，将 notRepaireDamage这一列转换成float32类型，将power列大于600的值截断为600

# 定义One-Hot编码函数
def oneHotEncode(df, colNames):
    for col in colNames:
        dummies = pd.get_dummies(df[col], prefix=col)
        df = pd.concat([df, dummies],axis=1)
        df.drop([col], axis=1, inplace=True)
    return df

定义one-Hot函数

# 处理离散数据
for col in cate_cols:
    data[col] = data[col].fillna('-1')
data = oneHotEncode(data, cate_cols)

# 处理连续数据
for col in num_cols:
    data[col] = data[col].fillna(0)
    data[col] = (data[col]-data[col].min()) / (data[col].max()-data[col].min())

# 处理(可能)无关数据 
data.drop(['name', 'regionCode'], axis=1, inplace=True)

处理数据，对于离散数据将缺失值赋为-1并进行one-Hot编码，对于连续数据将缺失值赋为0然后进行归一化处理，将数据缩放到0和1之间，删除可能的无关数据

# 拿出测试集

#重置索引，丢弃原来的索引，原地删除
data=data.reset_index(drop=True)
# 转换为float
data = data.astype(float)
# 拿出测试集（数据中没有price的列）
test_data = data[pd.isna(data.price)]
X_id=test_data['SaleID']
del test_data['SaleID']
del test_data['price']
# 转换成tensor类型
X_result=torch.tensor(test_data.values, dtype=torch.float32)
test_data.to_csv('one_hot_testB.csv') 
# 拿出训练集
train_data = data.drop(data[pd.isna(data.price)].index)
train_data.to_csv('one_hot_train.csv') 
y=train_data['price']
del train_data['price']
del train_data['SaleID']
X=torch.tensor(train_data.values, dtype=torch.float32)
y=torch.Tensor(y)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25,random_state=512)
lr1=RandomForestRegressor().fit(X_train,y_train)#随机森林回归模型、
print('训练集得分:{:.3f}'.format(lr1.score(X_train,y_train)))
print('测试集得分:{:.3f}'.format(lr1.score(X_test,y_test)))