程序猿成长之路之数据挖掘篇——朴素贝叶斯

news2024/10/7 10:19:30

朴素贝叶斯是数据挖掘分类的基础，本篇文章将介绍一下朴素贝叶斯算法

情景再现

以挑选西瓜为例，西瓜的色泽、瓜蒂、敲响声音、触感、脐部等特征都会影响到西瓜的好坏。那么我们怎么样可以挑选出一个好的西瓜呢？

分析过程

既然挑选西瓜有多个条件可供选择，那么我们可以根据已知的样本数据去获取好瓜的筛选条件，再拿测试的样本数据去匹配，最终得到好瓜的概率。然后我们再根据已知的样本数据去获取坏瓜的筛选条件，拿测试的样本数据去匹配，得到坏瓜的概率，如果好瓜的概率超过坏瓜的概率，那么我们可以认为该瓜是好瓜。

朴素贝叶斯介绍

什么是朴素贝叶斯
官话：朴素贝叶斯(naive Bayes)算法是基于贝叶斯定理与特征条件独立假设的分类方法。对于给定的训练数据集，首先基于特征条件独立假设学习输入输出的联合概率分布。然后基于此模型，对给定的输入x，利用贝叶斯定理求出后验概率最大的输出y。不同于其他分类器，朴素贝叶斯是一种基于概率理论的分类算法；
用个人的话来说：朴素贝叶斯就是基于概率大小进行分类判断的一种方式。就如同上面的西瓜分类，好瓜概率大就认定为是好瓜，否则就认定为坏瓜。

先验概率、似然概率和后验概率
先验概率：根据训练集可以经过统计初步得到的概率，就如同上文所说的好瓜或者坏瓜。标记为P（C）
似然概率：就是在先验概率基础上满足某一定条件的概率。比如当西瓜色泽为青绿色时好瓜的概率。标记为P(x|c)
后验概率：P(c|x) 即我们要求的概率，即P(好瓜|色泽=青绿)

贝叶斯的公式
在这里插入图片描述
公式简单介绍：就拿西瓜为例，P(色泽=青绿|好瓜) = P(色泽青绿) * P(好瓜|色泽青绿) | P(好瓜)
简单整体理解就是，先求色泽青绿的瓜中好瓜的概率然后乘以色泽青绿的瓜的数量就是色泽青绿的好瓜数量，然后除以好瓜的数量就是P(色泽=青绿|好瓜)的概率。

朴素贝叶斯的优势

  1. 实现简单：朴素贝叶斯基于先验概率和似然概率进行后验概率的求解，实现相对简单
  2. 算法较为快捷

扩展学习

求解先验和似然概率
根据大数定律，当训练集包含充足的独立同分布样本时，P（c）可通过各类样本出现的频率来进行估计。
朴素贝叶斯对条件概率分布做了条件独立性的假设。具体来说，条件独立性假设是：
在这里插入图片描述
这里的x(1) -> x(n) 表示各个满足的条件（比如，西瓜的色泽、瓜蒂、敲响声音、触感、脐部等特征）总而言之就是将各个条件满足的概率进行相乘后得到似然概率。

先验概率P©的极大似然估计是
在这里插入图片描述
其中N是样本集的总数，K是类别的总数，I表示事件，这里的意思是满足不同特征的好瓜或者坏瓜的概率。

