阿里云天池笔记

一

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

准备工作：

1. 安装 sklearn：
   python -m pip install scikit-learn -i https://pypi.tuna.tsinghua.edu.cn/simple
   清华镜源下载sklearn
2. 安装 torch:
   在清华镜源下安装适配的torch-1.13.0-cp310-cp310-win_amd64.whl。适配要求符合python版本3.10和win10 64位；
   cmd中 ①进入conda环境下②在下载的torch文件路径下—通过cd XX实现③输入pip install torch-1.13.0-cp310-cp310-win_amd64.whl 实现下载，如图：
   之后才能进行如上导入

二

# 定义解压.zip包函数
def unzip_file(zip_filepath, dest_path): 
    with zipfile.ZipFile(zip_filepath, 'r') as zip_ref:  
        zip_ref.extractall(dest_path) 

# 对.zip进行解包
unzip_file('used_car_train_20200313.zip','./')
unzip_file('used_car_testB_20200421.zip','./')

准备工作：

1. "dest_path is ./“意味着目标路径是当前工作目录（也称为根目录，”."表示当前目录）
2. extractall函数作用为解压压缩包中的所有文件至指定文件夹，多个模块都有此函数。

三

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')

准备工作：sep是指分割字符

四

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

准备工作——concat函数 pd.concat（）

Pandas数据可以实现纵向和横向连接，将数据连接后会形成一个新对象(Series或DataFrame)
连接是最常用的多个数据合并操作

pd.concat()是专门用于数据连接合并的函数，它可以沿着行或列进行操作，同时可以指定非合并轴的合并方式(如合集、交集等)

pd.concat()会返回一个合并后的DataFrame
代码：pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, sort=False, verify_integrity=False, copy=True)

参数 ：

• objs: 需要连接的数据，可以是多个DataFrame或者Series，它是必传参数
• axis: 连接轴的方法，默认值为0，即按行连接，追加在行后面;值为1时追加到列后面(按列连接:axis=1)
• join: 合并方式，其他轴上的数据是按交集(inner)还是并集(outer)进行合并
• ignore_index: 是否保留原来的索引
• keys: 连接关系，使用传递的键作为最外层级别来构造层次结构索引，就是给每个表指定一个一级索引
• names: 索引的名称，包括多层索引
• verify_integrity: 是否检测内容重复;参数为True时，如果合并的数据与原数据包含索引相同的行，则会报错
• copy: 如果为False，则不要深拷贝

1.按行连接
pd.concat()的基本操作可以实现df.append()功能
操作中ignore_index和sort参数的作用是一样的,axis默认取值为0，即按行连接

import pandas as pd
df1 = pd.DataFrame({'x':[1,2],'y':[3,4]})
df2 = pd.DataFrame({'x':[5,6],'y':[7,8]})
res1 = pd.concat([df1,df2])



2.按列连接
如果要将多个DataFrame按列拼接在一起，可以传入axis=1参数，这会将不同的数据追加到列的后面，索引无法对应的位置上将值填充为NaN

import pandas as pd
df1 = pd.DataFrame({'x':[1,2],'y':[3,4]})
df2 = pd.DataFrame({'x':[5,6,0],'y':[7,8,0]})
res = pd.concat([df1,df2], axis=1)

df1

df2

res

该例子中，df2比df1多一行，合并后df1的部分为NaN

3.合并交集
上述两个练习案例的连接操作会得到两个表内容的并集(默认是join=‘outer’)

合并交集需要将join参数进行改变 join=‘inner’

import pandas as pd
df1 = pd.DataFrame({'x':[1,2],'y':[3,4]})
df2 = pd.DataFrame({'x':[5,6,0],'y':[7,8,0]})
#按列合并交集
#传入join=’inner’取得两个DataFrame的共有部分，去除了df1没有的第三行内容
res = pd.concat([df1,df2], axis=1, join='inner')

df1

df2

res

4.与序列合并
import pandas as pd
z = pd.Series([9,9],name='z')
df = pd.DataFrame({'x':[1,2],'y':[3,4]})
#将序列加到新列
res = pd.concat([df,z],axis=1)

z

df

res

5.指定索引
import pandas as pd
df1 = pd.DataFrame({'x':[1,2],'y':[3,4]})
df2 = pd.DataFrame({'x':[5,6],'y':[7,8]})
#指定索引名
res1 = pd.concat([df1,df2], keys=['a','b'])
#以字典形式传入
dict = {'a':df1, 'b':df2}
res2 = pd.concat(dict)
#横向合并，指定索引
res3 = pd.concat([df1,df2], axis=1, keys=['a','b'])

df1

df2

res1

res2

res3

pandas contact 之后，一定要记得用reset_index去处理index,不然容易出现莫名的逻辑错误 即data=data.reset_index(drop=True)

五

data = data.replace('-', '-1')
data.notRepairedDamage = data.notRepairedDamage.astype('float32')#单拿出某列
data.loc[data['power']>600,'power'] = 600

准备工作：

1. replace函数
   string.replace( old, new, count )

