semi-Naive Bayesian（半朴素贝叶斯）

semi-Naive Bayesian（半朴素贝叶斯）

引言

朴素贝叶斯算法是基于特征是相互独立这个假设开展的（为了降低贝叶斯公式: P ( c ∣ x ) = P ( c ) P ( x ∣ c ) P ( x ) P(c|x) = \frac {P(c)P(x|c)}{P(x)} P(c∣x)=P(x)P(c)P(x∣c)​中后验概率 P ( c ∣ x ) P(c|x) P(c∣x)的困难），但在现实中这个假设往往很难成立。对条件独立假设进行适当的放宽，便引申出了“半朴素贝叶斯”。半朴素的意思就是，在朴素和非朴素之间寻找平衡，并不完全遵从条件独立，也不完全符合现实情况。

原理

在朴素贝叶斯中，对一个样本进行预测就是要找最大概率对应的类别，即
a r g m a x c k p ( c k ) ∏ i = 1 d P ( x i ∣ c l ) argmax_{c_k}p(c_k)\prod_{i=1}^d P(x_i|c_l) argmaxck​​p(ck​)i=1∏d​P(xi​∣cl​)
半朴素贝叶斯分类器的基本想法是适当考虑一部分属性间的相互依赖信息，从而既不需进行完全联合概率计算，又不至于彻底忽略了比较强的属性依赖关系。“独依赖估计”（One-Dependent Estimator，简称ODE）是半朴素贝叶斯分类器最常用的一种策略。“独依赖”就是假设每个属性在类别之外最多仅依赖于一个其他属性，即:
p ( c ∣ x ) ∝ p ( c k ) ∏ i = 1 d p ( x i ∣ c k , p a i ) p(c|x) \propto p(c_k)\prod_{i=1}^d p(x_i|c_k,pa_i) p(c∣x)∝p(ck​)i=1∏d​p(xi​∣ck​,pai​)
其中 p a i pa_i pai​为属性 x i x_i xi​所依赖的属性，称为 x i x_i xi​的父属性。此时，对每个属性 x i x_i xi​，若其父属性 p a i pa_i pai​已知，则可采用类似
p ^ ( x i ∣ c ) = ∣ D c , x i ∣ + 1 ∣ D c ∣ + N i \hat p(x_i|c) = \frac{|D_{c,x_i}|+1}{|D_c|+N_i} p^​(xi​∣c)=∣Dc​∣+Ni​∣Dc,xi​​∣+1​
的方法来估计概率值 p ( x i ∣ c , p a i ) p(x_i|c,pa_i) p(xi​∣c,pai​)。于是，问题就转化为如何确定每个属性的父属性，不同的做法产生不同的独依赖分类器。

根据不同确定父属性可以有不同的半朴素贝叶斯分类器：

  1. 选择贝叶斯分类器(SBC:Selective Bayesian Classifier)
  2. 超父独依赖估计分类器(SPODE:Super Parent ODE)
  3. 树增广朴素贝叶斯网络分类器(TAN:Tree Augmented NaiveBayes)
  4. 平均独依赖估测器(AODE:Averaged ODE)
  5. 加权平均独依赖估测器(WAODE:Weightily Averaged ODE)

