代码

# 1. 使用 Pandas 库读取 “某 APP 用户信息数据.csv” 数据集。

import pandas as pd

import warnings

warnings.filterwarnings('ignore')

user=pd.read_csv(r'F:\3.homework\大三下\数据分析\实验数据data\某APP用户信息数据.csv',encoding='gbk')

# 2. 将不愿分享概率与愿意分享概率特征中的缺失值用 0.0 替换。

user['不愿分享概率']=user['不愿分享概率'].fillna(0.0)

user['愿意分享概率']=user['愿意分享概率'].fillna(0.0)

# 3. 将不愿分享概率与愿意分享概率特征中负值赋值为 0, 并将大于 1 的值改为 1。

user['不愿分享概率'][user['不愿分享概率']<0]=0

user['不愿分享概率'][user['不愿分享概率']>0]=1

user['愿意分享概率'][user['愿意分享概率']<0]=0

user['愿意分享概率'][user['愿意分享概率']>0]=1

# 4. 将是否点击分享特征中的 T 重新赋值为 1, 将 F 重新赋值为 0。

user['是否点击分享'][user['是否点击分享']=='T']=1

user['是否点击分享'][user['是否点击分享']=='F']=0

# (2) 构建与用户使用信息相关的特征。

user_clean=user

# 1. 自定义 to_code 函数，用于对用户名特征首字母进行编码。

coding={}

for i in range(26):

    coding[chr(ord('a')+i)]=i

def to_code(s):

    code=0

    s=s.lower()[0]

    if s in coding:

        code=coding[s]

    return code

# 2. 对在线时长特征进行分段处理后生成分段在线时长新特征。

user_clean['分组后在线时长']=pd.qcut(user_clean['在线时长'],4,labels=[4,3,2,1])

# 3. 使用 apply 方法构建首字母编码新特征。

user_clean['用户编码']=user_clean['用户名'].apply(lambda x : to_code(x))

# (3) 构建 K-Means 聚类模型。

user_f=user_clean

# 1. 读取构建新特征后的数据集，区分标签和数据。

X=user_f[['不愿分享概率','愿意分享概率','在线时长','在线时长占比','分组后在线时长']]

y=user_f['是否点击分享']

from sklearn.cluster import KMeans

from sklearn.metrics import fowlkes_mallows_score

# 2. 构建 K-Means 模型，且聚类数为 2。

model=KMeans(n_clusters=2).fit(X)

# 3. 使用 FMI 评价法评价聚类模型性能。

fmi=fowlkes_mallows_score(y, model.labels_)

print(fmi)

# 使用用户在交易软件上的交易数据 (phone.csv)，预测回收二手手机的价格。

# 现需利用交易数据建立分类模型对二手手机价格进行预测，步骤如下。

import pandas as pd

data=pd.read_csv(r"F:\3.homework\大三下\数据分析\实验数据data\phone.csv")

# (1) 删除有异常值的行 (手机厚度小于等于 0cm)。

phone_data1=data[data['m_dep']>0]

phone_data=phone_data1.drop(['price_range'],axis=1)

phone_target=phone_data1['price_range']

# (2) 建立随机森林分类模型对数据进行训练。

# 将数据划分为训练集测试集，其中测试集占总数据的 30%，随机种子设置为 22。

from sklearn.model_selection import train_test_split

phone_data_train,phone_data_test,phone_target_train,phone_target_test=train_test_split(phone_data,phone_target,test_size=0.3,random_state=22)

# 数据标准化

from sklearn.preprocessing import StandardScaler

stScaler=StandardScaler().fit(phone_data_train)

phone_trainStd=stScaler.transform(phone_data_train)

phone_testStd=stScaler.transform(phone_data_test)

# 建立 RandomForestClassifier 模型 (随机森林)

from sklearn.ensemble import RandomForestClassifier

rfc=RandomForestClassifier().fit(phone_trainStd,phone_target_train)

print('建立的 rfc 模型为：\n', rfc)

# (3) 计算模型准确率，评价分类模型效果。

# 预测训练集结果

phone_target_pred=rfc.predict(phone_testStd)

print('预测的前 20 个结果为：\n', phone_target_pred[:20])

# 计算准确率

import numpy as np

true =np.sum(phone_target_pred == phone_target_test) # 预测正确量

print('预测对的结果数目为：', true)

print('预测错的的结果数目为：', phone_target_test.shape[0] - true)

print('预测结果准确率为：', true / phone_target_test.shape[0])

import pandas as pd

size_data=pd.read_csv(r'F:\3.homework\大三下\数据分析\实验数据data\size_data.csv')

print(size_data.shape)

size_data=size_data.dropna()

null=size_data.isnull().sum()

print(null)

size_data=size_data[size_data['age']>=18]

size_data=size_data[size_data['weight']>=30]

size_data=size_data.reset_index(drop=True)

age_min=size_data['age'].min()

weight_min=size_data['weight'].min()

print(age_min,weight_min)

# 构建 BML_ range 特征

size_data['BMI']=size_data['weight']/((size_data['height']/100)**2)

def bmi_range(data):

    for i in range(len(data)):

        if data[i]<18.5:

            data[i]=0

        elif 18.5<=data[i]<24:

            data[i]=1

        elif 24<=data[i]<28:

            data[i] = 2

        elif data[i]>=28:

            data[i] = 3

size_data['BMI_range']=size_data['BMI']

bmi_range(size_data['BMI_range'])

size_data_end=size_data

# 规划训练集和测试集

size_data=size_data_end.drop('size',axis=1)

size_target=size_data_end['size']

