HMM动态手势识别3——k-means

最新推荐文章于 2021-12-07 20:35:10 发布
最新推荐文章于 2021-12-07 20:35:10 发布
阅读量284 收藏 1
点赞数
分类专栏： HMM动态手势识别 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_Qyaya/article/details/104665023
版权

k-mean算法的主类

package kmeans;

import java.math.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;

import MySQL.ChaZhao;
 
public class main {
	public  static void main(String[] args)  
    {  
		Scanner s = new Scanner(System.in);
        //初始化一个Kmean对象，设置k
		int num;
		//System.out.println("输入要分为的类数：");			
		//num=s.nextInt();
		num = 10;
        k_means k=new k_means(num);  
        
        ArrayList<float[]> dataSet=new ArrayList<float[]>();  

		Connection conn = ChaZhao.getconn();
		dataSet = ChaZhao.select(conn);
        ChaZhao.close();
        
        
        //设置原始数据集  
        k.setDataSet(dataSet);  
        //执行算法  
        k.kmeans();
        //得到聚类结果  
        ArrayList<ArrayList<float[]>> cluster=k.getCluster();  
        
        //查看结果  
        //分类坐标结果打印
        k.printCenter();
        //数据分布结果
        
        System.out.println(cluster.size());
        double d = 0;
        double m = 1200;//12000条数据  12000/16=750
        //12000/10 = 1200
        double s1;
        for(int i=0;i<cluster.size();i++)  
        {   System.out.print("k="+i+":");
        	int n = cluster.get(i).size();
            System.out.println(n);  
            d += (n-m)*(n-m);
        } 
        BigDecimal dd = new BigDecimal(d);
        s1 = dd.divide(new BigDecimal(16)).doubleValue();
        System.out.println("s:"+s1);
        
        /*
        for(int i=0;i<cluster.size();i++)  
        {   System.out.println("k="+i);
            k.printDataArray(cluster.get(i));  
        }  
        */
        
        dataSet.clear();
        cluster.clear();
        k.Clean();
    }  
}

计算k-means中心值时的k-means算法，计算出所给数据所属的分类，更新入数据库

package kmeans;

import java.util.ArrayList;  
import java.util.Random;  
   
public class k_means {  
    private int k;// 分成多少簇  
    private int m;// 迭代次数  
    private int dataSetLength;// 数据集元素个数，即数据集的长度  
    private ArrayList<float[]> dataSet;// 数据集链表  一组数据(x,y,z)存入一个数组中
    //一个动态手势30组数据，一个手势需要100组，也就是3000组数据
    private ArrayList<float[]> center;// 中心链表  
    private ArrayList<ArrayList<float[]>> cluster; // 簇  
    private ArrayList<Float> jc;// 误差平方和，k越接近dataSetLength，误差越小  
    private Random random;  
    
    public void Clean(){
    	dataSet.clear();
    	center.clear();
    	cluster.clear();
    	jc.clear();
    }
    
    //DataSet的set方法
    public void setDataSet(ArrayList<float[]> dataSet) {  
    	//设置需分组的原始数据集
        this.dataSet = dataSet;  
    }  
    
    //Cluster的get方法
    public ArrayList<ArrayList<float[]>> getCluster() {  
        return cluster;  
    }  
    
    //构造方法传入需要分成的簇数量
    public k_means(int k) {  
        if (k <= 0) {  
            k = 1;  
        }  
        this.k = k;  
    }  
  
    private void init() { //初始化
        m = 0;  
        random = new Random();  
        if (dataSet == null || dataSet.size() == 0) {   
        	System.out.println("数据为空，请输入数据！！！！");
        } else{
        	dataSetLength = dataSet.size();  
        	if (k > dataSetLength) {  
        		k = dataSetLength;  
        	}  
        	center = initCenters();  
        	cluster = initCluster();  
        	jc = new ArrayList<Float>();  
        	}
    }  
  