在这里插入图片描述

  • SPODE

    确定父属性最直接的做法是假设所有属性都依赖于同一个属性，称为“超父”（super-parent），然后通过交叉验证等模型选择方法来确定超父属性，由此形成了SPODE（Super-Parent ODE）方法。

  • AODE

    将每个属性都作为超父来构建SPODE，然后将具有足够训练数据支撑的SPODE集成起来作为最终结果，由此形成了AODE算法（Averaged ODE），AODE是一种基于集成学习机制、更为强大的独依赖分类器。表达式：
    ∑ i = 1 d p ( c , x i ) ∏ j = 1 d p ( x j ∣ c , x i ) ， ∣ D x i ∣ ≥ m ′ \sum_{i=1}^d p(c,x_i)\prod{j=1}^dp(x_j|c,x_i)，|D_{x_i}|\geq m' i=1∑d​p(c,xi​)∏j=1dp(xj​∣c,xi​)，∣Dxi​​∣≥m′

    ∣ D x i ∣ |D_{x_i}| ∣Dxi​​∣ 是在第i个属性上取值为 x i x_i xi​的样本的集合，m’是阈值常数。
    p ( c , x i ) = ∣ D c , x i ∣ + 1 ∣ D ∣ + N c ∗ N i p(c,x_i) = \frac{|D_{c,x_i}|+1}{|D|+N_c*N_i} p(c,xi​)=∣D∣+Nc​∗Ni​∣Dc,xi​​∣+1​
    p ( x j ∣ c , x i ) = ∣ D c , x i , x j ∣ + 1 ∣ D c , x i ∣ + N j p(x_j|c,x_i) = \frac {|D_{c,x_i,x_j}|+1}{|D_{c,x_i}|+N_j} p(xj​∣c,xi​)=∣Dc,xi​​∣+Nj​∣Dc,xi​,xj​​∣+1​其中， N c N_c Nc​表示分类类别数， N i N_i Ni​表示第i个属性可能的取值数， N j N_j Nj​表示第j个属性可能的取值数， ∣ D c , x I ∣ |D_{c,x_I}| ∣Dc,xI​​∣表示分类为c，第i个属性取值为 x i x_i xi​的样本集合， ∣ D c , x i , x j ∣ |D_{c,x_i,x_j}| ∣Dc,xi​,xj​​∣表示分类为c，第i个属性取值为 x i x_i xi​，第j个属性取值为 x j x_j xj​的样本集合。

  • TAN

    TAN（Tree Augmented naive Bayes）是在最大带权生成树（maximum weighted spanning tree）算法的基础上，通过以下步骤将属性间依赖关系约简为如上图©所示的树形结构：

    1. 计算任意两个属性之间的条件互信息:
      I ( x i , x j ∣ y ) = ∑ x i , x j ; c ∈ y P ( x i , x j ∣ c ) l o g P ( x i , x j ∣ c ) P ( x i ∣ c ) P ( x j ∣ c ) I(x_i,x_j|y) = \sum_{x_i,x_j;c\in y}P(x_i,x_j|c)log\frac{P(x_i,x_j|c)}{P(x_i|c)P(x_j|c)} I(xi​,xj​∣y)=xi​,xj​;c∈y∑​P(xi​,xj​∣c)logP(xi​∣c)P(xj​∣c)P(xi​,xj​∣c)​
    2. 以属性为结点，构建完全图，任意两个结点之间边的权重设为 I ( x i , x j ∣ y ) I(x_i,x_j|y) I(xi​,xj​∣y)。
    3. 构建此完全图的最大带权生成树，挑选根变量，将边置为有向。
    4. 加入类别节点y，增加从y到每个属性的有向边。

代码

import numpy as np
import pandas as pd


