机器学习:多种算法处理填充后的数据

news/2024/9/17 7:15:05/ 标签: 机器学习, 算法, 人工智能, 学习

学习>机器学习中,填充数据(即处理缺失值)后,选择合适的算法并优化模型以提高召回率是一个常见的任务。召回率是指模型正确识别的正例占所有实际正例的比例。

代码思路:

  1. 数据预处理

    • 导入填充后的数据                                                                                                             
      import pandas as pd
      import numpy as np
      train_data=pd.read_excel('训练数据集[随机森林填充].xlsx')test_data=pd.read_excel('测试数据集[随机森林填充].xlsx')
  2. 特征与标签提取

    • 从数据集中提取特征和标签。                                                                                           
      train_data_x=train_data.drop('矿物类型',axis=1)
      train_data_y=train_data['矿物类型']test_data_x=test_data.drop('矿物类型',axis=1)
      test_data_y=test_data['矿物类型']#初始化存储所有算法的召回率字典
      result_data={}
  3. 网格搜索(寻找最优参数可能时间花费较长)

    • 用于超参数优化的方法,它系统地遍历多种超参数的组合,通过交叉验证来确定最佳的超参数设置。

    • 步骤

      • 定义参数网格

        • 确定需要优化的超参数及其可能的值。例如,学习率、正则化参数、树的深度等。
      • 设置交叉验证

        • 选择交叉验证的折数(如5折或10折),这将影响模型评估的稳健性。
      • 初始化模型

        • 选择一个基线模型,如逻辑回归、支持向量机、随机森林等。
      • 配置网格搜索

        • 使用网格搜索算法,输入模型、参数网格和交叉验证设置。
      • 训练和评估

        • 网格搜索算法将遍历所有参数组合,对每一组参数使用交叉验证来评估模型性能。
      • 选择最佳参数

        • 根据交叉验证的结果,选择表现最好的参数组合。
      • 最终模型训练

        • 使用最佳参数在完整的训练数据集上重新训练模型。                                     
          from sklearn.model_selection import GridSearchCV
          param_grid={'penalty':['l1','l2','elasticnet','none'],'C':[0.001,0.01,0.1,1,10,100],'solver':['newton_cg','lbfgs','linear','sag','sage'],'max_iter':[100,200,500],'multi_class':['auto','ovr','multionmial']
          }
          from sklearn.linear_model import LogisticRegression
          lohreg=LogisticRegression()
          grid_search=GridSearchCV(lohreg,param_grid,cv=5)
          grid_search.fit(train_data_x,train_data_y)
          print('最佳参数')
          print(grid_search.best_params_)
  4. 模型训练

    • 使用训练数据集来训练模型。
    • 使用交叉验证来评估模型的稳定性和性能。
  5. 性能评估

    • 使用测试数据集来评估模型的性能。
    • 重点观察召回率,但也要考虑精确度、F1分数等其他指标。
  6. 模型优化

    • 调整模型的超参数,如树的深度、学习率、正则化参数等。
    • 使用网格搜索(Grid Search)或随机搜索(Random Search)来找到最优的超参数组合。
  7. 模型选择

    • 比较不同模型的性能,选择召回率最高的模型。
    • 考虑模型的复杂度和训练时间,选择一个平衡性能和效率的模型。
  8. 选择算法

    • 线性回归                                                                                                                           

      # 初始化逻辑回归模型
      lr = LogisticRegression(C=10, max_iter=500, penalty='l2', solver='lbfgs')# 训练模型
      lr.fit(train_data_x, train_data_y)# 预测训练集
      train_pred = lr.predict(train_data_x)
      # 打印训练集的分类报告
      print('LR的train:\n', metrics.classification_report(train_data_y, train_pred))# 预测测试集
      test_pred = lr.predict(test_data_x)
      # 打印测试集的分类报告
      print('LR的test:\n', metrics.classification_report(test_data_y, test_pred))# 获取分类报告的字符串表示,并分割成单独的部分
      a = metrics.classification_report(test_data_y, test_pred, digits=6)
      b = a.split()# 初始化结果字典
      LR_result = {}# 提取召回率和准确率
      LR_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
      LR_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
      LR_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
      LR_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
      LR_result['accuracy'] = float(b[25])  # 添加准确率# 将逻辑回归的结果添加到总体结果字典中
      result_data = {'LR': LR_result}# 打印结束信息
      print('LR结束')
    • 支持向量机(SVM)                                                                                                       

      # 初始化SVM分类器
      svm_model = svm.SVC(C=1, coef0=0.1, degree=4, gamma=1, kernel='poly', probability=True, random_state=100
      )# 训练模型
      svm_model.fit(train_data_x, train_data_y)# 预测训练集
      train_pred = svm_model.predict(train_data_x)
      # 打印训练集的分类报告
      print('SVM的train:\n', metrics.classification_report(train_data_y, train_pred))# 预测测试集
      test_pred = svm_model.predict(test_data_x)
      # 打印测试集的分类报告
      print('SVM的test:\n', metrics.classification_report(test_data_y, test_pred))# 获取分类报告的字符串表示,并分割成单独的部分
      a = metrics.classification_report(test_data_y, test_pred, digits=6)
      b = a.split()# 初始化结果字典
      svm_result = {}# 提取召回率和准确率
      svm_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
      svm_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
      svm_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
      svm_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
      svm_result['accuracy'] = float(b[25])  # 添加准确率# 将SVM的结果添加到总体结果字典中
      result_data = {'svm': svm_result}# 打印结束信息
      print('SVM结束')
                                            
    • 随机森林                                                                                                                           

      # 初始化随机森林分类器
      rf = RandomForestClassifier(bootstrap=False,max_depth=20,max_features='log2',min_samples_leaf=1,min_samples_split=2,n_estimators=50,random_state=487
      )# 训练模型
      rf.fit(train_data_x, train_data_y)# 预测训练集
      train_pred = rf.predict(train_data_x)
      # 打印训练集的分类报告
      print('RF的train:\n', metrics.classification_report(train_data_y, train_pred))# 预测测试集
      test_pred = rf.predict(test_data_x)
      # 打印测试集的分类报告
      print('RF的test:\n', metrics.classification_report(test_data_y, test_pred))# 获取分类报告的字符串表示,并分割成单独的部分
      a = metrics.classification_report(test_data_y, test_pred, digits=6)
      b = a.split()# 初始化结果字典
      rf_result = {}# 提取召回率和准确率
      rf_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
      rf_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
      rf_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
      rf_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
      rf_result['accuracy'] = float(b[25])  # 添加准确率# 将随机森林的结果添加到总体结果字典中
      result_data = {'rf': rf_result}# 打印结束信息
      print('RF结束')
    • AdaBoost                                                                                                       

      # 初始化AdaBoost分类器
      abc = AdaBoostClassifier(algorithm='SAMME.R',  # 使用SAMME.R算法base_estimator=DecisionTreeClassifier(max_depth=2),  # 使用决策树作为基学习器n_estimators=200,  # 弱学习器的数量learning_rate=1.0,  # 学习率random_state=0  # 随机数种子
      )# 训练模型
      abc.fit(train_data_x, train_data_y)# 预测训练集
      train_pred = abc.predict(train_data_x)
      # 打印训练集的分类报告
      print('AdaBoost的train:\n', metrics.classification_report(train_data_y, train_pred))# 预测测试集
      test_pred = abc.predict(test_data_x)
      # 打印测试集的分类报告
      print('AdaBoost的test:\n', metrics.classification_report(test_data_y, test_pred))# 获取分类报告的字符串表示,并分割成单独的部分
      a = metrics.classification_report(test_data_y, test_pred, digits=6)
      b = a.split()# 初始化结果字典
      abc_result = {}# 提取召回率和准确率
      abc_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
      abc_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
      abc_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
      abc_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
      abc_result['accuracy'] = float(b[25])  # 添加准确率# 将AdaBoost的结果添加到总体结果字典中
      result_data = {'abc': abc_result}# 打印结束信息
      print('AdaBoost结束')
    • XGBoost                                                                                                                           

      # 初始化XGBoost分类器
      xgb = xgbs.XGBClassifier(learning_rate=0.05,n_estimators=200,num_class=5,max_depth=7,min_child_weight=1,  # 叶子节点中最小的样本权重gamma=0,  # 节点分裂所需的最小损失函数下降值subsample=0.6,  # 训练样本的子样本比例colsample_bytree=0.8,  # 每棵树随机采样的列数的占比objective='multi:softmax',  # 损失函数类型(对于多分类问题)seed=0  # 随机数种子
      )# 训练模型
      xgb.fit(train_data_x, train_data_y)# 预测训练集
      train_pred = xgb.predict(train_data_x)
      # 打印训练集的分类报告
      print('XGB的train:\n', metrics.classification_report(train_data_y, train_pred))# 预测测试集
      test_pred = xgb.predict(test_data_x)
      # 打印测试集的分类报告
      print('XGB的test:\n', metrics.classification_report(test_data_y, test_pred))# 获取分类报告的字符串表示,并分割成单独的部分
      a = metrics.classification_report(test_data_y, test_pred, digits=6)
      b = a.split()# 初始化结果字典
      xgb_result = {}# 提取召回率和准确率
      xgb_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
      xgb_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
      xgb_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
      xgb_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
      xgb_result['recall_4'] = float(b[26])  # 添加类别为4的召回率
      xgb_result['accuracy'] = float(b[31])  # 添加准确率# 将XGBoost的结果添加到总体结果字典中
      result_data = {'xgb': xgb_result}# 打印结束信息
      print('XGB结束')
    • 高斯朴素贝叶斯(GaussianNB)                                                                                          

      # 初始化高斯朴素贝叶斯分类器
      mb = GaussianNB()# 训练模型
      mb.fit(train_data_x, train_data_y)# 预测训练集
      train_pred = mb.predict(train_data_x)
      # 打印训练集的分类报告
      print('MNB的train:\n', metrics.classification_report(train_data_y, train_pred))# 预测测试集
      test_pred = mb.predict(test_data_x)
      # 打印测试集的分类报告
      print('MNB的test:\n', metrics.classification_report(test_data_y, test_pred))# 获取分类报告的字符串表示,并分割成单独的部分
      a = metrics.classification_report(test_data_y, test_pred, digits=6)
      b = a.split()# 初始化结果字典
      mb_result = {}# 提取召回率和准确率
      mb_result['recall_0'] = float(b[6])  # 添加类别为0的召回率
      mb_result['recall_1'] = float(b[11])  # 添加类别为1的召回率
      mb_result['recall_2'] = float(b[16])  # 添加类别为2的召回率
      # 修正召回率的键名 'recall 3' 为 'recall_3'
      mb_result['recall_3'] = float(b[21])  # 添加类别为3的召回率
      mb_result['accuracy'] = float(b[25])  # 添加准确率# 将朴素贝叶斯的结果添加到总体结果字典中
      result_data = {'mb': mb_result}# 打印结束信息
      print('MNB结束')