似然概率P(x|c)的极大似然估计分为离散型和连续型两种计算方式：
离散型的计算方式如下：
在这里插入图片描述
其中，xi^{(j)}代表第i个样本的第j个特征；a{jl}是第j个特征可能取的第l个值。 代入原来的西瓜模型为例，有：
P(色泽= 青绿|好瓜) = I(色泽=青绿，好瓜) / I(好瓜）也就是说好瓜中色泽青绿的概率。
连续型的似然概率计算方式如下：
在这里插入图片描述
也就是说使用正态分布函数进行计算，求出似然概率的值。

拉普拉斯修正
我们可能会遇到这种情况，x(i) 特征的频率为0，那么基于朴素贝叶斯的公式，有似然概率为0，那么会出现计算出的后验概率为0的情况，（如下图所示） 为了避免出现这种情况，我们可以使用拉普拉斯修正算法。
在这里插入图片描述
拉普拉斯修正公式：
在这里插入图片描述
这里的N为特征类型数量（如敲响有清脆、沉闷、浊响三种，那么N = 3），也就是说P(敲响=清脆|好瓜） = （0+1）/（8+3） ≈ 0.091

代码

训练集如下：
在这里插入图片描述

package beiyesi;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


public class BeiyesiUtil2 {
	
	private static List<TestItem2> list = new ArrayList<>();
	
	static {
		TestItem2 item1 = new TestItem2();
		item1.setColor("青绿");
		item1.setRoot("蜷缩");
		item1.setSound("浊响");
		item1.setWenli("清晰");
		item1.setQibu("凹陷");
		item1.setTouch("硬滑");
		item1.setDensity(0.697);
		item1.setSugerRate(0.46);
		item1.setGood(true);
		list.add(item1);
		
		TestItem2 item2 = new TestItem2();
		item2.setColor("乌黑");
		item2.setRoot("蜷缩");
		item2.setSound("沉闷");
		item2.setWenli("清晰");
		item2.setQibu("凹陷");
		item2.setTouch("硬滑");
		item2.setDensity(0.774);
		item2.setSugerRate(0.376);
		item2.setGood(true);
		list.add(item2);
		
		TestItem2 item3 = new TestItem2();
		item3.setColor("乌黑");
		item3.setRoot("蜷缩");
		item3.setSound("浊响");
		item3.setWenli("清晰");
		item3.setQibu("凹陷");
		item3.setTouch("硬滑");
		item3.setDensity(0.634);
		item3.setSugerRate(0.264);
		item3.setGood(true);
		list.add(item3);
		
		TestItem2 item4 = new TestItem2();
		item4.setColor("青绿");
		item4.setRoot("蜷缩");
		item4.setSound("沉闷");
		item4.setWenli("清晰");
		item4.setQibu("凹陷");
		item4.setTouch("硬滑");
		item4.setDensity(0.608);
		item4.setSugerRate(0.318);
		item4.setGood(true);
		list.add(item4);
		
		TestItem2 item5 = new TestItem2();
		item5.setColor("浅白");
		item5.setRoot("蜷缩");
		item5.setSound("浊响");
		item5.setWenli("清晰");
		item5.setQibu("凹陷");
		item5.setTouch("硬滑");
		item5.setDensity(0.556);
		item5.setSugerRate(0.215);
		item5.setGood(true);
		list.add(item5);
		
		TestItem2 item6 = new TestItem2();
		item6.setColor("青绿");
		item6.setRoot("稍蜷");
		item6.setSound("浊响");
		item6.setWenli("清晰");
		item6.setQibu("稍凹");
		item6.setTouch("软粘");
		item6.setDensity(0.403);
		item6.setSugerRate(0.237);
		item6.setGood(true);
		list.add(item6);
	
		TestItem2 item7 = new TestItem2();
		item7.setColor("乌黑");
		item7.setRoot("稍蜷");
		item7.setSound("浊响");
		item7.setWenli("稍糊");
		item7.setQibu("稍凹");
		item7.setTouch("软粘");
		item7.setDensity(0.481);
		item7.setSugerRate(0.149);
		item7.setGood(true);
		list.add(item7);
		
		TestItem2 item8 = new TestItem2();
		item8.setColor("乌黑");
		item8.setRoot("稍蜷");
		item8.setSound("浊响");
		item8.setWenli("清晰");
		item8.setQibu("稍凹");
		item8.setTouch("硬滑");
		item8.setDensity(0.437);
		item8.setSugerRate(0.211);
		item8.setGood(true);
		list.add(item8);
		
		TestItem2 item9 = new TestItem2();
		item9.setColor("乌黑");
		item9.setRoot("稍蜷");
		item9.setSound("沉闷");
		item9.setWenli("稍糊");
		item9.setQibu("稍凹");
		item9.setTouch("硬滑");
		item9.setDensity(0.666);
		item9.setSugerRate(0.091);
		item9.setGood(false);
		list.add(item9);
		
		TestItem2 item10 = new TestItem2();
		item10.setColor("青绿");
		item10.setRoot("硬挺");
		item10.setSound("清脆");
		item10.setWenli("清晰");
		item10.setQibu("平坦");
		item10.setTouch("软粘");
		item10.setDensity(0.243);
		item10.setSugerRate(0.267);
		item10.setGood(false);
		list.add(item10);
		
		TestItem2 item11 = new TestItem2();
		item11.setColor("浅白");
		item11.setRoot("硬挺");
		item11.setSound("清脆");
		item11.setWenli("模糊");
		item11.setQibu("平坦");
		item11.setTouch("硬滑");
		item11.setDensity(0.245);
		item11.setSugerRate(0.057);
		item11.setGood(false);
		list.add(item11);
		
		TestItem2 item12 = new TestItem2();
		item12.setColor("浅白");
		item12.setRoot("蜷缩");
		item12.setSound("浊响");
		item12.setWenli("模糊");
		item12.setQibu("平坦");
		item12.setTouch("软粘");
		item12.setDensity(0.343);
		item12.setSugerRate(0.099);
		item12.setGood(false);
		list.add(item12);
		
		TestItem2 item13 = new TestItem2();
		item13.setColor("青绿");
		item13.setRoot("稍蜷");
		item13.setSound("浊响");
		item13.setWenli("稍糊");
		item13.setQibu("凹陷");
		item13.setTouch("硬滑");
		item13.setDensity(0.639);
		item13.setSugerRate(0.161);
		item13.setGood(false);
		list.add(item13);
		
		TestItem2 item14 = new TestItem2();
		item14.setColor("浅白");
		item14.setRoot("稍蜷");
		item14.setSound("沉闷");
		item14.setWenli("稍糊");
		item14.setQibu("凹陷");
		item14.setTouch("硬滑");
		item14.setDensity(0.657);
		item14.setSugerRate(0.198);
		item14.setGood(false);
		list.add(item14);
		
		TestItem2 item15 = new TestItem2();
		item15.setColor("乌黑");
		item15.setRoot("稍蜷");
		item15.setSound("浊响");
		item15.setWenli("清晰");
		item15.setQibu("稍凹");
		item15.setTouch("软粘");
		item15.setDensity(0.36);
		item15.setSugerRate(0.37);
		item15.setGood(false);
		list.add(item15);
		
		TestItem2 item16 = new TestItem2();
		item16.setColor("浅白");
		item16.setRoot("蜷缩");
		item16.setSound("浊响");
		item16.setWenli("模糊");
		item16.setQibu("平坦");
		item16.setTouch("硬滑");
		item16.setDensity(0.593);
		item16.setSugerRate(0.042);
		item16.setGood(false);
		list.add(item16);
		
		TestItem2 item17 = new TestItem2();
		item17.setColor("青绿");
		item17.setRoot("蜷缩");
		item17.setSound("沉闷");
		item17.setWenli("稍糊");
		item17.setQibu("稍凹");
		item17.setTouch("硬滑");
		item17.setDensity(0.719);
		item17.setSugerRate(0.103);
		item17.setGood(false);
		list.add(item17);
	}
	
	/**
	 * 朴素贝叶斯分类
	 * @param testJson
	 * @return 贝叶斯分类
	 */
	@SuppressWarnings("unchecked")
	public static void calc(TestItem2 ...itemList){
		//朴素贝叶斯分类
		try {
			String date = new SimpleDateFormat("yyyyMMdd").format(new Date());
			File f = new File("D:/decisionTree/dataset/beiyesi_datas_" + date + ".dat");
			//读取/写入数据集
			List<TestItem2> items = new ArrayList<>();
			if (f.exists()) {
				try(ObjectInputStream ios = new ObjectInputStream(new FileInputStream(f))) {
					Object obj = ios.readObject();
					if (obj instanceof List) {
						items = (List<TestItem2>)obj;
					}			
					for (TestItem2 item:itemList) {
						System.out.println(item.toString());
					}
				} catch (FileNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (ClassNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				items = list;
				try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f))) {
					oos.writeObject(list);
					oos.flush();
				} catch (FileNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
				
			System.out.println("---------start--------");
			long timepre = System.currentTimeMillis();
			calc(items,itemList);
			long timeAfter = System.currentTimeMillis() - timepre;
			System.out.println("---------end " + timeAfter + "--------");
		} catch (IllegalArgumentException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 朴素贝叶斯分类
	 * @param item
	 * @return
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	private static void calc(List<TestItem2> items,TestItem2[] testItems) 
			throws IllegalArgumentException, IllegalAccessException {
		//使用递归进行朴素贝叶斯分类
		boolean[] isValid= new boolean[testItems.length];
		for (int i = 0; i < testItems.length; i++) {
			isValid[i] = calc(items,testItems[i]);
		}
		String date = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
		File f = new File("D:/decisionTree/dataset/result_" + date + ".dat");
		//结果保存
		if (!f.exists()){
			try(BufferedWriter writer = new BufferedWriter(new FileWriter(f))) {
				for (int i = 0; i < testItems.length; i++) {
					writer.write("测试数据为:");
					writer.newLine();
					writer.write(testItems[i].toString());
					writer.newLine();
					writer.write("结果为:" + (isValid[i] ? "好瓜":"坏瓜"));
					writer.newLine();
				}
				writer.flush();
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				System.out.println("结果已保存");
			}
		} else {
			System.out.println("结果表已存在");
		}
	}
	
	/**
	 * 
	 * @param items
	 * @param condition
	 * @return
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	private static boolean calc(
			List<TestItem2> items, 
			TestItem2 trainItem
	) 
			throws IllegalArgumentException, IllegalAccessException {
		//利用反射机制获取某一条件的条目数量
		Class<?> cls = TestItem2.class;
		Field[] fs = cls.getDeclaredFields();
		double[] resSim = {1.0,1.0};
		//计算连续属性的贝叶斯
		Map<String,Double[]> resMap = calcLianxuVar(items,trainItem);
		for (Field f:fs) {
			if (f.getType().getName().contains("Double")
				|| f.getType().getName().contains("Integer")) {
				for (int i = 0; i < resSim.length;i++)
					resSim[i] *= resMap.get(f.getName())[i];
			}
			
		}
		System.out.println(Arrays.toString(resSim));
		int totalCount[] = {0,0}; //0-好瓜，1-坏瓜
		//计算其他离散属性的项集数量
		//计算离散数据当前分类的总数
		for (TestItem2 item: items) {
			boolean goodRes = item.isGood();
			if (goodRes) {
				totalCount[0]++;
			} else {
				totalCount[1]++;
			}
		}
		System.out.println(Arrays.toString(totalCount));
		//计算离散数据不同分类的数量
		Map<String,Double[]> res = new ConcurrentHashMap<>();
		for(TestItem2 item: items) {		
			for(Field f:fs) {
				f.setAccessible(true);
				Object val = f.get(item);
				if (val instanceof String) {
					String str = f.getName() + "_" + String.valueOf(val);
					boolean goodRes = item.isGood();
					if (res.get(str) == null) {
						if (goodRes) {
							res.put(str, new Double[]{1.0,0.0});
						} else {
							res.put(str, new Double[]{0.0,1.0});
						}
					} else {
						Double[] arr = res.get(str);
						if (goodRes) {
							arr[0] = arr[0] + 1;
						} else {
							arr[1] = arr[1] + 1;
						}
						res.put(str,arr);
					}
				}
			}
		}
		//进行当前样本的匹配度计算
		for (int i = 0; i < 2; i++) {
			for (Field f:fs) {
				f.setAccessible(true);
				Object val = f.get(trainItem);
				//求分类数量
				List<String> typeList = new ArrayList<>();
				for (String key: res.keySet()) {
					if (key.contains(f.getName()) && 
							!typeList.contains(key)) {
						typeList.add(key);
					}
				}
				if (val instanceof String) {
					String str = f.getName() + "_" + String.valueOf(val);
					//使用拉普拉斯修正，调整值为0的数据
					resSim[i] *= (res.get(str)[i] + 1)/ ((totalCount[i] + typeList.size()) * 1.0);
				}		
			}
		}
		return resSim[0] >= resSim[1] ? true:false;
	}

	/**
	 * 计算连续属性的概率密度函数（正态分布）
	 * @param items
	 * @param trainItem
	 * @return
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	private static Map<String,Double[]> calcLianxuVar(List<TestItem2> items, TestItem2 trainItem) 
			throws IllegalArgumentException, IllegalAccessException {
		//计算均值和方差，只计算一次
		Double avg[],fangcha[],counter[];//0-好瓜，1-坏瓜
		Map<String,Double[]> avgMap = new ConcurrentHashMap<>();
		Map<String,Double[]> resMap = new ConcurrentHashMap<>();
		//训练模型
		//计算平均值
		Class<?> cls = TestItem2.class;
		Field[] fs = cls.getDeclaredFields();
		for (Field f: fs) {
			if (!(f.getType().getName().contains("Double")
					|| f.getType().getName().contains("Integer"))){
				continue;
			}
			//重新分配内存
			avg = new Double[2];
			counter = new Double[2];
			for (int i = 0; i < 2;i++) {
				avg[i] = 0.0;
				counter[i] = 0.0;
			}
			for (TestItem2 item: items) {
				f.setAccessible(true);
				boolean goodRes = item.isGood();
				if (goodRes) {
					avg[0] += (Double)f.get(item);
					counter[0]++;
				} else {
					avg[1] += (Double)f.get(item);
					counter[1]++;
				}
			}
			for (int i = 0;i < 2; i++) {
				avg[i] = avg[i] / counter[i];
			}
			avgMap.put(f.getName(), avg);
		}
		//计算方差
		for (Field f: fs) {
			if (!(f.getType().getName().contains("Double")
					|| f.getType().getName().contains("Integer"))){
				continue;
			}
			//重新分配内存
			fangcha = new Double[2];
			counter = new Double[2];
			for (int i = 0; i < 2;i++) {
				fangcha[i] = 0.0;
				counter[i] = 0.0;
			}
			for (TestItem2 item: items) {
				f.setAccessible(true);
				boolean goodRes = item.isGood();
				if (goodRes) {
					fangcha[0] +=
							Math.pow(((Double)f.get(item) - avgMap.get(f.getName())[0]), 2);
					counter[0]++;
				} else {
					fangcha[1] +=
							Math.pow(((Double)f.get(item) - avgMap.get(f.getName())[1]), 2);
					counter[1]++;
				}
			}
			for (int i =0;i < 2;i++) {
				fangcha[i] = fangcha[i] / ((counter[i] - 1) * 1.0);
			}
			resMap.put(f.getName(), fangcha);
		}
		Field[] fields = trainItem.getClass().getDeclaredFields();
		for(Map.Entry<String, Double[]> set:resMap.entrySet()) {
			for (Field f: fields) {
				f.setAccessible(true);
				if (f.getName().equalsIgnoreCase(set.getKey())) {
					Double val = (Double) f.get(trainItem);
					Double[] res = set.getValue();
					for (int i = 0; i < res.length;i++) {
						res[i] = 1/((Math.sqrt(2 * Math.PI) * Math.sqrt(set.getValue()[i])))
								* Math.exp(-1 * Math.pow((val - avgMap.get(set.getKey())[i]),2) / (2 * set.getValue()[i] * 1.0));
					}
					resMap.put(f.getName(), res);
				}
			}
		}
		return resMap;
	}

	public static void main(String[] args) {
		TestItem2 item1 = new TestItem2();
		item1.setColor("青绿");
		item1.setRoot("蜷缩");
		item1.setSound("浊响");
		item1.setWenli("清晰");
		item1.setQibu("凹陷");
		item1.setTouch("硬滑");
		item1.setDensity(0.697);
		item1.setSugerRate(0.46);
		item1.setGood(true);
		list.add(item1);
		calc(item1);
	}
	
}

TestItem 类

package beiyesi;

import java.io.Serializable;

/**
 * 好瓜坏瓜
 * @author zygswo
 *
 */
public class TestItem2 implements Serializable{

	@Override
	public String toString() {
		return "TestItem2 [color=" + color + ", root=" + root + ", sound=" + sound + ", wenli=" + wenli
				+ ", qibu=" + qibu + ", touch=" + touch + ", density=" + density + ", sugerRate=" + sugerRate
				+ ", isGood=" + isGood + "]";
	}

	private static final long serialVersionUID = 1L;

	public String getRootStyle() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public String getRoot() {
		return root;
	}

	public void setRoot(String root) {
		this.root = root;
	}

	public String getSound() {
		return sound;
	}

	public void setSound(String sound) {
		this.sound = sound;
	}

	public String getWenli() {
		return wenli;
	}

	public void setWenli(String wenli) {
		this.wenli = wenli;
	}

	public String getQibu() {
		return qibu;
	}

	public void setQibu(String qibu) {
		this.qibu = qibu;
	}

	public String getTouch() {
		return touch;
	}

	public void setTouch(String touch) {
		this.touch = touch;
	}

	public Double getDensity() {
		return density;
	}

	public void setDensity(double density) {
		this.density = density;
	}

	public Double getSugerRate() {
		return sugerRate;
	}

	public void setSugerRate(double sugerRate) {
		this.sugerRate = sugerRate;
	}

	public String getColor() {
		return color;
	}
	
	public boolean isGood() {
		return isGood;
	}

	public void setGood(boolean isGood) {
		this.isGood = isGood;
	}

	/**
	 * 色泽
	 */
	private String color;
	/**
	 * 根蒂
	 */
	private String root;
	
	/**
	 * 敲声
	 */
	private String sound;
	
	/**
	 * 纹理
	 */
	private String wenli;
	
	/**
	 * 脐部
	 */
	private String qibu;
	
	/**
	 * 触感
	 */
	private String touch;
	
	/**
	 * 密度
	 */
	private Double density;
	
	/**
	 * 含糖量
	 */
	private Double sugerRate;
	
	/**
	 * 是否好瓜
	 */
	private boolean isGood;
}

引用

朴素贝叶斯算法 https://www.jianshu.com/p/a4ddf754357b

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

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

相关文章

【七】jmeter5.5+influxdb2.0+prometheus+grafana

【七】jmeter5.5+influxdb2.0+prometheus+grafana

参考文章&#xff1a;https://blog.csdn.net/wenxingchen/article/details/126892890 https://blog.csdn.net/Zuo19960127/article/details/119726652 https://blog.csdn.net/shnu_cdk/article/details/132182858 promethus参考 由于自己下载的是infuldb2.0&#xff0c;所以按照…
阅读更多...
【视频异常检测】Open-Vocabulary Video Anomaly Detection 论文阅读

【视频异常检测】Open-Vocabulary Video Anomaly Detection 论文阅读

Open-Vocabulary Video Anomaly Detection 论文阅读 AbstractMethod3.1. Overall Framework3.2. Temporal Adapter Module3.3. Semantic Knowledge Injection Module3.4. Novel Anomaly Synthesis Module3.5. Objective Functions3.5.1 Training stage without pseudo anomaly …
阅读更多...
【webrtc】Chrome和Firefox在SDP协商过程中，针对localhost的不同处理

【webrtc】Chrome和Firefox在SDP协商过程中，针对localhost的不同处理

内网下chrome端webrtc协商失败 现象 我有一个webrtc服务器在局域网内&#xff0c;使用chrome浏览器访问时&#xff0c;发现webrtc在做媒体协商时失败。 具体表现是&#xff0c;在交换sdp后&#xff0c;ice的状态是oniceconnectionstatechange: failed 但是换成Firefox浏览器…
阅读更多...
【Linux】文件目录及路径表示

【Linux】文件目录及路径表示

1. Linux目录结构 在 Linux 系统中&#xff0c;有几个目录是比较重要的&#xff0c;平时需要注意不要误删除或者随意更改内部文件。 /etc&#xff1a; 这个是系统中的配置文件&#xff0c;如果更改了该目录下的某个文件可能会导致系统不能启动。 /bin, /sbin, /usr/bin, /usr…
阅读更多...
黄金行情下跌有投资机会吗？

黄金行情下跌有投资机会吗？

尽管黄金价格的波动常常引起投资者的高度关注&#xff0c;但行情的下跌未必只是警讯&#xff0c;亦可能蕴藏着某些难得的投资机会。总之&#xff0c;答案是肯定的——在黄金行情下跌时&#xff0c;依旧有适宜的投资机会&#xff0c;只是这需要投资者具备相应的应对知识和策略。…
阅读更多...
是德软件89600 RFID使用笔记

是德软件89600 RFID使用笔记

文章目录 1、进入RFID软件&#xff1a;2、RFID软件解调设置项3、如何查看一段指令数据 本文是日常工作的笔记分享。 lauch VSA&#xff08;矢量频谱分析&#xff09;后会出现以下界面&#xff1a; 当然这是因为频谱仪的输入有信号才显示如下&#xff1a; 否则就显示频谱仪的噪…
阅读更多...
【书生浦语第二期实战营学习笔记作业(七)】

【书生浦语第二期实战营学习笔记作业(七)】

课程文档&#xff1a;https://github.com/InternLM/Tutorial/blob/camp2/opencompass/readme.md 课程作业&#xff1a;https://github.com/InternLM/Tutorial/blob/camp2/opencompass/homework.md OpenCompass 大模型评测实战 1. 大模型的评测1.1 大模型评测如何促进发展1.2 大…
阅读更多...
WebSocket的原理、作用、常见注解和生命周期的简单介绍，附带SpringBoot示例

WebSocket的原理、作用、常见注解和生命周期的简单介绍，附带SpringBoot示例

文章目录 WebSocket是什么WebSocket的原理WebSocket的作用全双工和半双工客户端【浏览器】API服务端 【Java】APIWebSocket的生命周期WebSocket的常见注解SpringBoot简单代码示例 WebSocket是什么 WebSocket是一种 通信协议 &#xff0c;它在 客户端和服务器之间建立了一个双向…
阅读更多...
线性代数 --- 矩阵的对角化以及矩阵的n次幂

线性代数 --- 矩阵的对角化以及矩阵的n次幂

矩阵的对角化以及矩阵的n次幂 &#xff08;特征向量与特征值的应用&#xff09; 前言&#xff1a; 在上一篇文章中&#xff0c;我记录了学习矩阵的特征向量和特征值的学习笔记&#xff0c;所关注的是那些矩阵A作用于向量x后&#xff0c;方向不发生改变的x(仅有尺度的缩放)。线…
阅读更多...
跟着野火从零开始手搓emWin（1）初识emWin

跟着野火从零开始手搓emWin（1）初识emWin

PS&#xff1a;在嵌入式领域&#xff0c;本人认为QT的应用范围和性能几乎吊打市面上所有的GUI工具。但是本人之所以学习emWin&#xff0c;是因为自己有些微不足道的小想法&#xff0c;需要通过它来实现。但是QT有点吃硬件的配置&#xff0c;为了MCU专门发行的QT我又懒得去弄&am…
阅读更多...
mac电脑搭建vue项目（下篇）

mac电脑搭建vue项目（下篇）

第三步&#xff1a;安装npm &#xff08;1&#xff09;执行以下命令安装cnpm淘宝镜像 sudo npm install -g cnpm --registryhttps://registry.npmmirror.com &#xff08;2&#xff09;执行命令cnpm -v查看版本信息&#xff0c;结果说找不到cnpm命令 &#xff08;3&#xff…
阅读更多...
智慧校园：大数据助力校情分析

智慧校园：大数据助力校情分析

随着信息技术的快速发展&#xff0c;数据信息资源以井喷的姿态涌现。数据信息的大量涌现给人们带来丰富的数据信息资源&#xff0c;但面对海量的信息资源时&#xff0c;加大了人们对有效信息资源获取的难度&#xff0c;数据挖掘技术正是这一背景下的产物&#xff0c;基于数据挖…
阅读更多...
【003_音频开发_基础篇_Linux进程通信（20种你了解几种？)】

【003_音频开发_基础篇_Linux进程通信（20种你了解几种？)】

003_音频开发_基础篇_Linux进程通信&#xff08;20种你了解几种&#xff1f;) 文章目录 003_音频开发_基础篇_Linux进程通信&#xff08;20种你了解几种&#xff1f;)创作背景Linux 进程通信类型fork() 函数fork() 输出 2 次fork() 输出 8 次fork() 返回值fork() 创建子进程 方…
阅读更多...
elasticsearch-8.1.0安装记录

elasticsearch-8.1.0安装记录

目录 零、版本说明一、安装二、使用客户端访问 零、版本说明 centos [rootnode1 ~]# cat /etc/redhat-release CentOS Linux release 7.9.2009 (Core)elasticsearch elasticsearch-8.1.0-linux-x86_64一、安装 systemctl stop firewalld.servicesystemctl disable firewal…
阅读更多...
【国产替代】航空电子通信总线航空电子通信总线产品为MIL-STD-1553和ARINC 429等协议提供原生支持

【国产替代】航空电子通信总线航空电子通信总线产品为MIL-STD-1553和ARINC 429等协议提供原生支持

航空电子通信总线 航空电子通信总线产品为MIL-STD-1553和ARINC 429等协议提供原生支持。这些产品用于进行航空电子应用所需的开发、生产和系统测试。 PXIe&#xff0c;2通道PXI ARINC-664接口模块 AIM ARINC-664具有板载处理器&#xff0c;可自动处理所有与协议相关的活动&…
阅读更多...
python绘图时渐变的处理——以一个扇形图的渐变为例

python绘图时渐变的处理——以一个扇形图的渐变为例

python绘图时渐变的处理——以一个扇形图的渐变为例 使用matplotlib绘制扇形的圆环 from matplotlib.patches import Wedge wedgeWedge((0,0),1,0,60,width0.3,colorred) wedge.set_edgecolor(k) fig,axplt.subplots(1,1) ax.add_patch(wedge) # 设置坐标轴的比例 plt.axis(e…
阅读更多...
DaPy：实现数据分析与处理

DaPy：实现数据分析与处理

DaPy&#xff1a;实现数据分析与处理 DaPy是一个用于数据分析和处理的Python库&#xff0c;它提供了一系列强大的工具和功能&#xff0c;使开发者能够高效地进行数据清洗、转换和分析。本文将深入解析DaPy库的特点、功能以及使用示例&#xff0c;帮助读者了解如何利用DaPy库处理…
阅读更多...
数据库之数据库恢复技术思维导图+大纲笔记

数据库之数据库恢复技术思维导图+大纲笔记

大纲笔记&#xff1a; 事务的基本概念 事务 定义 用户定义的一个数据库操作系列&#xff0c;这些操作要么全做&#xff0c;要么全不做&#xff0c;是一个不可分割的基本单位 语句 BEGIN TRANSACTION 开始 COMMIT 提交&#xff0c;提交事务的所有操作 ROLLBACK 回滚&#xff0c…
阅读更多...
CAN通信简单入门（一）

CAN通信简单入门（一）

1.IIC和CAN通信的主要区别 IIC至少需要3根线&#xff0c;SCL,SDA,GND 但是CAN只需要两条线&#xff0c;CAN_H以及CAN_L 2.CAN简介 3.主流通信协议详解 反正CAN通信最大的优势就是&#xff1a;可以多个主机同时进行通信 4.CAN协议详解 4.1 CAN硬件电路 在闭环电路当中&…
阅读更多...
Android Studio 报错：AVD Pixel_3a_API_30_x86 is already running

Android Studio 报错：AVD Pixel_3a_API_30_x86 is already running

在我的Android Studio和虚拟机运行时&#xff0c;我的电脑不小心关机了&#xff0c;在启动后再次打开Android Studio并运行虚拟机时发现报错。 Error while waiting for device: AVD Pixel_3a_API_30_x86 is already running. If that is not the case, delete the files at C…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023