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

news2024/12/22 23:57:32

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

代码思路：

  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 RandomForestClassifier

rf_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.coloradmin.cn/o/2116905.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

FastGPT自定义插件的icon

FastGPT自定义插件的icon

最近研究FastGPT的自定义插件，经过好几天的折磨，终于实现了一个简单的发送邮件功能，但是呢在使用的时候发现插件的icon是默认的fastgpt的logo，那肯定得自定义一个啊。直接说方法： 1、自定义插件下面的template.json文件…
阅读更多...
zookeeper相关面试题

zookeeper相关面试题

zk的数据同步原理？zk的集群会出现脑裂的问题吗？zk的watch机制实现原理？zk是如何保证一致性的？zk的快速选举leader原理？zk的典型应用场景zk中一个客户端修改了数据之后，其他客户端能够马上获取到最新的数据吗…
阅读更多...
握 手 问 题

握 手 问 题

目录 一：问题描述 二：思路: 三：代码： 四：结果：1204 一：问题描述 小蓝组织了一场算法交流会议，总共有50 5050 人参加了本次会议。在会议上，大家进行了握手交流。按照…
阅读更多...
excel如何删除某列或者某区域的重复数据

excel如何删除某列或者某区域的重复数据

先，鼠标选中想要去除重复数据的某列或者某区域 然后，点击上方栏中的【数据】-【删除重复数据】： 之后，表格里只留下了无重复的数据
阅读更多...
STM32(十一)：ADC数模转换器实验

STM32(十一)：ADC数模转换器实验

AD单通道： 1.RCC开启GPIO和ADC时钟。配置ADCCLK分频器。 2.配置GPIO，把GPIO配置成模拟输入的模式。 3.配置多路开关，把左面通道接入到右面规则组列表里。 4.配置ADC转换器， 包括AD转换器和AD数据寄存器。单次转换，连…
阅读更多...
Kafka （快速）安装部署

Kafka （快速）安装部署

文章目录 1、软件下载&配置环境1_JDK安装2_Zookeeper安装3_Kafka安装 2、单机安装1_配置主机名和IP映射2_单机Kafka配置 3、集群安装1_配置主机名和IP的映射关系2_时钟同步3_Zookeeper配置信息4_集群Kafka配置 4、kafka的其他脚本命令5、监控工具Kafka-eagle安装 1、软件下…
阅读更多...
Java并发编程实战 07 | 如何正确停止线程

Java并发编程实战 07 | 如何正确停止线程

什么时候需要停止一个线程？ 一个线程被创建并启动之后，大部分情况下都会自然运行至结束，但是也有一些情况需要主动停止线程，比如： 用户主动取消执行：用户可能会中止一个正在进行的操作，这时需…
阅读更多...
Python系统教程004（字符串）

Python系统教程004（字符串）

一、input函数的算术运算 一包奥特曼卡片卖0.5元，小华想编写一个只需要输入卡片的包数就能自动计算价格的程序，请你帮帮它。 解题 报出类型错误 注意： input函数接收到的键盘信息，默认都是字符串的数据类型。 字符串的数据类型…
阅读更多...
书生浦语三期实战营 [进阶] LMDeploy 量化部署进阶实践

书生浦语三期实战营 [进阶] LMDeploy 量化部署进阶实践

LMDeploy 量化部署进阶实践 1 配置LMDeploy环境 1.1 InternStudio开发机创建与环境搭建 在终端中，让我们输入以下指令，来创建一个名为lmdeploy的conda环境，python版本为3.10，创建成功后激活环境并安装0.5.3版本的lmdeploy及相关…
阅读更多...
IM即时通讯，稳定可靠的即时通讯服务-WorkPlus

IM即时通讯，稳定可靠的即时通讯服务-WorkPlus

在现代企业日常工作中，即时通讯已成为了一种不可或缺的沟通工具。为了满足企业对稳定可靠的即时通讯服务的需求，WorkPlus提供了一款优秀的IM即时通讯平台，以满足企业高效沟通和协作的要求。本文将深入探讨IM即时通讯服务的重要性以及WorkPlus…
阅读更多...
Linux下的RTC应用

