代码：

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
import pickle
from sklearn.metrics import mean_squared_error, r2_score
import xgboost as xgb
    # 加载数据集
df = pd.read_csv('fitness analysis.csv')
    # 显示前五行数据
print(df.head())
    # 去除所有字符串字段的前后空格
df = df.applymap(lambda x: x.strip() if isinstance(x, str) else x)
    # 检查和清理列名
df.columns = df.columns.str.strip()
    # 选择相关特征进行建模
X = df[['Your gender', 'How important is exercise to you ?', 'How healthy do you consider yourself?']]
X = pd.get_dummies(X)  # 将分类变量转为数值变量
    # 将年龄段转为数值变量
y = df['Your age'].apply(lambda x: int(x.split(' ')[0]))  # 假设年龄段为整数
    # 将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    # 创建并训练随机森林回归模型
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)
    # 保存训练好的模型
with open('2.2.3_model.pkl', 'wb') as model_file:
    pickle.dump(rf_model, model_file)
    # 进行结果预测
y_pred = rf_model.predict(X_test)
results_df = pd.DataFrame(y_pred, columns=['预测结果'])
results_df.to_csv('2.2.3_results.txt', index=False)
    # 使用测试工具对模型进行测试，并记录测试结果
train_score = rf_model.score(X_train, y_train)
test_score = rf_model.score(X_test, y_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
with open('2.2.3_report.txt', 'w') as report_file:
     report_file.write(f'训练集得分: {train_score}\n')
     report_file.write(f'测试集得分: {test_score}\n')
     report_file.write(f'均方误差(MSE): {mse}\n')
     report_file.write(f'决定系数(R^2): {r2}\n')
    # 运用工具分析算法中错误案例产生的原因并进行纠正
    #初始化XGBoost回归模型（构建100棵树）
xgb_model = xgb.XGBRegressor(n_estimators=100, random_state=42)
xgb_model.fit(X_train, y_train)
y_pred_xgb = xgb_model.predict(X_test)
results_df_xgb = pd.DataFrame(y_pred_xgb, columns=['预测结果'])
results_df_xgb.to_csv('2.2.3_results_xgb.txt', index=False)
with open('2.2.3_report_xgb.txt', 'w') as xgb_report_file:
     xgb_report_file.write(f'XGBoost训练集得分: {xgb_model.score(X_train, y_train)}\n')
     xgb_report_file.write(f'XGBoost测试集得分: {xgb_model.score(X_test, y_test)}\n')
     xgb_report_file.write(f'XGBoost均方误差(MSE): {mean_squared_error(y_test, y_pred_xgb)}\n')
     xgb_report_file.write(f'XGBoost决定系数(R^2): {r2_score(y_test, y_pred_xgb)}\n')

代码：

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

import pickle

from sklearn.ensemble import RandomForestRegressor

# 加载数据集

df = pd.read_csv('auto-mpg.csv')

# 显示前五行数据

print(df.head())

# 处理缺失值

# 将 'horsepower' 列中的所有值转换为数值类型

df['horsepower'] = pd.to_numeric(df['horsepower'], errors='coerce')

# 删除包含缺失值的行

df = df.dropna()

# 选择相关特征进行建模

X = df[['cylinders', 'displacement', 'horsepower', 'weight', 'acceleration', 'model year', 'origin']]

y = df['mpg']

# 将数据集划分为训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建包含标准化和线性回归的管道

pipeline = Pipeline([('scaler', StandardScaler()),('linreg', LinearRegression())])

# 训练模型

pipeline.fit(X_train, y_train)

# 保存训练好的模型

with open('2.2.2_model.pkl', 'wb') as model_file:

pickle.dump(pipeline, model_file)

# 预测并保存结果

y_pred = pipeline.predict(X_test)

results_df = pd.DataFrame(y_pred, columns=['预测结果'])

results_df.to_csv('2.2.2_results.txt', index=False)

# 测试模型

with open('2.2.2_report.txt', 'w') as results_file:

results_file.write(f'训练集得分: {pipeline.score(X_train, y_train)}\n')

    results_file.write(f'测试集得分: {pipeline.score(X_test, y_test)}\n')

# 训练一个随机森林回归模型,创建的决策树的数量为100

rf_model = RandomForestRegressor(n_estimators=100, random_state=42)

rf_model.fit(X_train, y_train)

# 使用随机森林模型进行预测

y_pred_rf = rf_model.predict(X_test)

# 保存新的结果

results_rf_df = pd.DataFrame(y_pred_rf, columns=['预测结果'])

results_rf_df.to_csv('2.2.2_results_rf.txt', index=False)

# 测试模型并保存得分

with open('2.2.2_report_rf.txt', 'w') as results_rf_file:

results_rf_file.write(f'训练集得分: {rf_model.score(X_train, y_train)}\n')

results_rf_file.write(f'测试集得分: {rf_model.score(X_test, y_test)}\n')

(1) 代码：

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

import pickle

from sklearn.metrics import classification_report

from imblearn.over_sampling import SMOTE

# 加载数据

data = pd.read_csv('finance数据集.csv')

    # 显示前五行的数据

print(data.head())

    # 选择自变量和因变量

X = data.drop(['SeriousDlqin2yrs', 'Unnamed: 0'], axis=1)

y = data['SeriousDlqin2yrs']

    # 分割训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    # 训练Logistic回归模型

model = LogisticRegression(max_iter=1000)

model.fit(X_train, y_train)

    # 保存模型

with open('2.2.1_model.pkl', 'wb') as file:

     pickle.dump(model, file)

    # 预测并保存结果

y_pred = model.predict(X_test)

pd.DataFrame(y_pred, columns=['预测结果']).to_csv('2.2.1_results.txt', index=False)

    # 生成测试报告

report = classification_report(y_test, y_pred, zero_division=1)

with open('2.2.1_report.txt', 'w') as file:

     file.write(report)

    # 分析测试结果

accuracy = (y_test == y_pred).mean()

print(f"模型准确率: {accuracy:.2f}")

    # 处理数据不平衡

 smote = SMOTE(random_state=42)

 X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

    # 重新训练模型

 model.fit(X_resampled, y_resampled)

    # 重新预测

 y_pred_resampled = model.predict(X_test)

    # 保存新结果

pd.DataFrame(y_pred_resampled, columns=['预测结果']).to_csv('2.2.1_results_xg.txt', index=False)

    # 生成新的测试报告

report_resampled = classification_report(y_test, y_pred_resampled, zero_division=1)

with open('2.2.1_report_xg.txt', 'w') as file:

     file.write(report_resampled)

    # 分析新的测试结果

accuracy_resampled = (y_test == y_pred_resampled).mean()

print(f"重新采样后的模型准确率: {accuracy_resampled:.2f}")

代码：

import pandas as pd
    # 加载数据集
data = pd.read_csv('健康咨询客户数据集.csv')
    # 查看表的数据类型和表结构
print(data.info())
    # 显示每一列的空缺值数量
print(data.isnull().sum())
    # 删除含有缺失值的行
data_cleaned = data.dropna()
    # 转换 'Your age' 列的数据类型为整数类型，并处理异常值
data_cleaned.loc[:, 'Your age'] = pd.to_numeric(data_cleaned['Your age'], errors='coerce')
data_cleaned = data_cleaned.dropna(subset=['Your age'])
data_cleaned = data_cleaned[data_cleaned['Your age'] >= 0]
data_cleaned.loc[:, 'Your age'] = data_cleaned['Your age'].astype(int)
print(data_cleaned['Your age'].dtype)
    # 检查和删除重复值
duplicates_removed = data_cleaned.duplicated().sum()
data_cleaned = data_cleaned.drop_duplicates()
print(f"Removed {duplicates_removed} duplicate rows")
from sklearn.preprocessing import LabelEncoder
    # 归一化 'How do you describe your current level of fitness ?' 列
label_encoder = LabelEncoder()
data_cleaned['How do you describe your current level of fitness ?'] = label_encoder.fit_transform(data_cleaned['How do you describe your current level of fitness ?'])
print(data_cleaned['How do you describe your current level of fitness ?'].unique())
from sklearn.preprocessing import LabelEncoder
import matplotlib.pyplot as plt
    # 去掉列名中的空格
data.columns = data.columns.str.strip()
    # 显示数据集的列名
print(data.columns)
    # 删除包含缺失值的行
data_cleaned = data.dropna(subset=['How often do you exercise?'])
    # 统计不同健身频率的分布情况
exercise_frequency_counts = data_cleaned['How often do you exercise?'].value_counts()
    # 绘制饼图
plt.figure(figsize=(10, 6))
exercise_frequency_counts.plot.pie(autopct='%1.1f%%', startangle=90, colors=plt.cm.Paired.colors)
plt.title('Distribution of Exercise Frequency')
plt.ylabel('')
plt.show()
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
    # 填充缺失值
data_filled = data.apply(lambda x: x.fillna(x.mode()[0]))
    # 划分数据
train_data, test_data = train_test_split(data_filled, test_size=0.2, random_state=42)
    # 保存数据
cleaned_file_path = '2.1.5_cleaned_data.csv'
data_filled.to_csv(cleaned_file_path, index=False)

代码：

import pandas as pd

#加载数据集并指定编码为gbk

data = pd.read_csv('medical_data.csv', encoding='gbk')

# 查看数据类型

print(data.dtypes)

# 查看表结构

print(data.info())

# 显示每一列的空缺值数量

print(data.isnull().sum())

# 规范日期格式

data['就诊日期'] = pd.to_datetime(data['就诊日期'])

data['诊断日期'] = pd.to_datetime(data['诊断日期'])

# 重命名列

data.rename(columns={'病人ID': '患者ID'}, inplace=True)

# 查看修改后的表结构
print(data.head())
from datetime import datetime
# 增加诊断延迟和病程
data['诊断延迟'] = (data['诊断日期'] - data['就诊日期']).dt.days
data['病程'] = (datetime(2024, 9, 1) - data['诊断日期']).dt.days
# 删除不合理的数据
data = data[(data['诊断延迟'] >= 0) & (data['年龄'] > 0) & (data['年龄'] < 120)]
# 查看修改后的数据
print(data.describe())
# 删除重复值并记录删除的行数
initial_rows = data.shape[0]
data.drop_duplicates(inplace=True)
deleted_rows = initial_rows - data.shape[0]
print(f'删除的重复行数: {deleted_rows}')
from sklearn.preprocessing import MinMaxScaler
# 对需要归一化的列进行处理
scaler = MinMaxScaler()
columns_to_normalize = ['年龄', '体重', '身高']
data[columns_to_normalize] = scaler.fit_transform(data[columns_to_normalize])
# 查看归一化后的数据
print(data.head())
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
# 统计治疗结果分布
treatment_outcome_distribution = data.groupby('疾病类型')['治疗结果'].value_counts().unstack()
# 设置中文字体
#font_path = 'C:/Windows/Fonts/simhei.ttf'  # 根据你的系统调整字体路径
font_path = '/System/Library/Fonts/Hiragino Sans GB.ttc'  # 根据你的系统调整字体路径
my_font = fm.FontProperties(fname=font_path)
# 绘制柱状图
treatment_outcome_distribution.plot(kind='bar', stacked=True)
plt.title('不同疾病类型的治疗结果分布', fontproperties=my_font)
plt.xlabel('疾病类型', fontproperties=my_font)
plt.ylabel('治疗结果数量', fontproperties=my_font)
plt.xticks(fontproperties=my_font)  # 设置x轴刻度标签的字体
plt.yticks(fontproperties=my_font)  # 设置y轴刻度标签的字体
plt.legend(prop=my_font)  # 设置图例字体
plt.show()
# 绘制散点图
plt.scatter(data['年龄'], data['疾病严重程度'])
plt.title('年龄和疾病严重程度的关系', fontproperties=my_font)
plt.xlabel('年龄', fontproperties=my_font)
plt.ylabel('疾病严重程度', fontproperties=my_font)
plt.xticks(fontproperties=my_font)  # 设置x轴刻度标签的字体
plt.yticks(fontproperties=my_font)  # 设置y轴刻度标签的字体
plt.legend(prop=my_font)  # 设置图例字体
plt.show()
# 保存数据
output_path = '2.1.4_cleaned_data.csv'
data.to_csv(output_path, index=False)

代码：

import pandas as pd

# Load the data

data = pd.read_csv('finance数据集.csv’)

# 显示前五行的数据

print(data.head())

import matplotlib.pyplot as plt

import seaborn as sns

# 设置图像尺寸

plt.figure(figsize=(12, 8))

# 识别数值列用于箱线图

numeric_cols = data.select_dtypes(include=['float64', 'int64']).columns

# 创建箱线图

for i, col in enumerate(numeric_cols, 1):

plt.subplot(3, 4, i)

sns.boxplot(x=data[col])

plt.title(col)

plt.tight_layout()

plt.show()

# 使用IQR处理异常值

Q1 = data[numeric_cols].quantile(0.25)

Q3 = data[numeric_cols].quantile(0.75)

IQR = Q3 - Q1

# 移除异常值

data_cleaned = data[

~((data[numeric_cols] < (Q1 - 1.5 * IQR)) | (data[numeric_cols] > (Q3 + 1.5 * IQR))).any(axis=1)]

# 检查重复值

duplicates = data_cleaned.duplicated()

num_duplicates = duplicates.sum()

data_cleaned = data_cleaned[~duplicates]

print(f'删除的重复行数: {num_duplicates}')

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

data_cleaned[numeric_cols] = scaler.fit_transform(data_cleaned[numeric_cols])

# 将SeriousDlqin2yrs设为目标变量

target_variable = 'SeriousDlqin2yrs'

from sklearn.model_selection import train_test_split

# 定义特征和目标

X = data_cleaned.drop(columns=['SeriousDlqin2yrs','Unnamed: 0'])

y = data_cleaned[target_variable]

# 划分数据

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 显示划分后的数据形状

print(f'训练数据形状: {X_train.shape}')

print(f'测试数据形状: {X_test.shape}')

# 保存清洗后的数据到CSV

cleaned_file_path = '2.1.3_cleaned_data.csv'

data_cleaned.to_csv(cleaned_file_path, index=False)

代码：

import pandas as pd

# 读取一个Excel文件，并将读取到的数据存储在变量data中

data = pd.read_excel('大学生低碳生活行为的影响因素数据集.xlsx')

# 打印出数据集的前5行

print(data.head())

# 处理数据集中的缺失值

initial_row_count = data.shape[0]

data = data.dropna()

final_row_count = data.shape[0]

print(f'处理后数据行数: {final_row_count}, 删除的行数: {initial_row_count - final_row_count}')

# 删除重复行

data = data.drop_duplicates()

from sklearn.preprocessing import StandardScaler

numerical_features = ['4.您的月生活费○≦1,000元   ○1,001-2,000元   ○2,001-3,000元   ○≧3,001元']

scaler = StandardScaler()

data[numerical_features] = scaler.fit_transform(data[numerical_features])

selected_features = ['1.您的性别○男性   ○女性', '2.您的年级○大一   ○大二   ○大三   ○大四', '3.您的生源地○农村   ○城镇（乡镇）   ○地县级城市  ○省会城市及直辖市','4.您的月生活费○≦1,000元   ○1,001-2,000元   ○2,001-3,000元   ○≧3,001元','5.您进行过绿色低碳的相关生活方式吗?', '6.您觉得“低碳”，与你的生活关系密切吗？','7.低碳生活是否会成为未来的主流生活方式？', '8.您是否认为低碳生活会提高您的生活质量？']

X = data[selected_features]

# 创建目标变量

y = data['低碳行为积极性']

from sklearn.model_selection import train_test_split

# 数据划分

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 保存处理后的数据

cleaned_data = pd.concat([X, y], axis=1)

cleaned_data.to_csv('2.1.2_cleaned_data.csv', index=False, encoding='gbk')

在现代交通中，燃油效率（MPG）是衡量汽车性能和交通系统优化的重要指标之一。高效的燃油利用不仅能够降低车辆运营成本，还能减少碳排放，促进环保。开发一个用于预测汽车燃油效率的模型可以帮助智慧交通系统优化路线规划和车辆调度，从而提升整体交通效率和减少能源消耗。此外，这样的模型还可以帮助消费者做出更明智的购车决策，并帮助厂商优化汽车设计。现要求根据提供的汽车燃油效率数据集，补全 2.1.1.ipynb 代码。选择合适的特征，开发一个燃油效率预测模型。在开发预测模型之前，首先要对数据进行数据清洗和标注，请完成下面的数据预处理任务，并设计一套标注流程规范：
(1)正确加载数据集，并显示前五行的数据及数据类型。
(2)检查数据集中的缺失值并删除缺失值所在的行。
(3)将“horsepower”列转换为数值类型，并处理转换中的异常值。
(4)对数值型数据进行标准化处理，确保数据在同一量纲下进行分析。
(5)根据业务 需求和数据特性， 选择对燃油效率预 测最有用的特征 ：选择以下特征：'cylinders'、'displacement'、'horsepower'、'weight'、'acceleration'、'model year'、
'origin'
(6)将“mpg”设为目标变量并标注；
(7)对数据进行标注和划分；
(8)保存处理后的数据，并命名为：2.1.1_cleaned_data.csv，保存到考生文件夹；
(9) 制 定 数 据 清 洗 和 标 注 规 范 ， 将 答 案 写 到 答 题 卷 文 件 中 ， 答 题 卷 文 件 命 名 为“2.1.1.docx”，保存到考生文件夹；
(10)将以上代码以及运行结果，以 html 格式保存并命名为 2.1.1.html，保存到考生文件夹，考生文件夹命名为“准考证号+身份证后 6 位”。

代码：

# 加载数据集并显示数据集的前五行 1分

    data = pd.read_csv('auto-mpg.csv')  

    print("数据集的前五行:")

    print(data.head())

    # 显示每一列的数据类型

    print(data.dtypes)

    # 检查缺失值并删除缺失值所在的行  2分

    print("\n检查缺失值:")

    print(data.isnull().sum())

    data = data.dropna()

    # 将 'horsepower' 列转换为数值类型，并处理转换中的异常值 1分

    data['horsepower'] = pd.to_numeric(data['horsepower'], errors='coerce')

    data = data.dropna(subset=['horsepower'])

    # 显示每一列的数据类型

    print(data.horsepower.dtypes)

    # 检查清洗后的缺失值

    print("\n检查清洗后的缺失值:")

    print(data.isnull().sum())

    from sklearn.preprocessing import StandardScaler

    # 对数值型数据进行标准化处理 1分

    numerical_features = ['displacement', 'horsepower', 'weight', 'acceleration']

    scaler = StandardScaler()

    data[numerical_features] = scaler.fit_transform(data[numerical_features])

    from sklearn.model_selection import train_test_split

    # 选择特征和目标变量 2分

    selected_features = ['cylinders', 'displacement', 'horsepower', 'weight', 'acceleration', 'model year', 'origin']

    X = data[selected_features]

    y = data['mpg']

    # 划分数据集为训练集和测试集 1分

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    # 将特征和目标变量合并到一个数据框中

    cleaned_data = X.copy()

    cleaned_data['mpg'] = y

    # 保存清洗和处理后的数据

    cleaned_data.to_csv('2.1.1_cleaned_data.csv', index=False)

    # 打印消息指示文件已保存

    print("\n清洗后的数据已保存到 2.1.1_cleaned_data.csv")

某智能交通系统希望通过车辆的行驶数据，利用人工智能技术进行交通流量预测和拥堵预警。你作为人工智能训练师，需要设计一套全面的业务数据采集、处理和审核流程，确保数据在进入交通流量分析系统之前经过严格的采集、清洗、审核和预处理。这里提供一个车辆行驶数据集（vehicle_traffic_data.csv），包含以下字段：
 VehicleID: 车辆 ID
 DriverName: 驾驶员姓名
 Age: 年龄
 Gender: 性别（Male/Female）
 Speed: 车速（km/h）
 TravelDistance: 行驶距离（km）
 TravelTime: 行驶时间（min）
 TrafficEvent: 交通事件（Normal, Accident, Traffic Jam,
Breakdown）
你作为人工智能训练师，根据提供的 vehicle_traffic_data.csv 数据集和 Python 代码框架
（1.1.5.ipynb），完成以下数据的采集、处理和审核任务，确保数据的准确性和可靠性。请按
照以下要求完成任务，确保结果准确并保存相应的截图。
人工智能训练师（三级）操作技能复习题
15 / 116
（1）数据采集：
通过运行 Python 代码（1.1.5.ipynb），从本地文件 vehicle_traffic_data.csv 中读取数据，
并将数据加载到 DataFrame 中。显示前 5 行数据截图以 JPG 的格式保存，命名为“1.1.5-1”。
（2）数据清洗与预处理：
通过运行 Python 代码（1.1.5.ipynb）对数据进行清洗和预处理，具体要求如下：
 处理缺失值：对缺失值进行删除。
 数据类型转换：确保每个字段的数据类型正确。
 处理异常值：删除不合理的年龄、车速、行驶距离和行驶时间。
清洗后的数据保存为新文件 cleaned_vehicle_traffic_data.csv。
（3）数据合理性审核： 通过运行 Python 代码审核以下字段的合理性：
 年龄：应在 18 到 70 岁之间。
 车速：应在 0 到 200 km/h 之间。
 行驶距离：应在 1 到 1000 km 之间。
 行驶时间：应在 1 到 1440 分钟（24 小时）之间。
对不合理的数据进行标记，并将审核结果截图以 JPG 的格式保存，命名为“1.1.5-2”。
（4）数据统计：
通过运行 Python 代码（1.1.5.ipynb），完成以下数据统计任务：
 统计每种交通事件的发生次数。
 统计不同性别的平均车速、行驶距离和行驶时间。
 统计不同年龄段的驾驶员数（18-25 岁、26-35 岁、36-45 岁、46-55 岁、
56-65 岁、65 岁以上）。
将统计结果分别截图以 JPG 的格式保存，分别命名为“1.1.5-3”、“1.1.5-4”、“1.1.5-5”。
所有结果文件储存在桌面新建的考生文件夹中，文件夹命名为“准考证号+身份证号后
六位”。

代码：

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

# 1. 数据采集

# 从本地文件中读取数据  2分

data = pd.read_csv('vehicle_traffic_data.csv')

print("数据采集完成，已加载到DataFrame中")

# 打印数据的前5条记录

print(data.head())

# 2. 数据清洗与预处理

# 处理缺失值  2分

data = data.dropna()

# 数据类型转换

data['Age'] = data['Age'].astype(int)  # Age数据类型转换 1分

data['Speed'] = data['Speed'].astype(float)  # Speed数据类型转换 1分

data['TravelDistance'] = data['TravelDistance'].astype(float)  # TravelDistance数据类型转换 1分

data['TravelTime'] = data['TravelTime'].astype(float)  # TravelTime数据类型转换 1分

# 处理异常值  2分

data = data[(data['Age'].between(18, 70)) &(data['Speed'].between(0, 200)) & (data['TravelDistance'].between(1, 1000)) & (data['TravelTime'].between(1, 1440))]

# 保存清洗后的数据  1分

data.to_csv('cleaned_vehicle_traffic_data.csv', index=False)

print("数据清洗完成，已保存为 'cleaned_vehicle_traffic_data.csv'")

# 3. 数据合理性审核

# 审核字段合理性 1分

unreasonable_data = data[~((data['Age'].between(18, 70)) &

                                    (data['Speed'].between(0, 200)) &

                                    (data['TravelDistance'].between(1, 1000)) &

                                    (data['TravelTime'].between(1, 1440)))]

print("不合理的数据:\n", unreasonable_data)

# 4. 数据统计

# 统计每种交通事件的发生次数  2分

traffic_event_counts = data['TrafficEvent'].value_counts()

print("每种交通事件的发生次数:\n", traffic_event_counts)

# 统计不同性别的平均车速、行驶距离和行驶时间  2分

gender_stats = data.groupby('Gender').agg(

{'Speed': 'mean', 'TravelDistance': 'mean', 'TravelTime': 'mean'})

print("不同性别的平均车速、行驶距离和行驶时间:\n", gender_stats)

# 统计不同年龄段的驾驶员数  2分

age_bins = [18, 26, 36, 46, 56, 66, np.inf]

age_labels = ['18-25', '26-35', '36-45', '46-55', '56-65', '65+']

data['AgeGroup'] = pd.cut(data['Age'], bins=age_bins, labels=age_labels, right=False)

age_group_counts = data['AgeGroup'].value_counts()

print("不同年龄段的驾驶员数:\n", age_group_counts)

某医疗机构计划引入智能医疗系统，以提升诊断效率和准确性。通过分析患者的历史
数据，使用机器学习算法预测患者的健康风险，从而辅助医生进行诊断和治疗。为此，该机
构需要设计一套全面的业务数据处理流程，确保数据处理的高效性和准确性，为人工智能模
型提供可靠的输入数据。
我们提供一个患者数据集（patient_data.csv），包含以下字段：
PatientID: 患者 ID
Age: 年龄
BMI: 体重指数
BloodPressure: 血压
Cholesterol: 胆固醇水平
DaysInHospital: 住院天数
你作为人工智能训练师，根据提供的数据集和 Python 代码框架（1.1.1.ipynb），完成以
下数据的统计和分析，为智能医疗系统提供可靠的数据支持。
人工智能训练师（三级）操作技能复习题
（1）通过补全并运行 Python 代码（1.1.1.ipynb）分别统计住院天数超过 7 天的患者数
量以及其占比。这类患者被定义为高风险患者，反之为低风险患者。将上述统计结果截图以
JPG 的格式保存，命名为“1.1.1-1”。
（2）通过补全并运行 Python 代码（1.1.1. ipynb）统计不同 BMI 区间中高风险患者的
比例和统计不同 BMI 区间中的患者数。BMI 区间分类设置为：偏瘦（低于 18.5），正常（18.5～
23.9），超重（24.0～27.9），肥胖（28.0 及以上），将上述统计结果截图以 JPG 的格式保存，
命名为“1.1.1-2”。
（3）通过补全并运行 Python 代码（1.1.1. ipynb）统计不同年龄区间中高风险患者的比
例和统计不同年龄区间中的患者数。年龄区间分类设置为：年龄区间分类设置为：≤25 岁，
26-35 岁，36-45 岁，46-55 岁，56-65 岁，＞65 岁，将上述统计结果截图以 JPG 的格式保存，
命名为“1.1.1-3”。
所有结果文件储存在桌面新建的考生文件夹中，文件夹命名为“准考证号+身份证号后
六位”

代码：

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

# 读取数据集

data = pd.read_csv('patient_data.csv')

# 1. 统计住院天数超过7天的患者数量及其占比

# 创建新列'RiskLevel'，根据住院天数判断风险等级

data['RiskLevel'] = np.where(data['DaysInHospital']>7, '高风险患者', '低风险患者')

# 统计不同风险等级的患者数量

risk_counts = data['RiskLevel'].value_counts()

# 计算高风险患者占比

high_risk_ratio = risk_counts['高风险患者'] / len(data)

# 计算低风险患者占比

low_risk_ratio = risk_counts['低风险患者'] / len(data)

# 输出结果

print("高风险患者数量:", risk_counts['高风险患者'])

print("低风险患者数量:", risk_counts['低风险患者'])

print("高风险患者占比:", high_risk_ratio)

print("低风险患者占比:", low_risk_ratio)

# 2. 统计不同BMI区间中高风险患者的比例和患者数

# 定义BMI区间和标签

bmi_bins = [0, 18.5, 24.9, 29.9, np.inf]

bmi_labels = ['偏瘦', '正常', '超重', '肥胖']

# 根据BMI值分配BMI区间标签

data['BMIRange'] = pd.cut(data['BMI'], bins=bmi_bins, labels=bmi_labels,right=False)

# 计算每个BMI区间中高风险患者的比例

bmi_risk_rate = data.groupby('BMIRange')['RiskLevel'].apply(lambda x: (x == '高风险患者').mean())

# 统计每个BMI区间的患者数量

bmi_patient_count = data['BMIRange'].value_counts()

# 输出结果

print("BMI区间中高风险患者的比例和患者数:")

print(bmi_risk_rate)    #高风险患者的比例

print(bmi_patient_count)    #高风险患者的患者数

# 3. 统计不同年龄区间中高风险患者的比例和患者数

# 定义年龄区间和标签

age_bins = [0, 25, 35, 45, 55, 65, np.inf]

age_labels = ['≤25岁', '26岁-35岁', '36岁-45岁', '46岁-55岁', '56岁-65岁', '＞65岁']

# 根据年龄值分配年龄区间标签

data['AgeRange'] = pd.cut(data['Age'], bins=age_bins, labels=age_labels,right=False)

# 计算每个年龄区间中高风险患者的比例

age_risk_rate = data.groupby('AgeRange')['RiskLevel'].apply(lambda x: (x == '高风险患者').mean())

# 统计每个年龄区间的患者数量

age_patient_count = data['AgeRange'].value_counts()

# 输出结果

print("年龄区间中高风险患者的比例和患者数:")

print(age_risk_rate)   #高风险患者的比例

print(age_patient_count)   #高风险患者的患者数