######一、朴素贝叶斯分类器
class NBayes(object):
    #设置属性
    def __init__(self):
        self.Y = 0          #训练集标签
        self.X = 0          #训练集数据
        self.PyArr = {}     #先验概率总容器
        self.PxyArr = {}    #条件概率总容器

    #连续变量处理，返回均值和标准差
    def Gaussian(self, xArr):
        miu = np.mean(xArr)            #变量平均数
        sigma = np.std(xArr)           #变量标准差
        return miu, sigma

    #离散变量直接计算概率
    def classify(self, x, xArr, countSetX):
        countX = len(xArr)              #计算变量X的数量
        countXi = sum(xArr == x)   #计算变量X某个属性的数量
        Pxy = (countXi+1)/(countX+countSetX)    #加入拉普拉斯修正的概率
        return Pxy

    #计算P(y)，加入了拉普拉斯修正
    def calPy(self,Y):
        Py = {}
        countY = len(Y)
        for i in set(Y.flatten()):
            countI = sum(Y[:,0] == i)
            Py[i] = (countI + 1) / (countY + len(set(Y.flatten())))
        self.PyArr = Py
        return

    #计算P(x|y)，加入了拉普拉斯修正
    def calPxy(self, X, Y):
        m, n = np.shape(X)
        Pxy = {}
        for yi in set(Y.flatten()):
            countYi = sum(Y[:,0] == yi)
            Pxy[yi] = {}                        #第一层是标签Y的分类
            for xIdx in range(n):
                Pxy[yi][xIdx] = {}              #第二层是不同的变量X
                setX = set(X[:,xIdx])
                tempX = X[np.nonzero(Y[:,0] == yi)[0],xIdx]
                for xi in setX:
                    countSetX = len(setX)
                    if countSetX <= 10:
                        Pxy[yi][xIdx][xi] = self.classify(xi, tempX, countSetX)     #第三层是变量Xi的分类概率，离散变量
                    else:
                        Pxy[yi][xIdx]['miu'], Pxy[yi][xIdx]['sigma'] = self.Gaussian(tempX)
        self.PxyArr = Pxy
        return

    #训练
    def train(self, X, Y):
        self.calPy(Y)
        print('P(y)训练完毕')
        self.calPxy(X, Y)
        print('P(x|y)训练完毕')
        self.X = X
        self.Y = Y
        return

    #连续变量求概率密度
    def calContinous(self, x, miu, sigma):
        Pxy = np.exp(-(x-miu)**2/(2*sigma**2))/(np.power(2*np.pi,0.5)*sigma)   #计算概率密度
        return Pxy

    #预测
    def predict(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, Py in self.PyArr.items():
            Ptest = Py
            print(yi,Ptest)
            for xIdx in range(n):
                xi = testX[0,xIdx]
                if len(set(self.X[:,xIdx])) <= 10:
                    Ptest *= self.PxyArr[yi][xIdx][xi]
                else:
                    pxy = self.calContinous(xi, self.PxyArr[yi][xIdx]['miu'], self.PxyArr[yi][xIdx]['sigma'])
                    Ptest *= pxy
                print(yi,Ptest)
            preP[yi] = Ptest
        return preP

    #防止数值下溢，预测时用log
    def predictlog(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, Py in self.PyArr.items():
            Ptest = 0
            for xIdx in range(n):
                xi = testX[0,xIdx]
                if len(set(self.X[:,xIdx])) <= 10:
                    Ptest += np.log(self.PxyArr[yi][xIdx][xi])
                else:
                    pxy = self.calContinous(xi, self.PxyArr[yi][xIdx]['miu'], self.PxyArr[yi][xIdx]['sigma'])
                    Ptest += np.log(pxy)
                print(yi,Ptest)
            preP[yi] = Py*Ptest
        return preP

#数据集准备
from sklearn.preprocessing import OrdinalEncoder
dataSet = [
        ['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.697, 0.460, '好瓜'],
        ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.774, 0.376, '好瓜'],
        ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.634, 0.264, '好瓜'],
        ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', 0.608, 0.318, '好瓜'],
        ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', 0.556, 0.215, '好瓜'],
        ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.403, 0.237, '好瓜'],
        ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘', 0.481, 0.149, '好瓜'],
        ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑', 0.437, 0.211, '好瓜'],
        ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑', 0.666, 0.091, '坏瓜'],
        ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘', 0.243, 0.267, '坏瓜'],
        ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑', 0.245, 0.057, '坏瓜'],
        ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘', 0.343, 0.099, '坏瓜'],
        ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑', 0.639, 0.161, '坏瓜'],
        ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑', 0.657, 0.198, '坏瓜'],
        ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘', 0.360, 0.370, '坏瓜'],
        ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑', 0.593, 0.042, '坏瓜'],
        ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑', 0.719, 0.103, '坏瓜']
    ]
