1.运用scikit-learn加载出葡萄酒数据，并对原始13维数据降成2维数据，并运用plt.scatter 函数可视化每一类数据。
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine
from sklearn.decomposition import PCA
# 加载葡萄酒数据
wine = load_wine()
X = wine.data
y = wine.target
# 使用PCA降维
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)
# 可视化每一类数据
colors = ['r', 'g', 'b']
markers = ['o', 's', 'D']
for i, (color, marker) in enumerate(zip(colors, markers)):
plt.scatter(X_reduced[y == i, 0], X_reduced[y == i, 1], c=color, marker=marker, label=f'Class {i + 1}')
plt.xlabel('First Principal Component')
plt.ylabel('Second Principal Component')
plt.legend()
plt.show()2.请使用scikcit-leam加载出波士顿房价数据，将数据拆分成训练集、测试集，构建多元线性回归模型，拟合房价训练数据，并用训练好的模型对测试数据作出房价预测，计算预测结果与真实房价数据的均方差损失。
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# 加载波士顿房价数据集
boston = datasets.load_boston()
X = boston.data
y = boston.target
# 将数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 构建多元线性回归模型
model = LinearRegression()
# 使用训练数据拟合模型
model.fit(X_train, y_train)
# 使用训练好的模型对测试数据进行预测
y_pred = model.predict(X_test)
# 计算预测结果与真实房价数据的均方差损失
mse = mean_squared_error(y_test, y_pred)
print("均方差损失：", mse)3.请使用scikit-leam库加载出鸢尾花数据，将数据拆分成训练测试集，使用scikit-leam tree模块的DecisionTreeClassifier类构建决策树模型，对鸢尾花训练数据进行拟合，对测试集数据分类，并输出分类准确率。（分割方法使用基尼系数)
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
# 加载鸢尾花数据
iris = load_iris()
X = iris.data
y = iris.target
# 将数据拆分成训练测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 使用DecisionTreeClassifier类构建决策树模型
clf = DecisionTreeClassifier(criterion='gini')
# 对鸢尾花训练数据进行拟合
clf.fit(X_train, y_train)
# 对测试集数据分类
y_pred = clf.predict(X_test)
# 输出分类准确率
accuracy = accuracy_score(y_test, y_pred)
print("分类准确率：", accuracy)4. 1）请描述KNN算法的算法思想；
2）针对第3题，请用KNN算法实现。
1)K近邻算法（K-Nearest Neighbors, KNN）是一种基本旦直观的分类和回归算法。它的核心思想是：对于给定的一个新的样本点，找到在特征空间中与它最接近的K个样本点（即K个最近邻），根据这K个样本点的类别来确定新样本点的类别。在分类任务中，通常采用投票法，即选择K个邻居中出现次数最多的类别作为预测结果。
KNN算法的步骤如下：
1.选择K值：K是用户指定的参数，表示选择多少个邻居。
2.计算距离：计算待分类样本与训练集中所有样本的距离。常用的距离度量有欧氏距离、曼哈顿距离等。
3.寻找最近邻：根据距离排序，选取前K个最近的样本。
4.分类决策：对这K个最近邻样本的类别进行投票，选择出现次数最多的类别作为预测类别.
KNN是一种懒情学习算法，因为它在训练阶段没有显式的模型训练过程，只是简单地存储训练数据，在预测阶段才进行计算。
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
# 加载鸢尾花数据
iris = load_iris()
X = iris.data
y = iris.target
# 将数据拆分成训练测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 使用KNN算法构建模型
knn = KNeighborsClassifier(n_neighbors=3)
# 对鸢尾花训练数据进行拟合
knn.fit(X_train, y_train)
# 对测试集数据分类
y_pred = knn.predict(X_test)
# 输出分类准确率
accuracy = accuracy_score(y_test, y_pred)
print("分类准确率：", accuracy)5.假设下面有三家公司的年度利润数据集，请绘制这三家公司在一年中的利润变化趋势
折线图。使用Matplotlib、绘制折线图，要求：
a)x轴表示月份（从1到12)；
b)y轴表示利润（单位：千美元）；
c）不同公司的折线图使用不同颜色表示（如公司A用蓝色，公司B用绿色，公司C用橙色）；
d）图中添加标题和坐标轴标签；
e）添加图例。
数据集如下：
x=[1,2,3,4.5,6,7,8,9,10,11,12]
公司 A的利润 y1=[10,12,14,13,15,16,14,13,15,17,19,18]
公司 B的利润 y2=[8,7,9,11,12,10,11,12,13,14,16,15]
公司 C的利润 y3=[5,6,7,8,7,6,7,8,9,10,11,12]
import matplotlib.pyplot as plt
# 数据集
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
y1 = [10, 12, 14, 13, 15, 16, 14, 13, 15, 17, 19, 18]
y2 = [8, 7, 9, 11, 12, 10, 11, 12, 13, 14, 16, 15]
y3 = [5, 6, 7, 8, 7.6, 7, 8, 9, 10, 11, 12]
# 创建折线图
plt.plot(x, y1, color='blue', label='公司A')
plt.plot(x, y2, color='green', label='公司B')
plt.plot(x, y3, color='orange', label='公司C')
# 添加标题和坐标轴标签
plt.title('三家公司一年中的利润变化趋势')
plt.xlabel('月份')
plt.ylabel('利润（千美元）')
# 添加图例
plt.legend()
# 显示图表
plt.show()6.请用mumpx随机生成一个3*3的数组，运用scikit-leamn 按列对数据进行归一化，并
输出归一化后每列数据的均值和标准差。
import numpy as np
from sklearn.preprocessing import StandardScaler
# 生成一个3x3的随机数组
np.random.seed(42)
data = np.random.rand(3,3)
print("原始数据：",data)
# 使用StandardScaler按列进行归一化
scaler = StandardScaler()
normalized_data = scaler.fit_transform(data)
print("归一化后的数据：",normalized_data)
# 计算归一化后每列数据的均值和标准差
mean = np.mean(normalized_data, axis=0)
std = np.std(normalized_data, axis=0)
print("归一化后每列数据的均值：", mean)
print("归一化后每列数据的标准差：", std)7.请使用scikit-leam 库加载出鸢尾花数据，将数据拆分成训练测试集，构建逻辑回归模型，用模型拟合训练数据后对测试数据作出预测，并输出预测结果的精度和召回率。
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import precision_score, recall_score
# 加载鸢尾花数据集
iris = load_iris()
X = iris.data
y = iris.target
# 将数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 构建逻辑回归模型
model = LogisticRegression(max_iter=200)
# 使用训练数据拟合模型
model.fit(X_train, y_train)
# 对测试数据进行预测
y_pred = model.predict(X_test)
# 计算预测结果的精度和召回率
precision = precision_score(y_test, y_pred, average='macro')
recall = recall_score(y_test, y_pred, average='macro')
print("预测结果的精度：", precision)
print("预测结果的召回率：", recall)8.请使用scikit-leam加载出葡萄酒数据，将数据拆分成训练集、测试集；枸建SVM分类模型，在训练集上训练 SVM模型，在测试数据上预测，并输出测试集上的预测准确率。
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
# 加载葡萄酒数据集
wine = load_wine()
X = wine.data
y = wine.target
# 将数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,random_state=42)
# 构建SVM分类模型
model = SVC()
# 使用训练数据拟合模型
model.fit(X_train, y_train)
# 对测试数据进行预测
y_pred = model.predict(X_test)
# 计算测试集上的预测准确率
accuracy = accuracy_score(y_test, y_pred)
print("测试集上的预测准确率：", accuracy)9.引入乳腺癌数据集，将数据按照8:2 的比例拆分成训练集和测试集，使用 sklearn naive_bazes模块的GausslanMB类构建高斯朴素贝叶斯分类模型，对乳腺癌训练数据进行拟合，最后对测试集数据分类，并输出分类准确率。
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score
# 加载乳腺癌数据集
data = load_breast_cancer()
X = data.data
y = data.target
# 将数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 构建高斯朴素贝叶斯分类模型
model = GaussianNB()
# 使用训练数据拟合模型
model.fit(X_train, y_train)
# 对测试集数据进行分类
y_pred = model.predict(X_test)
# 计算分类准确率
accuracy = accuracy_score(y_test, y_pred)
print("分类准确率：", accuracy)
- 在-5到5范围内生成1000个统一均匀分布的随机数，并基于y=x2+2x+1生成关于y的多项式分布，调用matplotlib绘制散点图。
import numpy as np import matplotlib.pyplot as plt # 生成1000个在-5到5范围内的统一均匀分布的随机数 x = np.random.uniform(-5, 5, 1000) # 基于y=x^2+2x+1生成关于y的多项式分布 y = x**2 + 2*x + 1 # 绘制散点图 plt.scatter(x, y) plt.xlabel('x') plt.ylabel('y') plt.title('Scatter plot of y = x^2 + 2x + 1') plt.show() - 调用sklearn包，使用决策树算法对鸢尾花数据集构建分类模型，可视化决策树构建过程，并输出模型评估的结果（使用“entropy”为划分标准，性能度量要求使用准确率、精度、召回率、auc值）
import numpy as np import matplotlib.pyplot as plt from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier, plot_tree from sklearn.metrics import accuracy_score, precision_score, recall_score, roc_auc_score from sklearn.preprocessing import label_binarize from sklearn.metrics import roc_curve, auc # 加载鸢尾花数据集 iris = datasets.load_iris() X = iris.data y = iris.target # 将数据集分割为训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) # 使用决策树算法构建分类模型，设置划分标准为“entropy” clf = DecisionTreeClassifier(criterion='entropy', random_state=42) clf.fit(X_train, y_train) # 预测测试集 y_pred = clf.predict(X_test) # 评估模型性能 accuracy = accuracy_score(y_test, y_pred) precision = precision_score(y_test, y_pred, average='weighted') recall = recall_score(y_test, y_pred, average='weighted') # 计算AUC值 y_test_binarized = label_binarize(y_test, classes=[0, 1, 2]) y_score = clf.predict_proba(X_test) fpr = dict() tpr = dict() roc_auc = dict() for i in range(3): fpr[i], tpr[i], _ = roc_curve(y_test_binarized[:, i], y_score[:, i]) roc_auc[i] = auc(fpr[i], tpr[i]) # 计算宏平均和微平均AUC fpr["micro"], tpr["micro"], _ = roc_curve(y_test_binarized.ravel(), y_score.ravel()) roc_auc["micro"] = auc(fpr["micro"], tpr["micro"]) fpr["macro"] = np.unique(np.concatenate([fpr[i] for i in range(3)])) tpr["macro"] = np.zeros_like(fpr["macro"]) for i in range(3): tpr["macro"] += np.interp(fpr["macro"], fpr[i], tpr[i]) tpr["macro"] /= 3 roc_auc["macro"] = auc(fpr["macro"], tpr["macro"]) # 打印模型评估结果 print(f"Accuracy: {accuracy}") print(f"Precision: {precision}") print(f"Recall: {recall}") print(f"AUC (macro): {roc_auc['macro']}") print(f"AUC (micro): {roc_auc['micro']}") # 可视化决策树 plt.figure(figsize=(20,10)) plot_tree(clf, filled=True, feature_names=iris.feature_names, class_names=iris.target_names) plt.title("决策树模型") plt.show() # 绘制ROC曲线 plt.figure() plt.plot(fpr["micro"], tpr["micro"], label='micro-average ROC curve (area = {0:0.2f})'.format(roc_auc["micro"])) plt.plot(fpr["macro"], tpr["macro"], label='macro-average ROC curve (area = {0:0.2f})'.format(roc_auc["macro"])) for i in range(3): plt.plot(fpr[i], tpr[i], lw=2, label='ROC curve of class {0} (area = {1:0.2f})'.format(i, roc_auc[i])) plt.plot([0, 1], [0, 1], 'k--') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('ROC曲线') plt.legend(loc="lower right") plt.show() - 请描述SVM算法的基本思想；
支持向量机是一种用于分类和回归任务的监督学习算法。SVM的基本思想是找到一个超平面（hyperplane），以最大化不同类别数据点之间的间隔（margin）。以下是SVM算法的几个关键点：
超平面：在特征空间中将不同类别的数据点分开的决策边界。对于二维空间，超平面是一个线；对于三维空间，超平面是一个平面；更高维空间中，超平面是一个高维超平面。
间隔（Margin）：超平面与离它最近的两个不同类别的数据点之间的距离。SVM算法通过最大化这个间隔来寻找最优的超平面。
支持向量（Support Vectors）：在找到的最优超平面上，紧邻超平面的那些数据点称为支持向量。这些支持向量决定了超平面的位置和方向。
软间隔（Soft Margin）：在实际应用中，数据可能无法被一个完美的超平面完全分开。SVM通过引入一个惩罚参数（C），允许某些数据点位于错误的一侧，以找到一个权衡点。
核函数（Kernel Function）：当数据不是线性可分时，SVM使用核函数将数据映射到更高维空间，在该空间中数据可能是线性可分的。常见的核函数包括线性核、多项式核和径向基函数（RBF）核。
-
调用sklearn包，使用支持向量机算法对鸢尾花数据集构建分类模型，并输出模型预测和模型评估的结果（评估模型时的度量标准不少于两种）
from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.svm import SVC from sklearn.metrics import accuracy_score, classification_report # 加载鸢尾花数据集 iris = datasets.load_iris() X = iris.data y = iris.target # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) # 创建支持向量机分类器 clf = SVC(kernel='linear', C=1) # 在训练集上训练模型 clf.fit(X_train, y_train) # 在测试集上进行预测 y_pred = clf.predict(X_test) # 输出模型预测结果 print("模型预测结果：", y_pred) # 输出模型评估结果（准确率和分类报告） accuracy = accuracy_score(y_test, y_pred) report = classification_report(y_test, y_pred) print("准确率：", accuracy) print("分类报告：\n", report) -
利用朴素贝叶斯分类算法对鸢尾花数据集构建分类模型，自定义合理的训练集和测试集比例。根据混淆矩阵，输出模型在三分类上的准确率、召回率、查准率和F1Score。
from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.naive_bayes import GaussianNB from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score # 加载鸢尾花数据集 iris = datasets.load_iris() X = iris.data y = iris.target # 划分训练集和测试集（自定义比例） X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) # 创建朴素贝叶斯分类器 clf = GaussianNB() # 在训练集上训练模型 clf.fit(X_train, y_train) # 在测试集上进行预测 y_pred = clf.predict(X_test) # 计算混淆矩阵 conf_mat = confusion_matrix(y_test, y_pred) # 输出模型在三分类上的准确率、召回率、查准率和F1Score accuracy = accuracy_score(y_test, y_pred) precision = precision_score(y_test, y_pred, average='weighted') recall = recall_score(y_test, y_pred, average='weighted') f1 = f1_score(y_test, y_pred, average='weighted') print("混淆矩阵：\n", conf_mat) print("准确率：", accuracy) print("召回率：", recall) print("查准率：", precision) print("F1Score：", f1)6.使用sklearn库对鸢尾花数据集构建KNN分类模型
import numpy as np from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix # 加载鸢尾花数据集 iris = datasets.load_iris() X = iris.data y = iris.target # 将数据集分割为训练集和测试集 # 这里我们使用80%的数据用于训练，20%的数据用于测试 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 使用KNN算法构建分类模型 knn = KNeighborsClassifier(n_neighbors=3) knn.fit(X_train, y_train) # 预测测试集 y_pred = knn.predict(X_test) # 评估模型性能 accuracy = accuracy_score(y_test, y_pred) precision = precision_score(y_test, y_pred, average='weighted') recall = recall_score(y_test, y_pred, average='weighted') f1 = f1_score(y_test, y_pred, average='weighted') conf_matrix = confusion_matrix(y_test, y_pred) # 打印模型评估结果 print(f"Accuracy: {accuracy}") print(f"Precision: {precision}") print(f"Recall: {recall}") print(f"F1 Score: {f1}") print("Confusion Matrix:") print(conf_matrix) -
请描述K-means算法的基本思想
K-means算法是一种常用的无监督学习算法，主要用于数据的聚类分析。K-means算法的基本思想是将数据集划分为K个簇（clusters），使得每个簇内的数据点与该簇的质心（centroid）的距离之和最小。以下是K-means算法的几个关键步骤：
1.选择K个初始质心：随机选择K个数据点作为初始质心。
2.分配数据点到最近的质心：根据每个数据点与质心之间的距离，将每个数据点分配到最近的质心所在的簇。
3.更新质心：重新计算每个簇的质心，质心为该簇内所有数据点的平均值。
4.重复步骤2和3：直到质心不再发生变化（收敛）或达到预设的迭代次数。
利用KMeans算法对鸢尾花数据集构建聚类模型，绘制K-Means结果（散点图）并输出模型评估的结果（模型评估可以使用FMI系数或者轮廓系数）
import numpy as np import matplotlib.pyplot as plt from sklearn import datasets from sklearn.cluster import KMeans from sklearn.metrics import fowlkes_mallows_score # 加载鸢尾花数据集 iris = datasets.load_iris() X = iris.data y = iris.target # 创建KMeans聚类器 kmeans = KMeans(n_clusters=3, random_state=42) # 在数据上进行聚类 kmeans.fit(X) # 获取聚类结果 labels = kmeans.labels_ centers = kmeans.cluster_centers_ # 绘制K-Means结果的散点图 plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis') plt.scatter(centers[:, 0], centers[:, 1], marker='x', color='red') plt.title('K-Means Clustering') plt.xlabel('Feature 1') plt.ylabel('Feature 2') plt.show() # 计算FMI系数作为模型评估指标 fmi = fowlkes_mallows_score(y, labels) print("FMI系数：", fmi) - 运用scikit-learn 加载出乳腺癌数据，并将原始30维数据降成2维数据，并运用 plt.scatter 函数可视化每一类数据。
import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import load_breast_cancer from sklearn.decomposition import PCA # 加载乳腺癌数据 data = load_breast_cancer() X = data.data y = data.target # 使用PCA降维 pca = PCA(n_components=2) X_reduced = pca.fit_transform(X) # 可视化数据 plt.scatter(X_reduced[y == 0, 0], X_reduced[y == 0, 1], c='red', label='Malignant') plt.scatter(X_reduced[y == 1, 0], X_reduced[y == 1, 1], c='blue', label='Benign') plt.xlabel('Principal Component 1') plt.ylabel('Principal Component 2') plt.legend() plt.show() -
假设某类数据总体服从正态分布，现有部分数据{130,46,10,93,26,57,108,2,86,96,75,35,1,86,47,47,91,12,53,5,15,87,96,4,23,52,611,80,81,-70}，请采用基于统计的方法检测离群点（置信区间为平均值±2*方差）
import numpy as np data = [130, 46, 10, 93, 26, 57, 108, 2, 86, 96, 75, 35, 1, 86, 47, 47, 91, 12, 53, 5, 15, 87, 96, 4, 23, 52, 611, 80, 81, -70] # 计算平均值 mean = np.mean(data) # 计算标准差 std_dev = np.std(data) # 计算置信区间 lower_bound = mean - 2 * std_dev upper_bound = mean + 2 * std_dev # 检测离群点 outliers = [] for value in data: if value < lower_bound or value > upper_bound: outliers.append(value) print("离群点：", outliers) -
随机生成100个服从正态分布的数据，采用基于统计的方法检测离群点（置信区间为平均值±2*方差），输出这组数据的离群点。
import numpy as np # 生成100个服从正态分布的数据 data = np.random.normal(size=100) # 计算平均值 mean = np.mean(data) # 计算标准差 std_dev = np.std(data) # 计算置信区间 lower_bound = mean - 2 * std_dev upper_bound = mean + 2 * std_dev # 检测离群点 outliers = [] for value in data: if value < lower_bound or value > upper_bound: outliers.append(value) print("离群点：", outliers)
扫一扫
3670
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