    private ArrayList<float[]> initCenters() {//初始化中心数据链表，分成多少簇就有多少个中心点	
        ArrayList<float[]> center = new ArrayList<float[]>();  
        int[] randoms = new int[k];  
        boolean flag;  
        int temp = random.nextInt(dataSetLength);  
        randoms[0] = temp;  
        for (int i = 1; i < k; i++) {  
            flag = true;  
            while (flag) {  
                temp = random.nextInt(dataSetLength);  
                int j = 0;  
                while (j < i) {  
                    if (temp == randoms[j]) {  
                        break;  
                    }  
                    j++;  
                }  
                if (j == i) {  
                    flag = false;  
                }  
            }  
            randoms[i] = temp;  
        }   
        for (int i = 0; i < k; i++) {  
            center.add(dataSet.get(randoms[i]));// 生成初始化中心链表  
        }  
        return center;  
    }  
  
 
    private ArrayList<ArrayList<float[]>> initCluster() {//初始化簇集合
        ArrayList<ArrayList<float[]>> cluster = new ArrayList<ArrayList<float[]>>();  
        //ArrayList里面套ArrayList，之前的cluster是Array
        for (int i = 0; i < k; i++) {  
            cluster.add(new ArrayList<float[]>());//开辟空间 创建对象  
        }  
  
        return cluster;  
    }  
  
    
 //需要根据维度改写距离公式，需要改动
    private float distance(float[] element, float[] center) {  
    	//计算两个点之间的距离
        
    	float distance = 0.0f;  
        float x = element[0] - center[0];  
        float y = element[1] - center[1];  
        float z = x * x + y * y;  
        distance = (float) Math.sqrt(z); 
        
    	/*
        float distance = 0.0f;  
        float x = element[0] - center[0];  
        float y = element[1] - center[1];  
        float z = element[2] - center[2];  
        float m = element[3] - center[3];  
        float e = element[4] - center[4];  
        */
        //float n = x * x + y * y + z * z + m * m + e*e;  
        float n = x * x + y * y;  
        distance = (float) Math.sqrt(n); 
        return distance;  
    }  
  
  
    private int minDistance(float[] distance) {//获取坐标，距离集合中最小距离的位置 
        float minDistance = distance[0];  
        int minLocation = 0;  
        for (int i = 1; i < distance.length; i++) {  
            if (distance[i] < minDistance) {  
                minDistance = distance[i];  
                minLocation = i;  
            } 
            else if (distance[i] == minDistance){ // 如果相等，随机返回一个位置    
                if (random.nextInt(10) < 5) { //使用随机数来实现随机返回 
                    minLocation = i;  
                }  
            }  
        }  
        return minLocation;  
    }  
  
 
    private void clusterSet() {//将当前元素放到最小距离中心相关的簇中
        float[] distance = new float[k];  
        //System.out.println(dataSetLength);
        for (int i = 0; i < dataSetLength; i++) {  
            for (int j = 0; j < k; j++) {//计算数据集中，每个数据，到簇中心的距离  
                distance[j] = distance(dataSet.get(i), center.get(j));  
            }  
            int minLocation = minDistance(distance);//找出距离最小的的坐标 
            /*
             * 输出坐标在这里产生
             */
            cluster.get(minLocation).add(dataSet.get(i));//将数据放到对应坐标集合的位置中  
        }  
    }  
 
    private float errorSquare(float[] element, float[] center) {
    	//求两点误差平方的方法 
    	
        float x = element[0] - center[0];  
        float y = element[1] - center[1];  
  
        float errSquare = x * x + y * y;  
  		
    	/*
        float x = element[0] - center[0];  
        float y = element[1] - center[1];  
        float z = element[2] - center[2];  
        float n = element[3] - center[3];  
        float e = element[4] - center[4];  
        */
        //float errSquare = x * x + y * y + z * z + n * n + e * e;  
        return errSquare;  
    }  
  
  
    private void countRule() {//计算误差平方和准则函数方法  
        float jcF = 0;  
        for (int i = 0; i < cluster.size(); i++) {  
            for (int j = 0; j < cluster.get(i).size(); j++) {  
                jcF += errorSquare(cluster.get(i).get(j), center.get(i));  
  
            }  
        }  
        jc.add(jcF);  
    }
    
    private void setNewCenter() { 
    	//设置新的簇中心方法
        for (int i = 0; i < k; i++) {  
            int n = cluster.get(i).size();  
            if (n != 0) {  
                float[] newCenter = { 0, 0 ,0,0,0};  
                for (int j = 0; j < n; j++) {  
                    newCenter[0] += cluster.get(i).get(j)[0];  
                    newCenter[1] += cluster.get(i).get(j)[1];  
                    //newCenter[2] += cluster.get(i).get(j)[2];//补充代码针对三维坐标  
                   // newCenter[3] += cluster.get(i).get(j)[3];// 
                    //newCenter[4] += cluster.get(i).get(j)[4];//补充代码针对五维坐标  
                }  
                // 设置一个平均值  
                newCenter[0] = newCenter[0] / n;  
                newCenter[1] = newCenter[1] / n;  
                //newCenter[2] = newCenter[2] / n;  
                //newCenter[3] = newCenter[3] / n;  
                //newCenter[4] = newCenter[4] / n;  
                center.set(i, newCenter);  
            }  
        }  
    }  
    
