目录
二、将分类数据和顺序数据转换为标志变量--非数值型转换为数值型
一.缺失值的处理4种 详见pandas教程
二、将分类数据和顺序数据转换为标志变量--非数值型转换为数值型
自己定义手动--有代码了推荐用这个，更人性化
import pandas as pd # 导入pandas库
from sklearn.preprocessing import OneHotEncoder # 导入OneHotEncoder库
# 生成数据
df = pd.DataFrame({'id': [3566841, 6541227, 3512441],
'sex': ['male', 'Female', 'Female'],
'level': ['high', 'low', 'middle']})
print (df) # 打印输出原始数据框
# 自定义转换主过程
df_new = df.copy() # 复制一份新的数据框用来存储转换结果
for col_num, col_name in enumerate(df): # 循环读出每个列的索引值和列名
col_data = df[col_name] # 获得每列数据
col_dtype = col_data.dtype # 获得每列dtype类型
if col_dtype == 'object': # 如果dtype类型是object（非数值型），执行条件
df_new = df_new.drop(col_name, 1) # 删除df数据框中要进行标志转换的列
value_sets = col_data.unique() # 获取分类和顺序变量的唯一值域
for value_unique in value_sets: # 读取分类和顺序变量中的每个值
col_name_new = col_name + '_' + value_unique # 创建新的列名，使用原标题+值的方式命名
col_tmp = df.iloc[:, col_num] # 获取原始数据列
new_col = (col_tmp == value_unique) # 将原始数据列与每个值进行比较，相同为True，否则为False
df_new[col_name_new] = new_col # 为最终结果集增加新列值
print (df_new) # 打印输出转换后的数据框# 使用sklearn进行标志转换
df2 = pd.DataFrame({'id': [3566841, 6541227, 3512441],
'sex': [1, 2, 2],
'level': [3, 1, 2]})
id_data = df2.values[:, :1] # 获得ID列
transform_data = df2.values[:, 1:] # 指定要转换的列
enc = OneHotEncoder() # 建立模型对象
df2_new = enc.fit_transform(transform_data).toarray() # 标志转换
df2_all = pd.concat((pd.DataFrame(id_data), pd.DataFrame(df2_new)), axis=1) # 组合为数据框
print (df2_all) # 打印输出转换后的数据框三、特征降维
下面的1和2代码放在一起的
1.判断变量重要性
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.decomposition import PCA
# 读取数据文件
data = np.loadtxt('data1.txt') # 读取文本数据文件
x = data[:, :-1] # 获得输入的x
y = data[:, -1] # 获得目标变量y
print (x[0], y[0]) # 打印输出x和y的第一条记录
# 使用sklearn的DecisionTreeClassifier判断变量重要性
model_tree = DecisionTreeClassifier(random_state=0) # 建立分类决策树模型对象
model_tree.fit(x, y) # 将数据集的维度和目标变量输入模型
feature_importance = model_tree.feature_importances_ # 获得所有变量的重要性得分
print (feature_importance) # 打印输出
#[0.03331054 0.01513967 0.02199713 0.119727 0.47930312 0.04776297
#0.17111746 0.02585441 0.02012725 0.06566044]2、使用sklearn的PCA进行维度转换
# 使用sklearn的PCA进行维度转换
model_pca = PCA() # 建立PCA模型对象
model_pca.fit(x) # 将数据集输入模型
model_pca.transform(x) # 对数据集进行转换映射
components = model_pca.components_ # 获得转换后的所有主成分
components_var = model_pca.explained_variance_ # 获得各主成分的方差
components_var_ratio = model_pca.explained_variance_ratio_ # 获得各主成分的方差占比
print (components[:2]) # 打印输出前2个主成分
print (components_var[:2]) # 打印输出前2个主成分的方差
print (components_var_ratio) # 打印输出所有主成分的方差占比四、解决样本类别分布不均衡的问题--（待完善）
分类问题首先要观察的！
不均衡：不同类别的的样本量差异非常大
1、查看样本类别分布情况--好像不用这么麻烦用第一个就好
#--------------------这个就好用啊
from collections import Counter
Counter(datefram['playerShort']) #Counter({nan: 110, '女': 689, '男': 1364}) 这里参数不是[['性别']]，一个中括号
# ---------------------------------------------
import pandas as pd
# 导入数据文件
df = pd.read_table('data2.txt', sep=' ', names=['col1', 'col2', 'col3', 'col4', 'col5', 'label']) # 读取数据文件
x = df.iloc[:, :-1] # 切片，得到输入x
y = df.iloc[:, -1] # 切片，得到标签y
groupby_data_orgianl = df.groupby('label').count() # 对label做分类汇总
print (groupby_data_orgianl) # 打印输出原始数据集样本分类分布
#两个类别：0和1，0:942个，1:58个 严重不均等需要做处理了
col1 col2 col3 col4 col5
label
0.0 942 942 942 942 942
1.0 58 58 58 58 58五、抽样数据
# 简单随机抽样
# 等距抽样
# 分层抽样
# 整群抽样
import random # 导入标准库
import numpy as np # 导入第三方库
# 简单随机抽样
data = np.loadtxt('data3.txt') # 导入普通数据文件
data_sample = random.sample(data, 2000) # 随机抽取2000个样本
print (data_sample[:2]) # 打印输出前2条数据
print (len(data_sample)) # 打印输出抽样样本量
# 等距抽样
data = np.loadtxt('data3.txt') # 导入普通数据文件
sample_count = 2000 # 指定抽样数量
record_count = data.shape[0] # 获取最大样本量
width = record_count / sample_count # 计算抽样间距
data_sample = [] # 初始化空白列表，用来存放抽样结果数据
i = 0 # 自增计数以得到对应索引值
while len(data_sample) <= sample_count and i * width <= record_count - 1: # 当样本量小于等于指定抽样数量并且矩阵索引在有效范围内时
data_sample.append(data[i * width]) # 新增样本
i += 1 # 自增长
print (data_sample[:2]) # 打印输出前2条数据
print (len(data_sample)) # 打印输出样本数量
# 分层抽样
# 导入有标签的数据文件
data2 = np.loadtxt('data2.txt') # 导入带有分层逻辑的数据
each_sample_count = 200 # 定义每个分层的抽样数量
label_data_unique = np.unique(data2[:, -1]) # 定义分层值域
sample_list = [] # 定义空列表，用于存放临时分层数据
sample_data = [] # 定义空列表，用于存放最终抽样数据
sample_dict = {} # 定义空字典，用来显示各分层样本数量
for label_data in label_data_unique: # 遍历每个分层标签
for data_tmp in data2: # 读取每条数据
if data_tmp[-1] == label_data: # 如果数据最后一列等于标签
sample_list.append(data_tmp) # 将数据加入到分层数据中
each_sample_data = random.sample(sample_list, each_sample_count) # 对每层数据都随机抽样
sample_data.extend(each_sample_data) # 将抽样数据追加到总体样本集
sample_dict[label_data] = len(each_sample_data) # 样本集统计结果
print (sample_dict) # 打印输出样本集统计结果
# 整群抽样
data3 = np.loadtxt('data4.txt') # 导入已经划分好整群的数据集
label_data_unique = np.unique(data3[:, -1]) # 定义整群标签值域
print (label_data_unique) # 打印输出所有整群标签
sample_label = random.sample(label_data_unique, 2) # 随机抽取2个整群
sample_data = [] # 定义空列表，用来存储最终抽样数据
for each_label in sample_label: # 遍历每个整群标签值域
for data_tmp in data3: # 遍历每个样本
if data_tmp[-1] == each_label: # 判断样本是否属于抽样整群
sample_data.append(data_tmp) # 样本添加到最终抽样数据集
print (sample_label) # 打印输出样本整群标签
print (len(sample_data)) # 打印输出总抽样数据记录条数六、数据特征的共线性问题：
特征和特征之间存在共线性问题
使用岭回归算法进行回归分析
使用主成分回归进行回归分析
import numpy as np
from sklearn.linear_model import Ridge
from sklearn.decomposition import PCA
from sklearn.linear_model import LinearRegression
# 读取数据
data = np.loadtxt('data5.txt', delimiter='\t') # 读取数据文件
x = data[:, :-1] # 切分自变量
y = data[:, -1] # 切分预测变量
# 使用岭回归算法进行回归分析
model_ridge = Ridge(alpha=1.0) # 建立岭回归模型对象
model_ridge.fit(x, y) # 输入x/y训练模型
print (model_ridge.coef_) # 打印输出自变量的系数
print (model_ridge.intercept_) # 打印输出截距
# 使用主成分回归进行回归分析
model_pca = PCA() # 建立PCA模型对象
data_pca = model_pca.fit_transform(x) # 将x进行主成分分析
ratio_cumsm = np.cumsum(model_pca.explained_variance_ratio_) # 得到所有主成分方差占比的累积数据
print (ratio_cumsm) # 打印输出所有主成分方差占比累积
rule_index = np.where(ratio_cumsm > 0.8) # 获取方差占比超过0.8的所有索引值
min_index = rule_index[0][0] # 获取最小索引值
data_pca_result = data_pca[:, :min_index + 1] # 根据最小索引值提取主成分
model_liner = LinearRegression() # 建立回归模型对象
model_liner.fit(data_pca_result, y) # 输入主成分数据和预测变量y并训练模型
print (model_liner.coef_) # 打印输出自变量的系数
print (model_liner.intercept_) # 打印输出截距七、特征之间的相关性分析
每个特征和每个特征相关性进行分析：有点像协方差矩阵一样
import numpy as np # 导入库
data = np.loadtxt('data5.txt', delimiter='\t') # 读取数据文件
x = data[:, :-1] # 切分自变量
correlation_matrix = np.corrcoef(x, rowvar=0) # 相关性分析
print (correlation_matrix.round(2)) # 打印输出相关性结果
[[ 1. -0.04 0.27 -0.05 0.21 -0.05 0.19 -0.03 -0.02]
[-0.04 1. -0.01 0.73 -0.01 0.62 0. 0.48 0.51]
[ 0.27 -0.01 1. -0.01 0.72 -0. 0.65 0.01 0.02]
[-0.05 0.73 -0.01 1. 0.01 0.88 0.01 0.7 0.72]
[ 0.21 -0.01 0.72 0.01 1. 0.02 0.91 0.03 0.03]
[-0.05 0.62 -0. 0.88 0.02 1. 0.03 0.83 0.82]
[ 0.19 0. 0.65 0.01 0.91 0.03 1. 0.03 0.03]
[-0.03 0.48 0.01 0.7 0.03 0.83 0.03 1. 0.71]
[-0.02 0.51 0.02 0.72 0.03 0.82 0.03 0.71 1. ]]
九、归一化（待完善）
# 3.9 标准化，让运营数据落入相同的区间
import numpy as np
from sklearn import preprocessing
import matplotlib.pyplot as plt
data = np.loadtxt('data6.txt', delimiter='\t') # 读取数据
# Z-Score标准化
zscore_scaler = preprocessing.StandardScaler() # 建立StandardScaler对象
data_scale_1 = zscore_scaler.fit_transform(data) # StandardScaler标准化处理
# Max-Min标准化
minmax_scaler = preprocessing.MinMaxScaler() # 建立MinMaxScaler模型对象
data_scale_2 = minmax_scaler.fit_transform(data) # MinMaxScaler标准化处理
# MaxAbsScaler标准化
maxabsscaler_scaler = preprocessing.MaxAbsScaler() # 建立MaxAbsScaler对象
data_scale_3 = maxabsscaler_scaler.fit_transform(data) # MaxAbsScaler标准化处理
# RobustScaler标准化
robustscalerr_scaler = preprocessing.RobustScaler() # 建立RobustScaler标准化对象
data_scale_4 = robustscalerr_scaler.fit_transform(data) # RobustScaler标准化标准化处理
# 展示多网格结果
data_list = [data, data_scale_1, data_scale_2, data_scale_3, data_scale_4] # 创建数据集列表
scalar_list = [15, 10, 15, 10, 15, 10] # 创建点尺寸列表
color_list = ['black', 'green', 'blue', 'yellow', 'red'] # 创建颜色列表
merker_list = ['o', ',', '+', 's', 'p'] # 创建样式列表
title_list = ['source data', 'zscore_scaler', 'minmax_scaler', 'maxabsscaler_scaler', 'robustscalerr_scaler'] # 创建标题列表
for i, data_single in enumerate(data_list): # 循环得到索引和每个数值
plt.subplot(2, 3, i + 1) # 确定子网格
plt.scatter(data_single[:, :-1], data_single[:, -1], s=scalar_list[i], marker=merker_list[i],
c=color_list[i]) # 子网格展示散点图
plt.title(title_list[i]) # 设置子网格标题
plt.suptitle("raw data and standardized data") # 设置总标题
plt.show() # 展示图形
十、数据离散化
# 3.10 离散化，对连续运营数据做逻辑分层
import pandas as pd
from sklearn.cluster import KMeans
from sklearn import preprocessing
# 读取数据
df = pd.read_table('data7.txt', names=['id', 'amount', 'income', 'datetime', 'age']) # 读取数据文件
print (df.head(5)) # 打印输出前5条数据
# 针对时间数据的离散化
for i, signle_data in enumerate(df['datetime']): # 循环得到索引和对应值
single_data_tmp = pd.to_datetime(signle_data) # 将时间转换为datetime格式
df['datetime'][i] = single_data_tmp.weekday() # 离散化为周几
print (df.head(5)) # 打印输出前5条数据
# 针对多值离散数据的离散化
map_df = pd.DataFrame([['0-10', '0-40'], ['10-20', '0-40'], ['20-30', '0-40'], ['30-40', '0-40'], ['40-50', '40-80'],
['50-60', '40-80'], ['60-70', '40-80'], ['70-80', '40-80'], ['80-90', '>80'], ['>90', '>80']],
columns=['age', 'age2']) # 定义一个要转换的新区间
df_tmp = df.merge(map_df, left_on='age', right_on='age', how='inner') # 数据框关联匹配
df = df_tmp.drop('age', 1) # 丢弃名为age的列
print (df.head(5)) # 打印输出前5条数据
# 针对连续数据的离散化
# 方法1：自定义分箱区间实现离散化
bins = [0, 200, 1000, 5000, 10000] # 自定义区间边界
df['amount1'] = pd.cut(df['amount'], bins) # 使用边界做离散化
print (df.head(5)) # 打印输出前5条数据
# 方法2 使用聚类法实现离散化
data = df['amount'] # 获取要聚类的数据，名为amount的列
data_reshape = data.reshape((data.shape[0], 1)) # 转换数据形状
model_kmeans = KMeans(n_clusters=4, random_state=0) # 创建KMeans模型并指定要聚类数量
keames_result = model_kmeans.fit_predict(data_reshape) # 建模聚类
df['amount2'] = keames_result # 新离散化的数据合并到原数据框
print (df.head(5)) # 打印输出前5条数据
# 方法3：使用4分位数实现离散化
df['amount3'] = pd.qcut(df['amount'], 4, labels=['bad', 'medium', 'good', 'awesome']) # 按四分位数进行分隔
df = df.drop('amount', 1) # 丢弃名为amount的列
print (df.head(5)) # 打印输出前5条数据
# 针对连续数据的二值化
binarizer_scaler = preprocessing.Binarizer(threshold=df['income'].mean()) # 建立Binarizer模型对象
income_tmp = binarizer_scaler.fit_transform(df['income']) # Binarizer标准化转换
income_tmp.resize(df['income'].shape) # 转换数据形状
df['income'] = income_tmp # Binarizer标准化转换
print (df.head(5)) # 打印输出前5条数据