Linux下的RTC应用

RTC RTC基础知识 1. RTC简介 RTC 全称是 Real-Time clock，翻译过来是实时时钟。实时时钟在日常生活中的应用也比较泛，比如电子时钟。实时时钟可以为系统提供精确的实时时间，通常带有电池，可以保证系统断电时还可以正常工作&…
阅读更多...
JVM虚拟机 - 基础篇

JVM虚拟机 - 基础篇

一、初始JVM 1. JVM是什么 2. JVM的三大核心功能是什么？ 3. 常见的JVM虚拟机有哪些？ 二、字节码文件详解 1. Java虚拟机的组成 2. 字节码文件的组成 （1）基本信息 Magic魔数 主副版本号 （2）常量池 &#…
阅读更多...
RabbitMQ练习（AMQP 0-9-1 Overview）

RabbitMQ练习（AMQP 0-9-1 Overview）

1、What is AMQP 0-9-1 AMQP 0-9-1（高级消息队列协议）是一种网络协议，它允许遵从该协议的客户端（Publisher或者Consumer）应用程序与遵从该协议的消息中间件代理（Broker，如RabbitMQ）…
阅读更多...
Day19_0.1基础学习MATLAB学习小技巧总结（19）——MATLAB绘图篇（2）

Day19_0.1基础学习MATLAB学习小技巧总结（19）——MATLAB绘图篇（2）

利用空闲时间把碎片化的MATLAB知识重新系统的学习一遍，为了在这个过程中加深印象，也为了能够有所足迹，我会把自己的学习总结发在专栏中，以便学习交流。 参考书目：《MATLAB基础教程 (第三版) (薛山)》 之前的章节都是…
阅读更多...
H5漂流瓶社交系统源码

H5漂流瓶社交系统源码

一个非常有创意的H5漂流瓶社交系统源码，带完整前端h5和后台管理系统。 环境：Nginx 1.20.1-MySQL 5.6.50-PHP-7.3 代码下载
阅读更多...
python简单计算入门教程|加减法

python简单计算入门教程|加减法

python通过调用numpy模块，非常擅长数学计算。再通过调用matplotlib模块，可以自由自在地输出numpy计算的结果。 今天，我们就尝试一些基本计算。 下述是正弦函数和余弦函数的加法和减法计算结果。 图1 代码为： import matplotli…
阅读更多...
【stata】处理城市名和城市代码

【stata】处理城市名和城市代码

写了两个简单的外部命令，在这里分享一下，希望能帮到大家 1.citycode_mutate 第一个命令是citycode_mutate，用于识别字符串中可能存在的城市信息，并生成城市代码（图1图2）。 2.cityname_mutate 第二个命令…
阅读更多...
如何编写Linux PCIe设备驱动器 之二

如何编写Linux PCIe设备驱动器 之二

如何编写Linux PCIe设备驱动器 之二 功能(capability)集功能(capability)APIs通过pci_bus_read_config完成功能存取功能APIs参数pos常量值PCI功能结构 PCI功能IDMSI功能电源功率管理功能 功能(capability)集 功能(capability)APIs int pcie_capability_read_word(struct pci_…
阅读更多...
C++（一）----C++基础

C++（一）----C++基础

1.C的发展史 C语言诞生后，很快普及使用，但是随着编程规模增大且越来越复杂，并且需要高度的抽象和建模时，C语言的诸多短板便表现了出来，为了解决软件危机，上世纪八十年代，计算机界提出了oop&…
阅读更多...
拓扑排序-广度优先遍历思路

拓扑排序-广度优先遍历思路

本质： 【广度优先遍历 】【贪心算法】应用于【有向图】的专有名词 应用场景：任务调度，课程安排 作用： 得到一个不唯一的【拓扑序】检测【有向图】是否有环，使用数据【并查集】 使用：先找度为0的前驱节点…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023