    public void printDataArray(ArrayList<float[]> dataArray) { 
    	//打印数据
        for (int i = 0; i < dataArray.size(); i++) {  
        	/*
            System.out.println("print:(" + dataArray.get(i)[0] + "," + dataArray.get(i)[1] +","+
            					dataArray.get(i)[2]+","+dataArray.get(i)[3]+","+dataArray.get(i)[4]+")"); 
            */
            System.out.println("print:(" + dataArray.get(i)[0] + "," + dataArray.get(i)[1] +")");  
            
        }  
        System.out.println("===================================");  
    }  
   
    public void printCenter(){
    	for(int i = 0;i < center.size(); i++){
    		/*
    		System.out.println("k"+i+":("+center.get(i)[0] +","+ center.get(i)[1] +","+
    							center.get(i)[2]+","+center.get(i)[3]+","+center.get(i)[4]+")");
    		*/
    		System.out.println("k"+i+":("+center.get(i)[0] +","+ center.get(i)[1] +")");
    	}
    }
    
    void kmeans() {  
        init();  
        // 循环分组，直到误差不变为止  
        int num = 0;
        while (true) {  
            clusterSet();  
            countRule();   
            // 误差不变了，分组完成  
            if (m != 0) {  
                if (jc.get(m) - jc.get(m - 1) == 0) {  
                    break;  
                }  
            }  
            
            setNewCenter();
            m++;  
            cluster.clear();  
            cluster = initCluster();
            
        }
        
    }  
}

k-means测试算法主方法

package kmeans;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.Iterator;

import Features.FirstProcessing;
import MySQL.ChaRu;
import MySQL.ChaZhao;
/*
 * 查找特征向量，计算特征值并更新表中特征值
 */
public class main01 {

	public static void main(String[] args) {
		//集合中以数组为单位存储，每个数组中存着？维坐标
		
        ArrayList<float[]> dataSet=new ArrayList<float[]>();  
		Connection conn1 = ChaZhao.getconn();
		dataSet = ChaZhao.select(conn1);
        ChaZhao.close();
        
        Connection conn2 = ChaRu.getconn();
        
        
        Test_k_means.fuzhi1();
        Test_k_means.fuzhi2();
        Test_k_means.fuzhi3();
        Test_k_means.fuzhi4();
        
		Iterator it = dataSet.iterator();
		float[] data; 
		int[] k = new int[4] ;
		float[] data1 = new float[3];
		float[] data2 = new float[5];
		float[] data3 = new float[5];
		float[] data4 = new float[2];
		
		int flag = 4;
		
		while(it.hasNext()){
			 data = (float[]) it.next();
			 for(int i=2,j=0;i<5;i++,j++){
				 data1[j] = data[i];
			 }
			 for(int i=5,j=0;i<10;i++,j++){
				 data2[j] = data[i];
			 }
			 for(int i=10,j=0;i<15;i++,j++){
				 data3[j] = data[i];
			 }
			 for(int i=15,j=0;i<17;i++,j++){
				 data4[j] = data[i];
			 }
			 k[0] = Test_k_means.getkt(16, 3, data1, Test_k_means.center1);
			 k[1] = Test_k_means.getkt(14, 5, data2, Test_k_means.center2);
			 k[2] = Test_k_means.getkt(10, 5, data3, Test_k_means.center3);
			 k[3] = Test_k_means.getkt(10, 2, data4, Test_k_means.center4);
			 
			 ChaRu.insert(conn2,(int)data[0],(int)data[1],k,flag);
		}
		
		
		/*
		Test_k_means.fuzhi1();
		//float[] data1 = {(float) -0.015048233299745577,(float) 0.009071020859739883,(float) -1.5238239430724612};
		float[] data1 = {(float) -0.037566654703485844,(float) -0.013700087129106654,(float) 1.561930435068692};
		int k = Test_k_means.getkt(16, 3, data1, Test_k_means.center1);
		System.out.println("k="+k);
		*/
		
		
		
		ChaRu.close();
	}
}