参数

• old ：（必选，字符串类型）被替换的字符串
• new ：（必选，字符串类型）替换后的字符串
• count ：（可选，整型）替换的次数

返回值： 返回替换后的新字符串

2. loc函数
   ①定位行列：data.loc[行索引, 列名]
   ②只定位行：data.loc[行索引]
   例如：
   data.loc[3] 表示第4行的所有内容。
   ③只定位列：data.loc[:, 列名]
   例如：
   data.loc[:, “列名1”]
   ④根据条件定位： data.loc[data[“某个列名”] > 6]
   定位某个列值大于6的所有行。

六

cate_cols=['model', 'brand', 'bodyType', 'fuelType', 'gearbox', 'seller', 'notRepairedDamage']
num_cols=['regDate', 'creatDate', 'power', 'kilometer', 'v_0', 'v_1', 'v_2', 'v_3', 'v_4', 'v_5', 'v_6', 'v_7', 'v_8', 'v_9', 'v_10','v_11', 'v_12', 'v_13', 'v_14']

单纯分类一下

七

# 定义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编码函数

1. 什么是one-hot编码？

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

2. one-hot编码过程详解

比如我们要对 “hello world” 进行one-hot编码，怎么做呢？
①确定要编码的对象–hello world，
②确定分类变量–h e l l o 空格 w o r l d，共27种类别（26个小写字母 + 空格，）；
③以上问题就相当于，有11个样本，每个样本有27个特征，将其转化为二进制向量表示，

这里有一个前提，特征排列的顺序不同，对应的二进制向量亦不同（比如我把空格放在第一列和a放第一列，one-hot编码结果肯定是不同的）
因此我们必须要事先约定特征排列的顺序：

• 27种特征首先进行整数编码：a–0，b–1，c–2，…，z–25，空格–26
• 27种特征按照整数编码的大小从前往后排列

get_dummies 是利用pandas实现one hot encode的方式
二，get_dummies函数

pandas.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False, columns=None, sparse=False, drop_first=False)[source]

例子：

mport pandas as pd
df = pd.DataFrame([  
            ['green' , 'A'],   
            ['red'   , 'B'],   
            ['blue'  , 'A']])  

df.columns = ['color',  'class'] 
pd.get_dummies(df

get_dummies 前：

get_dummies 后：

上述执行完以后再打印df 出来的还是get_dummies 前的图，因为你没有写df = pd.get_dummies(df)1

• 可以对指定列进行get_dummies

pd.get_dummies(df.color)

• 将指定列进行get_dummies 后合并到元数据中

df = df.join(pd.get_dummies(df.color))1

八

# 处理离散数据
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)

data.columns

九

data.to_csv('concat-adress.csv')

十

# 拿出测试集
data=data.reset_index(drop=True)
data = data.astype(float)
test_data = data[pd.isna(data.price)]
X_id=test_data['SaleID']
del test_data['SaleID']
del test_data['price']
X_result=torch.tensor(test_data.values, dtype=torch.float32)
test_data =test_data.astype(float)
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)

准备工作： astype函数

通过astype函数显式转换数组的数据类型

十一

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25,random_state=512)

准备工作—— 机器学习之train_test_split详解

导入方法：
from sklearn.model_selection import train_test_split
读入数据：

X_train,X_test, y_train, y_test =train_test_split(train_data,train_target,test_size=0.25, random_state=0,stratify=y)

参数意义:

• train_data：所要划分的样本特征集
• X_train：划分出的训练数据集数据
• X_test：划分出的测试数据集数据
• y_train：划分出的训练数据集的标签
• y_test：划分出的测试数据集的标签
• train_target：所要划分的样本结果
• test_size：若在0~1之间，为测试集样本数目与原始样本数目之比；若为整数，则是测试集样本的数目
• random_state：是随机数的种子。 随机数种子其实就是该组随机数的编号，在需要重复试验的时候，保证得到一组一样的随机数。比如你每次都填1，其他参数一样的情况下你得到的随机数组是一样的。但填0或不填，每次都会不一样。
• stratify：stratify是为了保持split前类的分布，例如训练集和测试集数量的比例是 A：B=
  4：1，等同于split前的比例（80：20）。通常在这种类分布不平衡的情况下会用到stratify。

这一步目的----划分训练集、测试集
将数据集进行拆分，训练集用于模型训练，得到一个大概的模型；测试集用于测试，利用训练集训练出的模型对测试集进行模型预测。

十二

lr1=RandomForestRegressor().fit(X_train,y_train)#随机森林回归模型
lr2=LinearRegression().fit(X_train,y_train)#直线回归模型

print('训练集得分:{:.3f}'.format(lr1.score(X_train,y_train)))
print('测试集得分:{:.3f}'.format(lr1.score(X_test,y_test)))

pred=lr1.predict(X_result)

res=pd.DataFrame(pred, columns=['price']) 
X_id=X_id.reset_index(drop=True)

submission = pd.concat([X_id, res['price']], axis=1)
submission.to_csv('submission.csv',index=False)
submission