from sklearn.model_selection import train_test_split

size_data_train,size_data_test,size_target_train,size_target_test=train_test_split(

    size_data,size_target,test_size=0.2,random_state=22,shuffle=True,stratify=size_target

)

# 标准化

from sklearn.preprocessing import StandardScaler

scale=StandardScaler().fit(size_data_train)

size_train_scale=scale.transform(size_data_train) # 建模准备

size_test_scale=scale.transform(size_data_test) # 预测准备

# 建模支持向量机 svm、决策树 dtc、随机森林分类模型 rfc

# 支持向量机 svm

from sklearn.svm import SVC

svn=SVC().fit(size_train_scale,size_target_train)

svn_pred=svn.predict(size_test_scale)

# 决策树 dtc

from sklearn.tree import DecisionTreeClassifier

dtc=DecisionTreeClassifier().fit(size_train_scale,size_target_train)

dtc_pred=dtc.predict(size_test_scale)

# 随机森林 rfc

from sklearn.ensemble import RandomForestClassifier

rfc=RandomForestClassifier().fit(size_train_scale,size_target_train)

rfc_pred=rfc.predict(size_test_scale)

from sklearn.metrics import confusion_matrix

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

from sklearn.metrics import f1_score

def test_pre(y,pred):

    print('混淆矩阵：\n',confusion_matrix(y,pred,labels=['S','M','L','XL']))

    print('准确率：\n', precision_score(y,pred,average='macro'))

    print('召回率：\n', recall_score(y,pred,average='macro'))

    print('F1值：\n',f1_score(y,pred,average='macro') )

print('SVM 模型预测结果：')

test_pre(size_target_test, svn_pred)

print('决策树 模型预测结果：')

test_pre(size_target_test, dtc_pred)

print('随机森林 模型预测结果：')

test_pre(size_target_test, rfc_pred)

# (1) 读取钻石价格数据集 (diamond_price.csv)。

import pandas as pd

diamond = pd.read_csv(r"F:\3.homework\大三下\数据分析\实验数据data\diamond_price.csv", encoding='gbk')

# (2) 经过观察数据发现，长度、宽度、高度特征存在 0 值，删除该 3 个特征中所有出现 0 值的行数据，并对其他数据进行重新索引。

diamond = diamond.drop(diamond[

                           (diamond['X(length)'] == 0) |

                           (diamond['Y(width)'] == 0) |

                           (diamond['Z(Depth)'] == 0)].index)

# 对其他数据进行重新索引。

diamond.reset_index(inplace=True,drop=True)

# (3) 新增价格 (人民币) 特征，假定 1 美元等于 6.50 人民币。

diamond['price_RMB'] =  diamond['Price(in US dollars)'] * 6.50

# (4) 拆分特征数据和标签数据，特征数据为克拉、切工等级、色泽、净度、台宽比、长度、宽度、高度，标签数据为价格 (人民币) 特征。

diamond_data = diamond.iloc[:, :-2]

diamond_target = diamond.iloc[:, -1]

# (5) 划分训练集和测试集，并对训练集和测试集进行标准差标准化。

# 划分训练集和测试集

from sklearn.model_selection import train_test_split

diamond_data_train, diamond_data_test, diamond_target_train, diamond_target_test = train_test_split(

    diamond_data, diamond_target, test_size=0.2,random_state=2

)

# 标准差标准化

from sklearn.preprocessing import StandardScaler

scale = StandardScaler().fit(diamond_data_train,diamond_target_train)

diamond_trainScaler = scale.transform(diamond_data_train)

diamond_testScaler = scale.transform(diamond_data_test)

# (6) 构建 SVR 等至少两种回归模型进行钻石价格预测，并输出回归模型评价指标，查看模型效果。

# 构建回归模型

from sklearn.svm import LinearSVR

# 支持向量回归

SVR_diamond = LinearSVR().fit(diamond_data_train, diamond_target_train)

y_pred1 = SVR_diamond.predict(diamond_data_test)

#梯度提升回归

from sklearn.ensemble import  GradientBoostingRegressor

GBR_diamond = GradientBoostingRegressor().fit(diamond_trainScaler, diamond_target_train)

y_pred2 = GBR_diamond.predict(diamond_testScaler)

#回归决策树

from sklearn.tree import  DecisionTreeRegressor

DTR_diamond =  DecisionTreeRegressor().fit(diamond_trainScaler, diamond_target_train)

y_pred3 = DTR_diamond .predict(diamond_testScaler)

#线性回归

from sklearn.linear_model import LinearRegression

LR_diamond =   LinearRegression().fit(diamond_trainScaler, diamond_target_train)

y_pred4 = LR_diamond .predict(diamond_testScaler)

#最近邻回归

from sklearn.neighbors import  KNeighborsRegressor

KNR_diamond =  KNeighborsRegressor().fit(diamond_trainScaler, diamond_target_train)

y_pred5 = DTR_diamond .predict(diamond_testScaler)

#定义评价函数

from sklearn.metrics import explained_variance_score,  r2_score

def test(y0,y1):

    print('回归模型的可解释方差值为：',

          explained_variance_score(y0,y1))

    print('回归模型的R方值为：',

          r2_score(y0, y1))

print("支持向量回归:")

test(diamond_target_test, y_pred1)

print("梯度提升回归:")

test(diamond_target_test, y_pred2)

print("回归决策树:")

test(diamond_target_test, y_pred3)

print("线性回归:")

test(diamond_target_test, y_pred4)

print("最近邻回归:")

test(diamond_target_test, y_pred5)