测试用的k-means方法类

package kmeans;

import java.util.ArrayList;
import java.util.Random;

public class Test_k_means {
	static ArrayList<float[]> center1 = new ArrayList<float[]>();
	static ArrayList<float[]> center2 = new ArrayList<float[]>();
	static ArrayList<float[]> center3 = new ArrayList<float[]>();
	static ArrayList<float[]> center4 = new ArrayList<float[]>();
	
	static float[] ct1 = {(float) -0.36549547,(float) -0.19680291,(float) 1.3342463}; 
	static float[] ct2 = {(float) -0.26852378,(float) -0.03381751,(float) 1.0894369}; 
	static float[] ct3 = {(float) -0.16302495,(float) -0.19998512,(float) 0.329478}; 
	static float[] ct4 = {(float) -0.87378883,(float) -0.32445675,(float) 1.2311304}; 
	static float[] ct5 = {(float) -0.14907424,(float) -0.066931404,(float) 1.442742}; 
	static float[] ct6 = {(float) -0.11564034,(float) -0.28077325,(float) -0.4544813}; 
	static float[] ct7 = {(float) -1.2184348,(float) -0.24974133,(float) 1.1926856}; 
	static float[] ct8 = {(float) -0.59237033,(float) -0.18715477,(float) 1.1560123}; 
	static float[] ct9 = {(float) -0.052315436,(float) -0.15902035,(float) -1.2516569}; 
	static float[] ct10 = {(float) -0.715085,(float) -0.34694636,(float) -1.4817164}; 
	static float[] ct11 = {(float) -0.0319672,(float) 0.123795904,(float) 1.205883}; 
	static float[] ct12 = {(float) -0.059195306,(float) -0.06899053,(float) -1.4732516}; 
	static float[] ct13 = {(float) -0.06828567,(float) -0.27861646,(float) -0.9786703}; 
	static float[] ct14 = {(float) 0.06383231,(float) 0.06881439,(float) 1.4630694}; 
	static float[] ct15 = {(float) 0.38046,(float) 0.086474285,(float) -1.3731346}; 
	static float[] ct16 = {(float) -0.6380327,(float) -0.3705011,(float) 1.3980854}; 
	
	static float[] ctt1 = {(float) 19.124573,(float) 19.942137,(float) 20.352076,(float) 20.683052,(float) 20.818832};
	static float[] ctt2 = {(float) 19.998987,(float) 20.386002,(float) 20.081959,(float) 20.245035,(float) 20.507982};
	static float[] ctt3 = {(float) 18.835457,(float) 18.02001,(float) 18.01416,(float) 18.275656,(float) 18.509668};
	static float[] ctt4 = {(float) 17.78561,(float) 17.379637,(float) 17.538177,(float) 17.822744,(float) 17.819603};
	static float[] ctt5 = {(float) 18.246813,(float) 18.072685,(float) 18.26946,(float) 18.531868,(float) 18.765728};
	static float[] ctt6 = {(float) 18.83908,(float) 18.665567,(float) 18.598078,(float) 18.782398,(float) 19.004646};
	static float[] ctt7 = {(float) 19.299448,(float) 19.514294,(float) 19.550995,(float) 19.709429,(float) 19.876785};
	static float[] ctt8 = {(float) 0.0,(float) 0.0,(float) 0.0,(float) 0.0,(float) 0.0};
	static float[] ctt9 = {(float) 19.147707,(float) 19.63055,(float) 18.349651,(float) 16.903051,(float) 0.0};
	static float[] ctt10= {(float) 18.181501,(float) 0.0,(float) 0.0,(float) 0.0,(float) 0.0};
	static float[] ctt11= {(float) 18.396076,(float) 18.365593,(float) 18.652214,(float) 18.946945,(float) 19.146654};
	static float[] ctt12= {(float) 17.994272,(float) 17.755035,(float) 17.938347,(float) 18.166737,(float) 18.32163};
	static float[] ctt13= {(float) 18.771173,(float) 18.516142,(float) 10.54976,(float) 0.0,(float) 0.0};
	static float[] ctt14= {(float) 18.899158,(float) 19.003944,(float) 19.06351,(float) 19.24987,(float) 19.461609};
	
	
	static float[] cttt1 = {(float) 1.5396874,(float) 1.5743555,(float) 1.5751604,(float) 1.5739932,(float) 1.5768001};
	static float[] cttt2 = {(float) 0.779205,(float) 1.5462575,(float) 1.5648361,(float) 1.5776663,(float) 1.5919755};
	static float[] cttt3 = {(float) 1.6717223,(float) 1.8396813,(float) 1.8731005,(float) 1.8762144,(float) 1.8320376};
	static float[] cttt4 = {(float) 0.67196554,(float) 0.7107125,(float) 0.70706266,(float) 0.7159178,(float) 0.7500223};
	static float[] cttt5 = {(float) 2.1454394,(float) 2.1112318,(float) 2.0890515,(float) 2.0410147,(float) 1.9534185};
	static float[] cttt6 = {(float) 2.1100385,(float) 1.7329234,(float) 1.639594,(float) 1.5791867,(float) 1.5464628};
	static float[] cttt7 = {(float) 1.1653012,(float) 1.22876,(float) 1.3362818,(float) 1.3627602,(float) 1.4075104};
	static float[] cttt8 = {(float) 0.84546506,(float) 0.8630724,(float) 0.8741382,(float) 0.88455427,(float) 0.91003066};
	static float[] cttt9 = {(float) 0.9648166,(float) 1.0143458,(float) 1.0654656,(float) 1.113567,(float) 1.1450683};
	static float[] cttt10= {(float) 2.333743,(float) 2.3290477,(float) 2.331421,(float) 2.3287027,(float) 2.3180618};