代码结果

完整代码

import pandas as pd
import numpy as np
train_data=pd.read_excel('训练数据集[随机森林填充].xlsx')
train_data_x=train_data.drop('矿物类型',axis=1)
train_data_y=train_data['矿物类型']test_data=pd.read_excel('测试数据集[随机森林填充].xlsx')
test_data_x=test_data.drop('矿物类型',axis=1)
test_data_y=test_data['矿物类型']result_data={}
# from sklearn.model_selection import GridSearchCV
# param_grid={
#     'penalty':['l1','l2','elasticnet','none'],
#     'C':[0.001,0.01,0.1,1,10,100],
#     'solver':['newton_cg','lbfgs','linear','sag','sage'],
#     'max_iter':[100,200,500],
#     'multi_class':['auto','ovr','multionmial']
# }
from sklearn.linear_model import LogisticRegression
# lohreg=LogisticRegression()
# grid_search=GridSearchCV(lohreg,param_grid,cv=5)
# grid_search.fit(train_data_x,train_data_y)
# print('最佳参数')
# print(grid_search.best_params_)LR_result={}
lr=LogisticRegression(C=10,max_iter=500,penalty='l2',solver='lbfgs')
lr.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=lr.predict(train_data_x)
print('LR的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=lr.predict(test_data_x)
print('LR的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()LR_result['recall_0']= float(b[6])  # 添加类别为0的召回导
LR_result['recall_1']= float(b[11])     # 添加类别为1的召回字
LR_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
LR_result['recall 3']= float(b[21])     # 添加类别为3的召回率
LR_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['LR']= LR_result    # result_data是总体的结果,
print('lr结束')import xgboost as xgbs
xgb_result={}
xgb=xgbs.XGBClassifier(learning_rate=0.05,
n_estimators=200,
num_class = 5,
max_depth=7,
min_child_weight=1, # 叶子节点中最小的样本权重
qamma=0,#节点分裂所需的最小损失函数下降值
subsample=0.6,#训练样本的子样本比例
colsample_bytree=0.8,#每棵树随机采样的列数的占比
objective='multi:softmax',#损失函数类型(对于二分类问题)
seed=0 #随机数种子
)# 创建XGBoost分类器
xgb.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=xgb.predict(train_data_x)
print('xgb的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=xgb.predict(test_data_x)
print('xgb的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()xgb_result['recall_0']= float(b[6])  # 添加类别为0的召回导
xgb_result['recall_1']= float(b[11])     # 添加类别为1的召回字
xgb_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
xgb_result['recall 3']= float(b[21])     # 添加类别为3的召回率
xgb_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['xgb']= xgb_result    # result_data是总体的结果,
print('xgb结束')from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
abc_result={}
abc = AdaBoostClassifier(algorithm='SAMME.R',  # 修正算法名称base_estimator=DecisionTreeClassifier(max_depth=2),  # 修正类名n_estimators=200,learning_rate=1.0,  # 修正参数名称random_state=0)
# abc=AdaBoostClassifier(algorithm='SAMME',base_estimator=DecisionTreeClassifier(max_depth=2),n_estimators=200,Learning_rate= 1.0,random_state=0)
abc.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=abc.predict(train_data_x)
print('abc的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=abc.predict(test_data_x)
print('abc的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()abc_result['recall_0']= float(b[6])  # 添加类别为0的召回导
abc_result['recall_1']= float(b[11])     # 添加类别为1的召回字
abc_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
abc_result['recall 3']= float(b[21])     # 添加类别为3的召回率
abc_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['abc']= abc_result    # result_data是总体的结果,
print('AdaBoost结束')from sklearn import svm
svm_result={}
svm=svm.SVC(C=1, coef0=0.1, degree= 4, gamma= 1, kernel='poly', probability=True, random_state=100)#
svm.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=svm.predict(train_data_x)
print('svm的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=svm.predict(test_data_x)
print('svm的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()svm_result['recall_0']= float(b[6])  # 添加类别为0的召回导
svm_result['recall_1']= float(b[11])     # 添加类别为1的召回字
svm_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
svm_result['recall 3']= float(b[21])     # 添加类别为3的召回率
svm_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['svm']= svm_result    # result_data是总体的结果,
print('svm结束')from sklearn.ensemble import RandomForestClassifierrf_result={}
rf=RandomForestClassifier(bootstrap= False,max_depth=20,max_features='log2',min_samples_leaf= 1,min_samples_split= 2,n_estimators=50,random_state=487)
rf.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=rf.predict(train_data_x)
print('rf的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=rf.predict(test_data_x)
print('rf的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()rf_result['recall_0']= float(b[6])  # 添加类别为0的召回导
rf_result['recall_1']= float(b[11])     # 添加类别为1的召回字
rf_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
rf_result['recall 3']= float(b[21])     # 添加类别为3的召回率
rf_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['rf']= rf_result    # result_data是总体的结果,
print('rf结束')from sklearn.naive_bayes import GaussianNB
mb_result={}
mb=GaussianNB()
mb.fit(train_data_x,train_data_y)
from sklearn import metrics
train_pred=mb.predict(train_data_x)
print('mb的train:\n',metrics.classification_report(train_data_y,train_pred))
test_pred=mb.predict(test_data_x)
print('mb的test:\n',metrics.classification_report(test_data_y,test_pred))
a=metrics.classification_report(test_data_y,test_pred,digits=6)
b=a.split()mb_result['recall_0']= float(b[6])  # 添加类别为0的召回导
mb_result['recall_1']= float(b[11])     # 添加类别为1的召回字
mb_result['recall_2']= float(b[16])     # 并添加美别为2的台回率
mb_result['recall 3']= float(b[21])     # 添加类别为3的召回率
mb_result['acc']=float(b[25])       # 添加accuracy的结果
result_data['mb']= mb_result    # result_data是总体的结果,
print('mb结束')import json
result={}
with open('随机森林填充.json','w') as f1:json.dump(result_data,f1,ensure_ascii=False)


http://www.ppmy.cn/news/1522668.html

相关文章

Python | Leetcode Python题解之第386题字典序排数

题目&#xff1a; 题解&#xff1a; class Solution:def lexicalOrder(self, n: int) -> List[int]:ans [0] * nnum 1for i in range(n):ans[i] numif num * 10 < n:num * 10else:while num % 10 9 or num 1 > n:num // 10num 1return ans

太速科技-1路万兆光纤SFP+和1路千兆网络 FMC子卡模块

1路万兆光纤SFP和1路千兆网络 FMC子卡模块 一、概述 该板卡是基于kc705和ml605的fmc 10g万兆光纤扩展板设计&#xff0c;提供了1路万兆光纤SFP和1路千兆网络接口。可搭配我公司开发的FPGA载卡使用。载卡可参考&#xff1a;ID204 SFP&#xff08;10 Gigabit Small…

1-10 图像增强对比度 opencv树莓派4B 入门系列笔记

目录 一、提前准备 二、代码详解 enhanced_image cv2.convertScaleAbs(image, alpha1.5, beta0) 三、运行现象 四、完整工程贴出 一、提前准备 1、树莓派4B 及 64位系统 2、提前安装opencv库 以及 numpy库 3、保存一张图片 二、代码详解 import cv2 # 增强图像的对比度 …

【Arm Cortex-X925】 -【第五章】-电源管理

5. 电源管理 Cortex-X925 核心提供了控制动态和静态功耗的机制。 动态功耗管理包括以下特性: 层次时钟门控每核心的动态电压和频率调整 (DVFS)静态功耗管理包括以下特性: 关机模式动态保持,一种低功耗模式,能够保留寄存器和 RAM 状态5.1 电压和功率域 DynamIQ™ Shared …

代码随想录Day 32|leetcode题目:501.斐波那契数、70.爬楼梯、746.使用最小花费爬楼梯

提示&#xff1a;DDU&#xff0c;供自己复习使用。欢迎大家前来讨论~ 文章目录 动态规划理论基础一、理论基础1.1 什么是动态规划1.2 动态规划的解题步骤1.3 动态规划应该如何debug 二、题目题目一&#xff1a; 509. 斐波那契数解题思路&#xff1a;动态规划递归解法 题目二&a…

【OpenWrt(3)】内网搭建iperf3测速服务器

下载的iperf3 网站&#xff1a;https://iperf.fr/iperf-download.php Window地址&#xff1a;https://github.com/ar51an/iperf3-win-builds 安卓&#xff1a;https://gitee.com/hiyanyx/magic-i-perf 文章目录 下载的iperf3Windows 服务器启动安卓客户端启动参考 Windows 服务…

363_C++_配合360_负责读取和处理录像数据RecordReader类

其中的变量们: 读取器未启用 (!m_bEnReader) 已经有一个读取操作正在进行 (m_bPending) 读取器还未启动 (!m_bStarted) lastRealBytes:计算这帧数据实际需要的总字节数(包括未处理的部分和对齐的填充字节) mLastOffset:表示上次处理数据时的偏移位置 lastRemain 计算出…

电路基础笔记 --- 第一章

关于电路吸收及发出功率的判断&#xff1a; 其实关于这个问题根据实际电流和电压更好判断&#xff0c;我们根据参考电压及参考电流再结合各自数值画出对于元件来说的实际电流方向和电位高低&#xff0c;在实际电流方向通过元件时如果电位变高则代表元件在产生功率&#xff0c;…

【Linux】进程控制(一)

1. 进程创建 &#xff08;一&#xff09;认识fork函数 从已存在进程中创建一个新进程&#xff08;新进程为子进程&#xff0c;而原进程为父进程&#xff09; 进程调用fork&#xff0c;当控制转移到内核中的fork代码后&#xff0c;内核做&#xff1a; 分配新的内存块和内核数…

如何恢复回收站中已删除/清空的文件

回收站清空后如何恢复已删除的文件&#xff1f;是否可以恢复永久删除的文件&#xff1f;或者最糟糕的是&#xff0c;如果文件直接被删除怎么办&#xff1f;本文将向您展示清空回收站后恢复已删除数据的最佳方法。 回收站清空后如何恢复已删除的文件&#xff1f; “回收站清空后…

将AI与情境定位结合以确保品牌安全

你可能会看到一些广告&#xff0c;感觉它们跟你在线阅读或观看的内容有奇怪的关联。这就是上下文广告在起作用。这种基于广告的解决方案在不断变化的数字环境中逐步发展&#xff0c;已经成为每个广告主的必备工具。不过&#xff0c;这种广告不只是把广告和上下文进行匹配这么简…

学习记录:js算法(二十八):删除排序链表中的重复元素、删除排序链表中的重复元素II

文章目录 删除排序链表中的重复元素我的思路解法一&#xff1a;循环解法二&#xff1a;递归 网上思路 删除排序链表中的重复元素 II我的思路网上思路 总结 删除排序链表中的重复元素 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出…

在js渲染的dom中的事件中传递对象

在某些情况下&#xff0c;可能需要将整个对象或部分对象嵌入到 HTML 元素的属性中&#xff0c;可以将对象数据序列化为 JSON 字符串&#xff0c;存储在 data-* 自定义属性中。这样可以在事件中取出并解析对象数据&#xff1a; <!DOCTYPE html> <html lang"en&qu…

Docker | Win10 安装

环境准备 1. 开启 WSL 环境配置 Docker 在 Windows 中&#xff0c;可以依赖于两种环境&#xff0c;分别是&#xff1a;Hyper-V、WSL。 Hyper-V&#xff1a;是一个虚拟环境&#xff0c;也就是虚拟机。WSL&#xff1a;是 Windows 的 Linux 子系统(系统要求不低于 Window10 的 …

八,SpringBoot Web 开发访问静态资源(附+详细源码剖析)

八&#xff0c;SpringBoot Web 开发访问静态资源(附详细源码剖析) 文章目录 八&#xff0c;SpringBoot Web 开发访问静态资源(附详细源码剖析)1. 基本介绍2. 快速入门2.1 准备工作 3. 改变静态资源访问前缀&#xff0c;定义为我们自己想要的4. 改变Spring Boot当中的默认的静态…

为何iPhone 16系列的发布对苹果至关重要?

即将发布的iPhone 16系列对苹果来说将是至关重要的时刻&#xff0c;特别是在快速发展的AI智能手机市场背景下。随着Android制造商在集成先进AI功能方面领先一步&#xff0c;苹果正处于一个关键的转折点——赶上竞争对手不仅仅是选择&#xff0c;而是必须完成的任务。 AI竞赛&am…

【深度学习详解】Task3 实践方法论-分类任务实践 Datawhale X 李宏毅苹果书 AI夏令营

前言 综合之前的学习内容&#xff0c; 本篇将探究机器学习实践方法论 出现的问题及其原因 &#x1f34e; &#x1f34e; &#x1f34e; 系列文章导航 【深度学习详解】Task1 机器学习基础-线性模型 Datawhale X 李宏毅苹果书 AI夏令营 【深度学习详解】Task2 分段线性模型-引入…

正则表达式--python

正则表达式 1、简介 概述 正确的, 符合特定规则的 字符串. 英文名叫: Regular Expression, 简称叫: re, RegExp 作用 主要是校验数据 细节 学正则, 主要是学正则的规则. 即: 哪个符号表示什么含义. 关于正则, 要求很简单, 只要能用规则, 看懂别人写的式子, 且能简单修改即可,…

springboot、flowable 生成图片发布到Docker乱码问题

flowable自带的方法生成图片时&#xff0c;如设置字体为宋体&#xff0c;则本地测试没有问题&#xff0c;因为windows自带宋体字体库&#xff0c;但是如果发布到Docker&#xff0c;则会出现乱码问题&#xff0c;因为大部分Docker并不包含宋体字体库&#xff1b; 通过Java代码&a…

VitePress 路由重写:自定义目录结构与页面生成

在使用VitePress构建文档网站时&#xff0c;你可能会遇到项目结构复杂的情况&#xff0c;特别是当你的项目是一个包含多个包的monorepo时。为了更好地组织和管理文档&#xff0c;你可能希望将文档文件放置在源代码旁边。然而&#xff0c;VitePress默认会按照特定的目录结构生成…