#特征值列表
labels = ['色泽', '根蒂', '敲击', '纹理', '脐部', '触感', '密度', '含糖率']
dataX = np.array(dataSet)[:,:6]
oriencode = OrdinalEncoder(categories='auto')
oriencode.fit(dataX)
X1=oriencode.transform(dataX)           #编码后的数据
X2=np.array(dataSet)[:,6:8].astype(float)
X = np.hstack((X1,X2))
Y = np.array(dataSet)[:,8]
Y[Y=="好瓜"]=1
Y[Y=="坏瓜"]=0
Y=Y.astype(float)
Y = Y.reshape(-1,1)

#训练
NB = NBayes()
NB.train(X, Y)
Pdict = NB.predict(X[0,:].reshape(1,-1))
logPdict = NB.predictlog(X[0,:].reshape(1,-1))


######二、半朴素贝叶斯分类器(Averaged One-Dependent Estimator)
class HalfNBayes(object):
    #设置属性
    def __init__(self):
        self.Y = 0          #训练集标签
        self.X = 0          #训练集数据
        self.PyArr = {}     #先验概率总容器
        self.PxyArr = {}    #条件概率总容器

    #连续变量处理，返回均值和标准差
    def Gaussian(self, xArr):
        miu = np.mean(xArr)            #变量平均数
        sigma = np.std(xArr)           #变量标准差
        return miu, sigma

    #离散变量直接计算概率
    def classify(self, x, xArr, countSetX):
        countX = len(xArr)              #计算变量X的数量
        countXi = sum(xArr == x)   #计算变量X某个属性的数量
        Pxy = (countXi+1)/(countX+countSetX)    #加入拉普拉斯修正的概率
        return Pxy

    #计算P(xi,y)，加入了拉普拉斯修正
    def calPy(self, X, Y):
        m, n = np.shape(X)
        Py = {}
        countY = len(Y)
        for i in set(Y.flatten()):
            Py[i] = {}                          #第一层是标签Y的分类
            for j in range(n):
                setX = set(X[:,j])
                countSetX = len(setX)
                if countSetX <= 10:
                    Py[i][j] = {}               #第二层是不同的变量X
                    for xi in setX:
                        countI = sum((Y[:,0] == i) & (X[:,j] == xi))
                        Py[i][j][xi] = (countI + 1) / (countY + countSetX*len(set(Y.flatten())))       #第二层是分类变量xi的不同值
        self.PyArr = Py
        return

    #计算P(x|y,xi)，加入了拉普拉斯修正
    def calPxy(self, X, Y):
        m, n = np.shape(X)
        Pxy = {}
        for yi in set(Y.flatten()):
            countYi = sum(Y[:,0] == yi)
            Pxy[yi] = {}                        #第一层是标签Y的分类
            for superX in range(n):
                setSuperX = set(X[:,superX])
                countSuperX = len(setSuperX)
                if countSuperX <= 10:
                    Pxy[yi][superX] = {}        #第二层是超父变量X，只有离散变量
                    for superXi in setSuperX:
                        Pxy[yi][superX][superXi] = {}               #第三层是超父变量的属性值superXi
                        for xIdx in range(n):
                            if xIdx == superX:
                                continue
                            Pxy[yi][superX][superXi][xIdx] = {}     #第四层是不同的变量X
                            setX = set(X[:,xIdx])
                            tempX = X[np.nonzero((Y[:,0] == yi)&(X[:,superX] == superXi))[0],xIdx]
                            for xi in setX:
                                countSetX = len(setX)
                                if countSetX <= 10:
                                    Pxy[yi][superX][superXi][xIdx][xi] = self.classify(xi, tempX, countSetX)     #第五层是变量Xi的分类概率，离散变量
                                else:
                                    Pxy[yi][superX][superXi][xIdx]['miu'], Pxy[yi][superX][superXi][xIdx]['sigma'] = self.Gaussian(tempX)
        self.PxyArr = Pxy
        return

    #训练
    def train(self, X, Y):
        self.calPy(X, Y)
        print('P(y)训练完毕')
        self.calPxy(X, Y)
        print('P(x|y)训练完毕')
        self.X = X
        self.Y = Y
        return

    #连续变量求概率密度
    def calContinous(self, x, miu, sigma):
        Pxy = np.exp(-(x-miu)**2/(2*sigma**2+1.0e-6))/(np.power(2*np.pi,0.5)*sigma+1.0e-6)   #计算概率密度
        return Pxy

    #预测
    def predict(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, Py in self.PyArr.items():
            Ptest = Py
            print(yi,Ptest)
            for xIdx in range(n):
                xi = testX[0,xIdx]
                if len(set(self.X[:,xIdx])) <= 10:
                    Ptest *= self.PxyArr[yi][xIdx][xi]
                else:
                    pxy = self.calContinous(xi, self.PxyArr[yi][xIdx]['miu'], self.PxyArr[yi][xIdx]['sigma'])
                    Ptest *= pxy
                print(yi,Ptest)
            preP[yi] = Ptest
        return preP

    #防止数值下溢，预测时用log
    def predictlog(self, testX):
        preP = {}
        m, n = testX.shape
        for yi, superXdict in self.PyArr.items():
            print('yi是{}================'.format(yi))
            Ptest = 0
            for superX, superXidict in superXdict.items():
                superXi = testX[0,superX]
                Py = superXidict[superXi]
                print('超父属性是{}，Py概率是{}'.format(superX, Py))
                print('----------------')
                Pxi = 0
                for xIdx in range(n):
                    if xIdx == superX:
                        continue
                    xi = testX[0,xIdx]
                    print('第{}个变量，值是{}'.format(xIdx, xi))
                    if len(set(self.X[:,xIdx])) <= 10:
                        Pxi += np.log(self.PxyArr[yi][superX][superXi][xIdx][xi])
                        print('概率是：',np.log(self.PxyArr[yi][superX][superXi][xIdx][xi]))
                    else:
                        pxy = self.calContinous(xi, self.PxyArr[yi][superX][superXi][xIdx]['miu'], self.PxyArr[yi][superX][superXi][xIdx]['sigma'])
                        print('概率是：',pxy)
                        Pxi += np.log(pxy)
                Ptest += Py*Pxi
            preP[yi] = Ptest
        return preP

#训练
HNB = HalfNBayes()
HNB.train(X, Y)
logPdict = HNB.predictlog(X[15,:].reshape(1,-1))

参考

机器学习基础

知乎

知乎

代码

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/896900.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Linux】进程优先级进程切换

【Linux】进程优先级进程切换

文章目录 进程优先级查看进程优先级进程优先级的修改 进程切换进程切换的概念 总结 进程优先级 进程优先级是操作系统中用于决定进程调度顺序的重要属性。它表示一个进程在系统资源分配和 CPU 调度中的相对重要性。优先级越高的进程通常会获得更多的 CPU 时间和资源&#xff0…
阅读更多...
若依项目学习---【数据字典】

若依项目学习---【数据字典】

数据字典 若以内置的数据字典&#xff0c;用于维护系统中常见的静态数据。例如&#xff1a;性别、状态……如下&#xff1a; 简单描述&#xff1a;一个地方定义&#xff0c;多个地方使用。 只需要修改数据字典&#xff0c;而不需要修改每一个使用该数据的地方。 常见静态数据&…
阅读更多...
【C++】创建TCP客户端

【C++】创建TCP客户端

目录 一、实现发送字符串功能 二、实现接收字符串功能 三、客户端接收乱码问题 四、客户端发送乱码问题 五、客户端接收到数据时进行回调 六、子线程接收数据 七、发送Json格式数据 源码 一、实现发送字符串功能 头文件 #pragma once #include <iostream> #inc…
阅读更多...
.net framework 3.5sp1插件怎么安装

.net framework 3.5sp1插件怎么安装

以下是在不同操作系统电脑上安装.NET Framework 3.5 SP1 的几种常见方法&#xff1a; 一、Windows 10 及以上操作系统&#xff1a; 1.在线安装&#xff08;需要网络连接稳定&#xff09;&#xff1a; 按键盘上的 Windows 键&#xff0c;键入 “Windows 功能”&#xff0c;然…
阅读更多...
15分钟学Go 第3天：编写第一个Go程序

15分钟学Go 第3天：编写第一个Go程序

第3天&#xff1a;编写第一个Go程序 1. 引言 在学习Go语言的过程中&#xff0c;第一个程序通常是“Hello, World!”。这个经典的程序不仅教会你如何编写代码&#xff0c;还引导你理解Go语言的基本语法和结构。本节将详细介绍如何编写、运行并理解第一个Go程序&#xff0c;通过…
阅读更多...
建库建表练习

建库建表练习

目录 根据以下需求完成图书管理系统数据库及表设计&#xff0c;并建库建表&#xff0c;并截图创建表的详细信息(desc 表名),不用添加数据 1. 用户表: 字段: 姓名&#xff0c;用户名&#xff0c;密码&#xff0c;电话&#xff0c;住址&#xff0c;专业及年级 2. 图书表: 字段: 图…
阅读更多...
你知道吗？这个岗位只招2人，但HR那边却收到了1w份简历

你知道吗？这个岗位只招2人，但HR那边却收到了1w份简历

引言 在当前经济环境下&#xff0c;求职者面临的挑战越来越大。互联网行业尤其如此&#xff0c;许多人挤破头都想进入大厂&#xff0c;但竞争异常激烈。如今的就业市场确实变得异常艰难。然而&#xff0c;随着AI大模型技术的兴起&#xff0c;对于那些掌握了相关技能的专业人才…
阅读更多...
基于vue框架的的地铁站智慧管理系统的设计n09jb（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。

基于vue框架的的地铁站智慧管理系统的设计n09jb（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。

系统程序文件列表 项目功能&#xff1a;用户,上班打卡,下班打卡,人员管理,交接班,视频巡检,车辆巡检,车辆管理 开题报告内容 基于Vue框架的地铁站智慧管理系统的设计开题报告 一、研究背景与意义 随着城市化进程的加速&#xff0c;地铁站作为城市交通系统的重要组成部分&am…
阅读更多...
PC端视频编辑解决方案，跨平台SDK，构建多端统一的创作生态

PC端视频编辑解决方案，跨平台SDK，构建多端统一的创作生态

从短视频的兴起&#xff0c;到中长视频内容的蓬勃发展&#xff0c;视频创作领域正经历着一场深刻的变革。在这场变革中&#xff0c;美摄科技以其卓越的PC端视频编辑解决方案&#xff0c;不仅站在了技术创新的前沿&#xff0c;更以开放的姿态&#xff0c;为企业用户搭建起通往未…
阅读更多...
Java项目-基于springboot框架的校园疫情防控系统系统项目实战(附源码+文档)

Java项目-基于springboot框架的校园疫情防控系统系统项目实战(附源码+文档)

作者&#xff1a;计算机学长阿伟 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、ElementUI等&#xff0c;“文末源码”。 开发运行环境 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringBoot、Vue、Mybaits Plus、ELementUI工具&#xff1a;IDEA/…
阅读更多...
Springboot 使用POI导出Excel文件

Springboot 使用POI导出Excel文件

Springboot 使用POI导出Excel文件 Excel导出系列目录&#xff1a;引入依赖逻辑处理controllerservice数据查询Excel文件内容处理样式封装 导出效果思考 Excel导出系列目录&#xff1a; 【Springboot 使用EasyExcel导出Excel文件】 【Springboot 使用POI导出Excel文件】 【Spri…
阅读更多...
VScode远程开发之remote 远程开发（二）

VScode远程开发之remote 远程开发（二）

VScode远程开发之remote 远程开发&#xff08;二&#xff09; 使用vscode进行远程开发很简单&#xff0c;在拓展里搜索 Remote Development&#xff0c;就可以搜索到微软提供的远程开发大礼包&#xff0c;里面包含了 通过 SSH 远程服务器 远程容器 远程 WSL&#xff08;Win…
阅读更多...
演示：基于WPF的DrawingVisual开发的高刷新率示波器

演示：基于WPF的DrawingVisual开发的高刷新率示波器

一、目的&#xff1a;分享一个基于WPF的DrawingVisual开发的高刷新率示波器 二、效果演示 特此说明&#xff1a;由于Gif录制工具帧率不够&#xff0c;渲染60帧用了4.6秒&#xff0c;平均帧率在12Hz左右&#xff0c;所以展示效果不好&#xff0c;想要看好些的效果可以看文章下面…
阅读更多...
安科瑞智慧能源管理系统EMS3.0在浙江某能源集团有限公司的应用

安科瑞智慧能源管理系统EMS3.0在浙江某能源集团有限公司的应用

安科瑞戴婷 Acrel-Fanny 一、项目背景 浙江某能源集团有限公司位于浙江省宁波前湾新区&#xff0c;主营业务范围包括了储能技术服务&#xff0c;光伏风力发电技术服务&#xff0c;充电桩技术服务&#xff0c;新能源项目的施工以及为企业提供配电房运维服务。 随着新能源的兴…
阅读更多...
[ComfyUI]Flux：爆火禅语小和尚素材！禅意人生，享受自在

[ComfyUI]Flux：爆火禅语小和尚素材！禅意人生，享受自在

在快节奏的现代生活中&#xff0c;人们越来越渴望一种宁静和放松的状态。而禅意小和尚素材正是这样一种能够带给我们内心宁静和智慧的存在。ComfyUI的Flux框架结合了禅意小和尚素材&#xff0c;为我们提供了一个探索禅意人生的独特方式。 禅意小和尚素材源于佛教文化&#xff…
阅读更多...
DORA 机器人中间件学习教程（5）——3D激光雷达数据可视化

DORA 机器人中间件学习教程（5）——3D激光雷达数据可视化

DORA中3D激光雷达数据可视化 1 总体思路2 DORA数据接收节点3 编写yml文件4 启动节点参考资料 截止目前 DORA还没有类似于ROS2中RVIZ这样的可视化工具&#xff0c;而在调试算法时我们又需要将数据进行可视化以验证代码的正确性。目前的解决方法是将DORA中的数据发送到ROS2中&…
阅读更多...
ubuntu查看系统版本命令

ubuntu查看系统版本命令

查看系统版本指令 在 Ubuntu 操作系统中&#xff0c;您可以使用多个命令来查看系统版本。以下是一些常用的命令&#xff1a; lsb_release -a 这个命令会显示详细的 Ubuntu 版本信息&#xff0c;包括发行版名称、版本号、代号等。lsb_release -acat /etc/os-release 这个命令会显…
阅读更多...
实用好助手

实用好助手

在现代职场中&#xff0c;拥有高效且适用的工具能够显著提升我们的工作效率与质量。除了常见的办公软件&#xff0c;还有许多小众但非常实用的工具可以大幅度优化工作流程。以下是另外五个推荐的工作软件&#xff0c;它们各自具备独特的功能与优势&#xff0c;值得一试。 1 …
阅读更多...
MongoDB未授权访问

MongoDB未授权访问

mongodb未授权访问漏洞 复现 MongoDB[//]: # (忙够DB)是一种流行的开源文档数据库管理系统&#xff08;DBMS&#xff09;&#xff0c;基于分布式文件存储的数据库属于NoSQL数据库的一种。 开启MongoDB服务时不添加任何参数时,默认是没有权限验证的 登录的用户可以通过默认端口…
阅读更多...
双十一适合买什么东西？2024年双十一收藏榜单必买好物分享！

双十一适合买什么东西？2024年双十一收藏榜单必买好物分享！

随着双十一的脚步日益临近&#xff0c;各大电商平台已经开始了激烈的促销竞争。作为每年最盛大的购物节&#xff0c;双十一不仅吸引了无数消费者的积极参与&#xff0c;也成为品牌和产品质量的一次大检阅。那么&#xff0c;在2024年的双十一&#xff0c;哪些商品是值得购买的呢…
阅读更多...
最新文章

Copyright @ 2022~2023