	static float[] ctttt1 = {(float) 5.026384,(float) -23.825523};
	static float[] ctttt2 = {(float) 17.161247,(float) 0.46476126};
	static float[] ctttt3 = {(float) 3.3841784,(float) 7.9062724};
	static float[] ctttt4 = {(float) 11.013154,(float) -1.2864549};
	static float[] ctttt5 = {(float) 6.640934,(float) 24.923754};
	static float[] ctttt6 = {(float) 8.692141,(float) -19.800547};
	static float[] ctttt7 = {(float) 12.416968,(float) -23.395496};
	static float[] ctttt8 = {(float) 10.311456,(float) -14.101471};
	static float[] ctttt9 = {(float) 3.5202806,(float) -13.321848};
	static float[] ctttt10= {(float) 5.50634,(float) -4.683569};

	public static void fuzhi1(){
		center1.add(ct1);center1.add(ct2);center1.add(ct3);center1.add(ct4);
		center1.add(ct5);center1.add(ct6);center1.add(ct7);center1.add(ct8);
		center1.add(ct9);center1.add(ct10);center1.add(ct11);center1.add(ct12);
		center1.add(ct13);center1.add(ct14);center1.add(ct15);center1.add(ct16);
	}

	
	public static void fuzhi2(){
		center2.add(ctt1);center2.add(ctt2);center2.add(ctt3);center2.add(ctt4);center2.add(ctt5);center2.add(ctt6);center2.add(ctt7);
		center2.add(ctt8);center2.add(ctt9);center2.add(ctt10);center2.add(ctt11);center2.add(ctt12);center2.add(ctt13);center2.add(ctt14);
	}
	
	public static void fuzhi3(){
		center3.add(cttt1);center3.add(cttt2);center3.add(cttt3);center3.add(cttt4);center3.add(cttt5);
		center3.add(cttt6);center3.add(cttt7);center3.add(cttt8);center3.add(cttt9);center3.add(cttt10);
	}
	
	public static void fuzhi4(){
		center4.add(ctttt1);center4.add(ctttt2);center4.add(ctttt3);center4.add(ctttt4);center4.add(ctttt5);
		center4.add(ctttt6);center4.add(ctttt7);center4.add(ctttt8);center4.add(ctttt9);center4.add(ctttt10);
	}
	
	public static void clear(){
		center1.clear();
		center2.clear();
		center3.clear();
		center4.clear();
		
	}
	
    public static float distance(float[] element, float[] center,int k) {  
    	//计算两个点之间的距离
    	float n = 0;
        float distance = 0.0f;  
        for(int i=0;i<k;i++){
        	float x = element[i] - center[i];  
        	n = n + x*x;  
        }  
        distance = (float) Math.sqrt(n); 
        return distance;  
    }  
    
