import pandas as pddata_forest_fires = pd.read_csv("data/forestfires.csv", encoding='gbk')data1 = pd.read_excel("data/original_data.xls", sheet_name="原始数据")
data2 = pd.read_excel("data/original_data.xls", sheet_name="属性规约")data_mtcars = pd.read_csv("data/mtcars.csv")# data1.to_csv("data/original_data.csv")
# data2.to_csv("data/originalTo_data.csv")# ----------------------------------------------------------------------
# test# 查看几行几列
# print(data1.shape)# 查看维度
# print(data1.ndim)# 查看列名
# print(data1.columns)# 查看索引名
# print(data1.index)# 查看每列的数据类型
# print(data1.info())# 查看统计特征
# print(data1.describe())
'''
count：非空值的数目
mean：数值型数据的均值
std：数值型数据的标准差
min：数值型数据的最小值
25%：数值型数据的下四分位数
50%：数值型数据的中位数
75%：数值型数据的上四分位数
max：数值型数据的最大值
'''# ----------查看数据-----------
# 直接查看数据
# print(data1[1:5]["加热中"])
# 通过索引和列名来查看数据
# print(data1.loc[1:5]["加热中"])
# 通过第几行，第几列来查看数据
# print(data1.iloc[1:5, 5])# ----------修改数据-----------# ----------增加数据-----------
# 新增一列
# data1['new'] = 'new'
# 新增一行
# data1.loc['new', :] = 'new'# ----------删除数据-----------
# 删除列
# data1.drop('new', axis=1, inplace=True)
# 删除行
# data1.drop('new', axis=0, inplace=True)# ----------替代数据-----------
# data1.iloc[1, :] = data1.iloc[0, :]# ---------转换数据类型--------
# 转换时间
data1["发生时间"] = pd.to_datetime(data1["发生时间"], format='%Y%m%d%H%M%S')
print(data1["发生时间"])
import pandas as pd
import numpy as np
from scipy.interpolate import interp1d
from scipy.interpolate import lagrange
from scipy.interpolate import spline
from sklearn.cluster import KMeansdata_forest_fires = pd.read_csv("data/forestfires.csv", encoding='gbk')
data1 = pd.read_excel("data/original_data.xls", sheet_name="原始数据")
data2 = pd.read_excel("data/original_data.xls", sheet_name="属性规约")
data_mtcars = pd.read_csv("data/mtcars.csv")# 转换时间
data1["发生时间"] = pd.to_datetime(data1["发生时间"], format='%Y%m%d%H%M%S')
# data1.info()
# print(data1.head())
# data1.loc[1, "发生时间"].day# 新增一列日期
data1["日期"] = [i.day for i in data1["发生时间"]]
# print(data1.head())# 新增一列第几周
data1["第几周"] = [i.weekofyear for i in data1["发生时间"]]
# print(data1.head())# 新增一列一周第几天
data1["星期几"] = [i.weekday for i in data1["发生时间"]]# data1.to_csv("data/original_data_day.csv")# 查看时间最大值
# print(data1['发生时间'].max())# --------------------------------------分组聚合---------------------------------------
# ---分组---
group_day = data1.groupby("日期")
group_day_water = data1.groupby(["日期", "有无水流"])
# 查看分组个数
# print(group_day.size())
# print(group_day_water.size())# ---聚合---# agg 函数或包含了字段名和函数的字典
# 对不同的列进行不同的聚合操作
# print(group_day.agg({'发生时间': max, '水流量': sum}))
# 上述过程中使用的函数均为系统math库所带的函数，若需要使用pandas的函数则需要做如下操作
group_day.agg({'发生时间': lambda x: x.max(), '水流量': lambda x: x.sum()})# apply 只能对所有列执行同一种操作
group_day.apply(lambda x: x.max())# transform 常用来组内标准化,transform操作时的对象不再是每一组，而是每一个元素
# print(group_day['热水器编号'].transform(lambda x: x.astype(str)+'China').head())
# 组内标准化
group_day['水流量'].transform(lambda x: (x.mean()-x.min())/(x.max()-x.min())).head()# --------------------------------------数据清洗---------------------------------------# data_training_Master = pd.read_csv("Training_Master.csv", encoding='gbk')
df1 = pd.DataFrame({'一班': [90, 80, 66, 75, 99, 55, 76, 78, 98, None, 90],
'二班': [75, 98, 100, None, 77, 45, None, 66, 56, 80, 57],
'三班': [45, 89, 77, 67, 65, 100, None, 75, 64, 88, 99]})print(df1)
# -------------数据删除-------------
# dropna()
'''
axis：表示轴向。默认为0，表示删除所有含有空值的行。
how：表示删除的方式。默认为any。为any的时候，表示只要存在缺失值就删除。为all的时候，表示全部是缺失值才能删除。
subset：表示删除的主键，默认为全部。注意，使用任意主键均需要将其放入list中。且主键和axis对应。
inplace：表示是否对原数据进行操作。默认为False，不对原数据操作。
'''
df1.dropna(axis=0, how='any')
# 判断缺失值
df1.notna()# -------------定值替换法-------------
'''
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
value：表示传入的定值。可为某一个值，dict,Series,DataFrame。无默认
method：此参数存在，则不传入value。表示使用前一个非空值或后一个非空值进行缺失值填补。无默认。
axis：表示轴向。
inplace：表示是否对原数据进行操作。默认为False，不对原数据操作。
limit：表示插补多少次。默认全量插补。
'''
# df1.fillna(-999)
# df1.fillna({'一班':-60,'二班':-70,'三班':-80})# -------------插补法-------------
df1.fillna(method='ffill')# -------------插值法-------------
# 用inteerpolate包
# 默认linear
df1.interpolate()
# 线性插值
linear = df1['一班'][df1['一班'].notnull()]
LinearInsValue1 = interp1d(linear.index, linear.values, kind='linear')
LinearInsValue1(df1['一班'][df1['一班'].isnull()].index)
# 拉格朗日插值,使用非空索引为因变量，对应的元素为自变量，创建了一个拉格朗日拟合公式
LargeInsValue1 = lagrange(linear.index, linear.values)
LargeInsValue1(df1['一班'][df1['一班'].isnull()].index)
# 样条插值
spline(linear.index, linear.values,
xnew=df1['一班'][df1['一班'].isnull()].index)# -------------数据校验-------------# 判断是否为缺失值（空值）
df1.isnull()
# 统计出每一列的缺失值数目
df1.isnull().sum()
# 每一列缺失比例
df1.isnull().sum()/df1.shape[0]
# 使用describe方法查看数据的完整性,统计出了非空值的数目
print(df1.describe().iloc[0, :])# 特征值检验，相似度
'''
特征重复检验
针对数值型的特征（列）
特征重复检验需要用到相似度的概念
pearson相似度
spearman相似度
kendall相似度
使用的pandas方法为 DataFrame.corr(method = 'pearson')
method：表示求取相似度的方法，可取pearson，kendall，spearman。默认为pearson
'''
# 对分类型数据要去空格！！！
asso = df1.corr()
print(asso)
# 自定义一个输入相似度矩阵，输出应剔除的列名的自定义函数def drop_features(assoMat,assoRate = 1.0):
'''
此函数用于求取相似度大于assoRate的两列中的一个，主要目的用于去除数值型特征的重复
assoMat：相似度矩阵，无默认
assoRate：相似度，默认为1
'''
delCol = []
length = len(assoMat)
for i in range(length):
for j in range(i+1, length):
if asso.iloc[i, j] >= assoRate:
delCol.append(assoMat.columns[j])
return(delCol)
drop_features(asso)# -------------样本重复检验-------------
df2 = pd.DataFrame({'一班': [90, 80, 66, 90, 99, 55, 76, 90, 98, None, 90],
'二班': [75, 98, 100, 75, 77, 45, None, 75, 56, 80, 57],
'三班': [45, 89, 77, 45, 65, 100, None, 45, 64, 88, 99],
'四班': [75, 98, 100, 75, 77, 45, None, 75, 56, 80, 57]})
# print(df2)
'''
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)
subset：表示以这几个特征为基础，对整体样本进行去重。默认为使用所有特征
keep：表示保留第几个重复的样本。只允许填入first（保留第一个）,last(保留最后一个)，False(只要存在重复均不保留)。默认为first
inplace：表示是否在原DataFrame上进行操作,会改变原数据。默认为False
'''
# 剔除重复行
# df2.drop_duplicates()
# 计算样本重复率
# 计算样本重复率
# (df2.shape[0] - df2.drop_duplicates().shape[0])/df2.shape[0]# -------------异常值处理-------------
# 3σ原则检测异常值
# 定义3σ法则识别异常值函数
def outRange(Ser1):
'''
Ser1：表示传入DataFrame的某一列。
'''
boolInd = (Ser1.mean()-3*Ser1.std() > Ser1) | (Ser1.mean()+3*Ser1.std() < Ser1)
index = np.arange(Ser1.shape[0])[boolInd] # range to array
outrange = Ser1.iloc[index]
return outrange
df = pd.read_csv('./data/detail.csv', encoding='gbk')
print(outRange(df['counts']).head())# 箱线图检测异常值
def boxOutRange(Ser):
'''
Ser：进行异常值分析的DataFrame的某一列
'''
Low = Ser.quantile(0.25)-1.5*(Ser.quantile(0.75)-Ser.quantile(0.25))
Up = Ser.quantile(0.75)+1.5*(Ser.quantile(0.75)-Ser.quantile(0.25))
index = (Ser < Low) | (Ser > Up)
Outlier = Ser.loc[index]
return(Outlier)
# print(boxOutRange(df['counts']))# --------------------------------------数据合并---------------------------------------df1 = pd.DataFrame({'一班':[90,80,66,75,99,55,76,78,98,None,90],
'二班':[75,98,100,None,77,45,None,66,56,80,57],
'三班':[45,89,77,67,65,100,None,75,64,88,99]})
df2 = pd.DataFrame({'一班':[90,80,66,75,99,55,76,78,98,None,90],
'二班':[75,98,100,None,77,45,None,66,56,80,57],
'三班':[45,89,77,67,65,100,None,75,64,88,99]})# append 直接在末尾追加，注意特征数目相同，并且数据类型相同
# print(df1.append(df2))# concat
# print(pd.concat([df1, df2], axis=1))# 主键合并
'''
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, suffixes=('_x', '_y'))
left：表示进行合并的左边的DataFrame。无默认。
right：表示进行合并的右边的DataFrame。无默认。
how：表示合并的方法。默认为'inner'。可取'left'(左连接),'right'（右连接）,'inner'（内连接）,'outer'（外连接）。
on：表示合并的主键。默认为空。
left_on：表示左边的合并主键。默认为空。
right_on：表示右边的合并主键。默认为空。
suffixes：表示列名相同的时候的后缀。默认为('_x', '_y')
'''
# 合并数据
# print(pd.merge(df1, df2, on='一班')) # 因为90出现两次，在进行合并时，合并了4次
# print(pd.merge(df1, df2, left_on='一班', right_on='二班', suffixes=('_1', '_2')))
# 重叠合并
# DataFrame.combine_first(other) 重叠合并，当两者皆有以前者为准，为空时，则使用后者的补上。
df1['一班'].combine_first(df1['二班'])# --------------------------------------数据变换---------------------------------------df = pd.DataFrame({'性别': ['男', '女', '男'],
'学历': ['本科', '硕士', '本科'],
'民族': ['汉族', '仫佬族', '维吾尔族']})# -------------哑变量处理/独热编码-------------
'''
pd.get_dummies(data, prefix=None, prefixsep='', dummy_na=False, columns=None, sparse=False, drop_first=False)
data：进行哑变量处理的数据，无默认，不可省略
prefix：前缀字符串
prefixsep：连接字符串，默认为''
dummy_na：表示是否将缺失值单独作为一类，默认为False，表示不将缺失值单独作为一类。
columns：表示进行哑变量处理的列，仅接收list，默认所有的类别型的列。
drop_first：表示是否剔除第一种类型，默认为False，表示不剔除。
'''
print(pd.get_dummies(df, prefix_sep='_'))
print(pd.get_dummies(df, prefix_sep='_', columns=['学历']))
print(pd.get_dummies(df, prefix_sep=':', drop_first=True))## 证据权重函数def total_response(data, label):
value_count = data[label].value_counts()
return value_countdef woe(data, feature, label, label_value):
'''
data：传入需要做woe的特征和标签两列数据
feature：特征名
label：标签名
label_value:接收字典，key为1，0，表示为响应和未响应，value为对应的值
'''
import pandas as pd
import numpy as np
idx = pd.IndexSlice data['woe'] = 1
groups = data.groupby([label, feature]).count().sort_index() ## 使用上述函数
value_counts = total_response(data, label) resp_col = label_value[1]
not_resp_col = label_value[0]
resp = groups.loc[idx[resp_col, :]] / value_counts[resp_col]
not_resp = groups.loc[idx[not_resp_col, :]] / value_counts[not_resp_col]
Woe = np.log(resp / not_resp).fillna(0)
return Woe# -------------连续型数据离散化-------------
lsh = pd.DataFrame({'年龄':[18,16,15,17,19,28,80,55,36,43,12,23],
'身高':[180,160,150,170,170,153,165,155,162,170,120,185]})# -------------等宽离散化-------------
pd.cut(lsh['年龄'], bins=5)
# pd.cut(lsh['年龄'],bins=5,labels = ['青少年','而立','不惑','耳顺','耄耋'])# -------------等频离散化-------------
# 自定义等频法离散化函数
def SameRateCut(data,k):
import numpy as np
w = data.quantile(np.arange(0, 1+1.0/k, 1.0/k))
data = pd.cut(data,w, include_lowest=True)
return data
print(SameRateCut(lsh['身高'],5))# -------------聚类离散化-------------
# def KmeanCut(data,k):
# kmodel=KMeans(n_clusters=k, n_jobs=4) ##建立模型，n_jobs是并行数
# kmodel.fit(data.reshape((len(data), 1))) ##训练模型
# c=pd.DataFrame(kmodel.cluster_centers_).sort_values(0) ##输出聚类中心并排序
# w=pd.rolling_mean(c, 2).iloc[1:] ##相邻两项求中点，作为边界点
# w=[0]+list(w[0])+[data.max()] ##把首末边界点加上
# data=pd.cut(data,w)
# return data
# print(KmeanCut(lsh['年龄'],5))# --------------------------------------透视表和交叉表---------------------------------------
df = pd.DataFrame({'性别': ['男', '女', '男'],
'学历': ['本科', '硕士', '本科'],
'民族': ['汉族', '仫佬族', '维吾尔族']})'''
log_info1 = pd.pivot_table(data_training_LogInfo[['Idx', 'LogInfo1', 'Listinginfo1']], index='Idx',
values='Listinginfo1', columns='LogInfo1',
aggfunc='count', fill_value=0).reset_index()
# index = 索引行
# values = 想要探究的值
# columns = 列，类似index吧
# aggfunc 聚合函数
'''print(df1)
# sklearn 学习# 读取数据集
from sklearn.datasets import load_iris
iris = load_iris()# print(iris)# print(iris.keys())data = iris['data'] # 数据内容
target = iris['target'] # 属于花的种类
target_names = iris['target_names'] # 种类名
DESR = iris['DESCR'] # 描述
feature_names = iris['feature_names'] # 列名# print(target)
# ---------------------------分类模型构建 (离散)--------------------------------
'''
模块 函数 算法名称
linear_model LogisticRegression 逻辑斯蒂回归
svm SVC 支持向量机
neighbors KNeighborsClassifier K最近邻分类
naive_bayes GaussianNB 高斯朴素贝叶斯
tree DecisionTreeClassifier 分类决策树
ensemble RandomForestClassifier 随机森林分类
ensemble GradientBoostingClassifier 梯度提升分类树
'''# -------------------------------回归模型构建（连续）--------------------------------
'''
模块 函数 算法名称
linear_model LinearRegression 线性回归
svm SVR 支持向量机回归
neighbors KNeighborsRegressor 最近邻回归
tree DecisionTreeRegressor 回归决策树
ensemble RandomForestRegressor 随机森林回归
ensemble GradientBoostingRegressor 梯度提升回归树
'''# -------------------------------KMeans 算法--------------------------------
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3, random_state=123).fit(data)
print(kmeans.labels_)# 对数据要进行标准化， 因为要进行计算时，特征x与y应该对等，若差别太大，会削弱其中一个特征的作用
from sklearn.preprocessing import StandardScaler, MinMaxScaler# 标准差标准化，x-均值/标准差
scale = StandardScaler().fit(data) # 训练规则
X = scale.transform(data) # 应用规则
kmeans = KMeans(n_clusters=3, random_state=123).fit(X)
# print(kmeans.labels_)# 离差标准化， x-min/max-min
scale = MinMaxScaler().fit(data) # 训练规则
X = scale.transform(data) # 应用规则
kmeans = KMeans(n_clusters=3, random_state=123).fit(X)
# print(kmeans.labels_)# 检验kmeans的优劣度,silhoutte_scorce和c
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt
silhouettteScore = []
for i in range(2, 15):
kmeans = KMeans(n_clusters=i, random_state=123).fit(X) # 构建并训练模型
score = silhouette_score(X, kmeans.labels_)
silhouettteScore.append(score)
plt.figure(figsize=(10, 6))
plt.plot(range(2, 15), silhouettteScore, linewidth=1.5, linestyle="-")
plt.show()# -------------------------------KNN分类算法(不适合用高维)--------------------------------
# 数据集划分
'''
一般在日常工作中将数据集拆分为训练集（train_set）和测试集（test_set）
训练集：一般用于训练模型，需要尽可能保证训练的数据具有代表性。
测试集：用于测试模型，检测模型的性能（包括了运行时间，模型的效果等）
trian_test_split(*arrays,train_size,test_size,ramdom_state)
*arrays：表示需要进行划分的数据，可以为多个。
train_size：训练集所占总数据的比例，0-1的浮点数。无默认
test_size：测试集所占总数据的比例，和train_size相加为1，在填写了train_size的情况下可以省略
random_state：设置随机种子，保证后续每次划分的结果相同
'''
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X = data['data']
y = data['target']
names = data['feature_names']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
# 标准化
from sklearn.preprocessing import StandardScaler
Standard = StandardScaler().fit(X_train) # 训练产生标准化的规则,因为数据集分为训练与测试，测试相当于后来的。Xtrain = Standard.transform(X_train) # 将规则应用于训练集
Xtest = Standard.transform(X_test) # 将规则应用于测试集
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier().fit(Xtrain, y_train)
y_pred = knn.predict(Xtest)# 分类算法评价常用函数,只适用于2分类。要么是要么否
'''
方法名称 最佳值 sklearn函数
Precision（精确率） 1.0 metrics.precision_score
Recall（召回率） 1.0 metrics.recall_score
F1值 1.0 metrics.f1_score
Cohen’s Kappa系数 1.0 metrics.cohen_kappa_score
ROC曲线 最靠近y轴 metrics. roc_curve
AUC(ROC的积分) 1.0 metrics.auc
'''
from sklearn.metrics import precision_score, recall_score, f1_score, cohen_kappa_score, roc_curve
# print(precision_score(y_test, y_pred))
# print(recall_score(y_test, y_pred))
# print(f1_score(y_test, y_pred))
# print(cohen_kappa_score(y_test, y_pred))
# print(roc_curve(y_test, y_pred))# 输出上述的常用判定函数值
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))# 绘制roc曲线
from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = 'SimHei' # 改字体
# 求出ROC曲线的x轴和Y轴
fpr, tpr, thresholds = roc_curve(y_test, y_pred)
plt.figure(figsize=(10, 6))
plt.xlim(0, 1) # 设定x轴的范围
plt.ylim(0.0, 1.1) # 设定y轴的范围
plt.xlabel('假正率')
plt.ylabel('真正率')
plt.plot(fpr, tpr, linewidth=2, linestyle="-", color='red')
plt.show()