    public static int minDistance(float[] distance) {//获取坐标，距离集合中最小距离的位置 
    	Random random = new Random();
    	float minDistance = distance[0];  
        int minLocation = 0;  
        for (int i = 1; i < distance.length; i++) {  
            if (distance[i] < minDistance) {  
                minDistance = distance[i];  
                minLocation = i;  
            } 
            else if (distance[i] == minDistance){ // 如果相等，随机返回一个位置    
                if (random.nextInt(10) < 5) { //使用随机数来实现随机返回 
                    minLocation = i;  
                }  
            }  
        }  
        return minLocation;  
    }     
    
    /*
     * k 簇数
     * kk 维数
     */
    public static int getkt(int k,int kk,float[] data,ArrayList<float[]> center) {//将当前元素放到最小距离中心相关的簇中
    	float[] dataSet = data;
        float[] distance = new float[k];  
            for (int j = 0; j < k; j++) {//计算数据集中，每个数据，到簇中心的距离  
                distance[j] = distance(dataSet, center.get(j),kk);  
            }   
            int minLocation = minDistance(distance);//找出距离最小的的坐标 
            
            return minLocation;
    }   
}
c_Qyaya
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【手势识别】基于matlab k-means聚类手势识别【含Matlab源码 386期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
02-25 2550
k-means聚类手势识别 完整的代码，方可运行；可提供运行操作视频！适合小白！
【图像识别】基于k-means聚类实现手势识别matlab代码
qq_59747472的博客
11-07 579
1 简介 k-means算法是一种聚类算法，所谓聚类，即根据相似性原则，将具有较高相似度的数据对象划分至同一类簇，将具有较高相异度的数据对象划分至不同的类簇。聚类与分类最大的区别在于，聚类过程为无监督过程，即待处理数据对象没有任何先验知识，而分类过程为有监督过程，即存在有先验知识的训练数据集。k-means算法中的 k代表类簇的个数，means代表类簇内数据对象的均值（这种均值是一种对类簇中心的描述），因此 k-means 算法又称为 k-均值算法。k-means 算法是一种基于划分的聚类算法，以距离作为
基于HMM的动态手势识别
08-23
基于HMM的动态手势识别
语音识别基于matlab隐马尔可夫模型（HMM）孤立字语音识别【含Matlab源码 576期】.zip
12-27
CSDN海神之光上传的全部代码均可运行，亲测可用，尽我所能，为你服务； 1、代码压缩包内容 主函数：hmm_recog.m； 调用函数：其他m文件； 语音信号，其格式为MP4； 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到 Matlab的当前文件夹中； 步骤二：双击打开hmm_recog.m文件；（若有其他m文件，无需运行） 步骤三：点击运行，等程序运行完得到结果； 4、语音处理系列仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 语音处理系列程序定制或科研合作方向：语音隐藏、语音压缩、语音识别、语音去噪、语音评价、语音加密、语音合成、语音分析、语音分离、语音处理、语音编码、音乐检索、特征提取、声源定位、情感识别、语音采集播放变速等；
HMM模型——隐含马尔科夫模型【详细分析+图】
MyHeartWillGoOn
12-07 4735
文章目录HMM含义作用 HMM 含义 HMM(Hidden Markov Model), 中文称作隐含马尔科夫模型, 因俄国数学家马尔可夫而得名. 它一般以文本序列数据为输入, 以该序列对应的隐含序列为输出. 什么是隐含序列 序列数据中每个单元包含的隐性信息, 这些隐性信息之间也存在一定关联 EG： content = "他喜欢看动画片" # 对文本进行分词处理 arr = ["他","喜欢","看","动画片"] # 每个词对应的隐含序列为 hidden_sequence = ["n","v"
【机器学习算法】隐马尔可夫模型HMM（一）
尊新必威的博客
04-29 493
一、马尔可夫性质 设{X(t),t∈T}\{X(t), t ∈ T\}{X(t),t∈T}是一个随机过程，E为其状态空间，若对于任意的t1<t2<...<tn<tt_1<t_2< ...<t_n<tt1​<t2​<...<tn​<t，任意的x1,x2,...,xn,x∈Ex_1,x_2,...,x_n,x∈Ex1​,x2​,...,xn​,x∈E，随机变量X(t)X(t)X(t)在已知变量X(t1)=x1,...,X(tn)=xnX(t
[zz] 隐马尔可夫模型(HMM)简介
Xianling Mao的专栏
05-15 4322
这篇文章是我看过的关于HMM最好的文章之一，值得仔细揣摩，这篇文章里面有一些错误，如计算和表达，需要注意。隐马尔可夫模型(HMM)简介http://xiaofeng1982.blog.163.com/blog/static/315724582009824103618623/  隐马尔可夫模型(HMM)简介请各位读者深吸一口气……呼…… 开始…
HMM动态手势识别1——LeapMotion
c_Qyaya的博客
03-05 720
数据接收的主类 package MainMethord; import java.io.IOException; import com.leapmotion.leap.Controller; import Features.FrameListener; public class MTest { public static void main(String[] args) { Con...
基于HMM的手势识别
11-16
文章是使用HMM方法对手势进行识别，初学者可以参考学习一下。
语音识别学习日志 2019-7-14 语音识别基础知识准备3 {Kmean算法分析与HMM(Hidden Markov Model)模型}
Believe in the Future的专栏
07-14 442
Kmean算法 聚类算法 对于"监督学习"(supervised learning)，其训练样本是带有标记信息的，并且监督学习的目的是：对带有标记的数据集进行模型学习，从而便于对新的样本进行分类。而在“无监督学习”(unsupervised learning)中，训练样本的标记信息是未知的，目标是通过对无标记训练样本的学习来揭示数据的内在性质及规律，为进一步的数据分析提供基础。对于无监督学习，...
【图像识别】基于k-means聚类的手势识别matlab 源码.md
08-18
【图像识别】基于k-means聚类的手势识别matlab 源码.md
k-means聚类、EM聚类、模糊聚类比较
01-02
PPT较详细的讲述了k-means、em聚类、模糊聚类等不同聚类的算法原理和过程
基于HMM-FNN模型的复杂动态手势识别
02-23
复杂动态手势识别是利用视频手势进行人机交互的关键问题.提出一种HMM-FNN模型结构.它整合了隐马尔可夫模型对时序数据的建模能力与模糊神经网络的模糊规则构建与推理能力,并将其应用到复杂动态手势的识别中.复杂动态...
NER-CRF-HMM-master_HMM_HMM-CRF用于命名实体识别_语音识别_
10-02
HMM以及CRF用于自然语音处理中的命名识别
基于不同预测算法的手势识别比较分析-研究论文
05-20
我们正在使用手势识别的动态时间扭曲方法。 我们解释了一种有效的手势识别方法。 我们还使用了简单的K-NN分类器。 在这种方法中，我们使用了DTW（动态时间包装）对齐方式。 我们使用不同的算法和方法来解释有关手势...
时序分析：HMM模型（状态空间）
热门推荐
wishchinYang的专栏
12-18 1万+
关于HMM模型：隐马尔科夫模型 和动态贝叶斯网络
HMM隐马尔科夫算法(Hidden Markov Algorithm)初探
weixin_34370347的博客
10-14 673
1. HMM背景 0x1：概率模型 - 用概率分布的方式抽象事物的规律 机器学习最重要的任务，是根据一些已观察到的证据（例如训练样本）来对感兴趣的未知变量（例如类别标记）进行估计和推测。 概率模型（probabilistic model）提供了一种描述框架，将学习任务归结于计算未知变量的概率分布，而不是直接得到一个确定性的结果。 在概率模型中，利用已知变量推测未知变量的分布称为“推断（in...
HMM学习范例
vcmman的专栏
02-24 4103
翻译自：http://www.comp.leeds.ac.uk/roger/HiddenMarkovModels/html_dev/main.html 转载自： http://www.52nlp.cn/hmm-learn-best-practices-one-introduction 隐马尔科夫模型（HMM）依然是读者访问“我爱自然语言处理”的一个热门相关关键词，我曾在《HMM学习
HMM动态手势识别5——HMM训练算法2
c_Qyaya的博客
03-05 269
HMM训练时储存特征值的方法 package HMM_test01; public class TeZhengZhi { static double[] pi11 = {-4.387067629347257,-2.009320836866209,-1.5315456606012958, -1.5345456785034912,-1.0845325292675625,-2.48089234...
载波恢复算法——Viterbi-Viterbi算法 VV算法
最新发布
07-28
Viterbi算法（也称为Viterbi-Viterbi算法或VV算法）是一种用于解码隐马尔可夫模型（Hidden Markov Model，HMM）的动态规划算法。在通信领域中，Viterbi算法常用于载波恢复（Carrier Recovery）过程中。 在载波恢复...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值