dtw

最新推荐文章于 2021-05-09 20:52:02 发布
最新推荐文章于 2021-05-09 20:52:02 发布
阅读量197 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/non_hercules/article/details/98076485
版权

/**
* (c) Daniel Lemire, 2008
*This C++ library implements fast nearest-neighbor retrieval under the dynamic time warping (DTW). 
* This library includes the dynamic programming solution, a fast implementation of the LB_Keogh
*  lower bound, as well as a improved lower bound called LB_Improved. This library was used to show
*  that LB_Improved can be used to retrieve nearest neighbors three times on several data sets
* including random walks time series or shape time series.
*
* See the classes LB_Keogh and LB_Improved for usage.
* 
* Time series are represented using STL vectors.
*/

#ifndef DTW
#define DTW

#include <iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include <deque>
#include <cassert>
#include <sstream>

typedef double floattype;
typedef unsigned int uint;
using namespace std;

class MathUtil {
  public:
    static inline int min (int x, int y ) { return x < y ? x : y;}
    static inline int max (int x, int y ) { return x > y ? x : y;}
};

/**
* You do not need this class, used by LB_Keogh and LB_Improved later.
* It computes the DTW using dynamic programmming.
*/    
class dtw {
    public:
        
enum{ verbose = false, 
   vverbose = false, INF = 100000000, fast=true};
static inline double max (double x, double y ) { return x > y ? x : y;}
static inline double min (double x, double y ) { return x < y ? x : y;}

    dtw(uint n, uint constraint): mGamma(n,vector<double>(n,INF)),mN(n),mConstraint(constraint) {        
    }
    /*
    * hardcoded l1 norm (for speed)
    */
    inline double fastdynamic(const vector<double> &  v, const vector<double> & w) {
        if(! fast) return dynamic(v,w,mConstraint,1);
        assert(static_cast<int>(v.size()) == mN);
        assert(static_cast<int>(w.size()) == mN);
        assert(static_cast<int>(mGamma.size()) == mN);
        double Best(INF);
        for (int i = 0; i < mN;++i) {
            assert(static_cast<int>(mGamma[i].size()) == mN);
            for (int j = max(0,i-mConstraint); j < min(mN,i+mConstraint+1);++j) {
                Best = INF;
                if(i>0) Best = mGamma[i-1][j];
                if(j>0) Best = min(Best, mGamma[i][j-1]);
                if( (i > 0) && (j > 0) )
                 Best = min(Best, mGamma[i-1][j-1]);
                if((i==0) && (j==0))
                  mGamma[i][j] = fabs(v[i]-w[j]);
                else 
                  mGamma[i][j] = Best + fabs(v[i]-w[j]);                   
            }
        }
         return mGamma[mN-1][mN-1];
    }

    vector<vector<double> > mGamma;

    int mN, mConstraint;

    static inline double dynamic(const vector<double> &  v, const vector<double> & w, 
      int constraint=INF, int p=2) {
          assert(v.size() == w.size());
        int n ( v.size() );
        vector<vector<double> > gamma(n, vector<double>(n,0.0));
        for (int i = 0; i < n;++i) {
            for (int j = 0; j < n;++j) {
                if(abs(i-j) > constraint) {
                  gamma[i][j] = INF; continue;
                }
                vector<double> previous(0);
                if(i>0) previous.push_back(gamma[i-1][j]);
                if(j>0) previous.push_back(gamma[i][j-1]);
                if( (i > 0) && (j > 0) )
                 previous.push_back(gamma[i-1][j-1]);
                double smallest = *min_element(previous.begin(),previous.end());
                if (p != INF)
                  gamma[i][j] = pow(fabs(v[i]-w[j]),p)+smallest;
                else
                  gamma[i][j] = max(fabs(v[i] - w[j]), smallest);
                   
            }
        }
        if(p != INF) 
         return pow(gamma[n-1][n-1],1.0/p);
        else
         return gamma[n-1][n-1];
      }
};

/**
* You do not need this function, used by LB_Keogh and LB_Improved later.
*/
void computeEnvelope(const vector<floattype> & array, uint constraint, vector<floattype> & maxvalues, vector<floattype> & minvalues) {
        uint width = 1+  2 * constraint;
        deque<int> maxfifo, minfifo;
        maxfifo.push_back(0);
        minfifo.push_back(0);
        for(uint i = 1; i < array.size(); ++i) {
          if(i >=constraint+1) {
            maxvalues[i-constraint-1] = array[maxfifo.front()];
            minvalues[i-constraint-1] = array[minfifo.front()];
          }
          if(array[i] > array[i-1]) { //overshoot
            maxfifo.pop_back();
            while(maxfifo.size() > 0) {
              if(array[i] <= array[maxfifo.back()]) break;
              maxfifo.pop_back();
            }
          } else {
            minfifo.pop_back();
            while(minfifo.size() > 0) {
              if(array[i] >= array[minfifo.back()]) break;
              minfifo.pop_back();
            }
          }  
          maxfifo.push_back(i);
          minfifo.push_back(i);
         if(i==  width+maxfifo.front()) maxfifo.pop_front();
         else if(i==  width+minfifo.front()) minfifo.pop_front();
        }
        for(uint i = array.size(); i <= array.size() + constraint; ++i) {
              maxvalues[i-constraint-1] = array[maxfifo.front()];
              minvalues[i-constraint-1] = array[minfifo.front()];
              if(i-maxfifo.front() >= width) maxfifo.pop_front();
              if(i-minfifo.front() >= width) minfifo.pop_front();
        }
}

class NearestNeighbor {
    public:
        NearestNeighbor(const vector<double> &  v, int constraint) : mDTW(v.size(),constraint) {}
        virtual double test(const vector<double> & candidate) {return 0;}//= 0;
        virtual double getLowestCost() {return 0;}
        virtual ~NearestNeighbor() {};
        virtual int getNumberOfDTW(){return 0;}
        virtual int getNumberOfCandidates(){return 0;}
        dtw mDTW;
};

class NaiveNearestNeighbor :  public NearestNeighbor {
    public:
    NaiveNearestNeighbor(const vector<double> &  v, int constraint) : NearestNeighbor(v,constraint), lb_keogh(0),full_dtw(0),
     V(v),
    bestsofar(dtw::INF) {
    }
    
    double test(const vector<double> & candidate) {
        ++lb_keogh;++full_dtw;
        const double trueerror = mDTW.fastdynamic(V,candidate);//,mConstraint,1);
        if(trueerror < bestsofar) bestsofar = trueerror;
        return bestsofar;
    }
    
    
    void resetStatistics() {
        lb_keogh = 0;
        full_dtw = 0;
    }
    double getLowestCost(){return bestsofar;}
    
    int getNumberOfDTW(){return full_dtw;}
    
    
    int getNumberOfCandidates(){return lb_keogh;}
    
    
    private:
    int lb_keogh;
    int full_dtw;
    
    const vector<double>   V;
    double bestsofar;
    
};

/**
* Usage: create the object using the time series you want to match again the
* database and some DTW time constraint parameter. Then repeatedly apply
* the test function on the various candidates. The function returns the
* matching cost with the best candidate so far. By keeping track of when
* the cost was lowered, you can find the nearest neighbor in a database.
*
* Only the l1 norm is used.
*/
class LB_Keogh :  public NearestNeighbor{
    public:
    LB_Keogh(const vector<double> &  v, int constraint) : NearestNeighbor(v,constraint), lb_keogh(0), full_dtw(0), V(v), mConstraint(constraint),  
    bestsofar(dtw::INF), U(V.size(),0), L(V.size(),0) {
        assert(mConstraint>=0);
        assert(mConstraint<static_cast<int>(V.size()));
        computeEnvelope(V,mConstraint,U,L);
    }
    
    double justlb(const vector<double> & candidate) {
        double error (0.0);
        for(uint i = 0; i < V.size();++i) {
            if(candidate[i] > U[i]) 
              error += candidate[i] - U[i];
            else if(candidate[i] < L[i])
              error += L[i] - candidate[i];
        }
        return error;
    }
    double test(const vector<double> & candidate) {
        ++lb_keogh;
        double error (0.0);
        for(uint i = 0; i < V.size();++i) {
            if(candidate[i] > U[i]) 
              error += candidate[i] - U[i];
            else if(candidate[i] < L[i])
              error += L[i] - candidate[i];
        }
        //cout << "lb keogh = "<<error<<endl;
        if(error < bestsofar) {
            ++full_dtw;
            const double trueerror = mDTW.fastdynamic(V,candidate);//,mConstraint,1);
            if(trueerror < bestsofar) bestsofar = trueerror;
        }
        return bestsofar;
    }
    
    
    int getNumberOfDTW(){return full_dtw;}
    
    
    int getNumberOfCandidates(){return lb_keogh;}
    
    
    double getLowestCost(){return bestsofar;}
    
    void resetStatistics() {
        lb_keogh = 0;
        full_dtw = 0;
    }
    
    private:
    
    int lb_keogh;
    int full_dtw;
    const vector<double>   V; 
    int mConstraint;
    double bestsofar;
    vector<double>   U; 
    vector<double>   L; 
    
};


class LB_KeoghEarly :  public NearestNeighbor{
    public:
    LB_KeoghEarly(const vector<double> &  v, int constraint) : NearestNeighbor(v,constraint), lb_keogh(0), full_dtw(0), V(v), mConstraint(constraint),  
    bestsofar(dtw::INF), U(V.size(),0), L(V.size(),0) {
        assert(mConstraint>=0);
        assert(mConstraint<static_cast<int>(V.size()));
        computeEnvelope(V,mConstraint,U,L);
    }
    
    double test(const vector<double> & candidate) {
        ++lb_keogh;
        double error (0.0);
        for(uint i = 0; i < V.size();++i) {
            if(candidate[i] > U[i]) 
              error += candidate[i] - U[i];
            else if(candidate[i] < L[i])
              error += L[i] - candidate[i];
            if(error > bestsofar) return bestsofar;
        }
            ++full_dtw;
            const double trueerror = mDTW.fastdynamic(V,candidate);//,mConstraint,1);
            if(trueerror < bestsofar) bestsofar = trueerror;
        return bestsofar;
    }
    
    
    int getNumberOfDTW(){return full_dtw;}
    
    
    int getNumberOfCandidates(){return lb_keogh;}
    
    
    double getLowestCost(){return bestsofar;}
    
    void resetStatistics() {
        lb_keogh = 0;
        full_dtw = 0;
    }
    
    private:
    
    int lb_keogh;
    int full_dtw;
    const vector<double>   V; 
    int mConstraint;
    double bestsofar;
    vector<double>   U; 
    vector<double>   L; 
    
};


/**
* Usage (same as LB_Keogh): create the object using the time series you want to match again the
* database and some DTW time constraint parameter. Then repeatedly apply
* the test function on the various candidates. The function returns the
* matching cost with the best candidate so far. By keeping track of when
* the cost was lowered, you can find the nearest neighbor in a database.
*
* Only the l1 norm is used.
*/
class LB_Improved : public  NearestNeighbor{
    public:
    LB_Improved(const vector<double> &  v, int constraint) : NearestNeighbor(v,constraint), lb_keogh(0), full_dtw(0), V(v), buffer(v), mConstraint(constraint),  
    bestsofar(dtw::INF), U(V.size(),0), L(V.size(),0), U2(V.size(),0), L2(V.size(),0) {
        assert(mConstraint>=0);
        assert(mConstraint<static_cast<int>(V.size()));
        computeEnvelope(V,mConstraint,U,L);
    }
    
    void resetStatistics() {
        lb_keogh = 0;
        full_dtw = 0;
    }
    
    
    
    double justlb(const vector<double> & candidate) {
        double error (0.0);
        buffer = candidate;
        for(uint i = 0; i < V.size();++i) {
            if(candidate[i] > U[i]) 
              error += candidate[i] - U[i];
            else if(candidate[i] < L[i])
              error += L[i] - candidate[i];
        }
        computeEnvelope(buffer,mConstraint,U2,L2);
        for(uint i = 0; i < V.size();++i) {
                if(V[i] > U2[i]) { 
                      error += V[i] - U2[i];
                } else if(V[i] < L2[i]) {
                      error += L2[i] - V[i];
                }
        }
        return error;
    }
    
    
    double test(const vector<double>  &candidate) {
        //memcpy(&buffer[0], &candidate[0],buffer.size()*sizeof(double));// = candidate;
        //buffer = candidate;
        //vector<double> & buffer(candidate);// no need for a copy
        ++lb_keogh;
        double error (0.0);
        for(uint i = 0; i < V.size();++i) {
            const double & cdi (candidate[i]); 
            if(cdi > U[i]) { 
              error += cdi - (buffer[i] = U[i]);
            } else if(cdi < L[i]) {
              error += (buffer[i] = L[i]) - cdi;
            } else buffer[i] = cdi;
        }
        if(error < bestsofar) {
            computeEnvelope(buffer,mConstraint,U2,L2);
            //env.compute(buffer,mConstraint,U2,L2);
            for(uint i = 0; i < V.size();++i) {
                if(V[i] > U2[i]) { 
                      error += V[i] - U2[i];
                } else if(V[i] < L2[i]) {
                      error += L2[i] - V[i];
                }
            }
            if(error < bestsofar) {
                ++full_dtw;
                const double trueerror = mDTW.fastdynamic(V,candidate);//,mConstraint,1);
                if(trueerror < bestsofar) bestsofar = trueerror;
            }
        }
        return bestsofar;
    }
    
    /**
    * for plotting purposes
    */
    string dumpTextDescriptor(const vector<double>  &candidate) {
        //memcpy(&buffer[0], &candidate[0],buffer.size()*sizeof(double));// = candidate;
        buffer = candidate;
        //vector<double> & buffer(candidate);// no need for a copy
        ++lb_keogh;
        double error (0.0);
        for(uint i = 0; i < V.size();++i) {
            if(candidate[i] > U[i]) { 
              error += candidate[i] - U[i];
              buffer[i] = U[i];
            } else if(candidate[i] < L[i]) {
              error += L[i] - candidate[i];
              buffer[i] = L[i];
            } 
            assert((buffer[i]== L[i]) or (buffer[i] == U[i]) or (buffer[i] == candidate[i]));
            
        }
        vector<double> lbimprovedarray;
        computeEnvelope(buffer,mConstraint,U2,L2);
        for(uint i = 0; i < V.size();++i) {
                if(V[i] > U2[i]) { 
                      error += V[i] - U2[i];
                      lbimprovedarray.push_back(U2[i]);
                } else if(V[i] < L2[i]) {
                      error += L2[i] - V[i];
                      lbimprovedarray.push_back(L2[i]);
                } else 
                    lbimprovedarray.push_back(V[i]);

        }
        stringstream ss;
        for(uint k = 0; k <V.size(); ++k) {
            assert((lbimprovedarray[k]== L2[k]) or (lbimprovedarray[k] == U2[k]) or (lbimprovedarray[k] == V[k]));
            assert((buffer[k]== L[k]) or (buffer[k] == U[k]) or (buffer[k] == candidate[k]));
            ss<<k<<" "<<V[k]<<" "<<candidate[k]<<" "<<buffer[k]<<" "<<lbimprovedarray[k]<<" "<<L[k]<<" "<<U[k]<<" "<<L2[k]<<" "<<U2[k]<<endl;
        }
        //string ans;
        //ss>>ans;
        ///cout<<ss.str()<<endl;
        return ss.str();
    }

    int getNumberOfDTW(){return full_dtw;}
    
    int getNumberOfCandidates(){return lb_keogh;}
    
    double getLowestCost(){return bestsofar;}
    private:
    
    int lb_keogh;
    int full_dtw;
    const vector<double>   V;
    vector<double> buffer;  
    int mConstraint;
    double bestsofar;
    vector<double>   U;  
    vector<double>   L;  
    vector<double>   U2;  
    vector<double>   L2;  

};

class LB_ImprovedEarly : public  NearestNeighbor{
    public:
    LB_ImprovedEarly(const vector<double> &  v, int constraint) : NearestNeighbor(v,constraint), lb_keogh(0), full_dtw(0), V(v), buffer(v), mConstraint(constraint),  
    bestsofar(dtw::INF), U(V.size(),0), L(V.size(),0), U2(V.size(),0), L2(V.size(),0) {
        assert(mConstraint>=0);
        assert(mConstraint<static_cast<int>(V.size()));
        computeEnvelope(V,mConstraint,U,L);
    }
    
    void resetStatistics() {
        lb_keogh = 0;
        full_dtw = 0;
    }

    double test(const vector<double>  &candidate) {
        //memcpy(&buffer[0], &candidate[0],buffer.size()*sizeof(double));// = candidate;
        //buffer = candidate;
        //vector<double> & buffer(candidate);// no need for a copy
        ++lb_keogh;
        double error (0.0);
        for(uint i = 0; i < V.size();++i) {
            const double & cdi (candidate[i]); 
            if(cdi > U[i]) { 
              error += cdi - (buffer[i] = U[i]);
            } else if(cdi < L[i]) {
              error += (buffer[i] = L[i]) - cdi;
            } else buffer[i] = cdi;
            if(error>bestsofar) return bestsofar;
        }
        if(error < bestsofar) {
            computeEnvelope(buffer,mConstraint,U2,L2);
            //env.compute(buffer,mConstraint,U2,L2);
            for(uint i = 0; i < V.size();++i) {
                if(V[i] > U2[i]) { 
                      error += V[i] - U2[i];
                } else if(V[i] < L2[i]) {
                      error += L2[i] - V[i];
                }
                if(error>bestsofar) return bestsofar;

            }
            if(error < bestsofar) {
                ++full_dtw;
                const double trueerror = mDTW.fastdynamic(V,candidate);//,mConstraint,1);
                if(trueerror < bestsofar) bestsofar = trueerror;
            }
        }
        return bestsofar;
    }

    
    int getNumberOfDTW(){return full_dtw;}
    
    int getNumberOfCandidates(){return lb_keogh;}
    
    double getLowestCost(){return bestsofar;}
    private:
    
    int lb_keogh;
    int full_dtw;
    const vector<double>   V;
    vector<double> buffer;  
    int mConstraint;
    double bestsofar;
    vector<double>   U;  
    vector<double>   L;  
    vector<double>   U2;  
    vector<double>   L2;  

};

void piecewiseSumReduction(const vector<floattype> & array, vector<floattype> & out) {
    // the length of out gives out the desired output length 
    assert(out.size()>0);
    const uint sizeofpieces = array.size()/out.size();
    assert(sizeofpieces>0);
    //sum_up<floattype> s;
    for(uint k = 0; k<out.size()-1;++k) {
        //s.reset();
        out[k] = 0;
        for(uint j = k*sizeofpieces; j < (k+1)*sizeofpieces; ++j)
          out[k] += array[j];
    }
    uint k=out.size()-1;
    out[k] = 0;
    for(uint j = k*sizeofpieces; j < array.size(); ++j)
          out[k] += array[j];
}


/**
* for debugging purposes
*/
class DimReducedLB_Keogh :  public NearestNeighbor{
    public:
    DimReducedLB_Keogh(const vector<double> &  v, int constraint, int reduced) : NearestNeighbor(v,constraint), lb_keogh(0), full_dtw(0), V(v), mConstraint(constraint),  
    bestsofar(dtw::INF), U(V.size(),0), L(V.size(),0),Ured(reduced,0),Lred(reduced) {
        assert(mConstraint>=0);
        assert(mConstraint<static_cast<int>(V.size()));
        computeEnvelope(V,mConstraint,U,L);
        piecewiseSumReduction(U, Ured);
        piecewiseSumReduction(L, Lred);
    }
    
    double test(const vector<double> & candidate) {
        vector<double> reducedCandidate(Ured.size());
        piecewiseSumReduction(candidate, reducedCandidate);
        double smallerror (0.0);
        for(uint i = 0; i < Ured.size();++i) {
            if(reducedCandidate[i] > Ured[i]) 
              smallerror += reducedCandidate[i] - Ured[i];
            else if(reducedCandidate[i] < Lred[i])
              smallerror += Lred[i] - reducedCandidate[i];
        }
        if(smallerror > bestsofar) return bestsofar;
        ++lb_keogh;
        double error (0.0);
        for(uint i = 0; i < V.size();++i) {
            if(candidate[i] > U[i]) 
              error += candidate[i] - U[i];
            else if(candidate[i] < L[i])
              error += L[i] - candidate[i];
        }
        if(error < bestsofar) {
            ++full_dtw;
            const double trueerror = mDTW.fastdynamic(V,candidate);//,mConstraint,1);
            if(trueerror < bestsofar) bestsofar = trueerror;
        }
        return bestsofar;
    }
    
    
    int getNumberOfDTW(){return full_dtw;}
    
    
    int getNumberOfCandidates(){return lb_keogh;}
    
    
    double getLowestCost(){return bestsofar;}
    
    
    private:
    
    int lb_keogh;
    int full_dtw;
    const vector<double>   V; 
    int mConstraint;
    double bestsofar;
    vector<double>   U,L; 
    vector<double>   Ured,Lred; 
    
};

/**
* this class is not used?
*/
class Envelope {
    public:
    Envelope() : maxfifo(), minfifo(){}
    virtual ~Envelope() {}
    void compute(const vector<floattype> & array, uint constraint, vector<floattype> & maxvalues, vector<floattype> & minvalues) {
        const uint width = 1 +  2 * constraint;
        maxfifo.clear();minfifo.clear();
        for(uint i = 1; i < array.size(); ++i) {
          if(i >=constraint+1) {
            maxvalues[i-constraint-1] = array[maxfifo.size()>0 ? maxfifo.front():i-1];
            minvalues[i-constraint-1] = array[minfifo.size()>0 ? minfifo.front(): i-1];
          }
          if(array[i] > array[i-1]) { //overshoot
            minfifo.push_back(i-1);
            if(i ==  width+minfifo.front()) minfifo.pop_front();
            while(maxfifo.size() > 0) {
              if(array[i] <= array[maxfifo.back()]) {
                if (i==  width+maxfifo.front()) maxfifo.pop_front();
                break;
              }
              maxfifo.pop_back();
            }
          } else {
            maxfifo.push_back(i-1);
            if (i==  width+maxfifo.front()) maxfifo.pop_front();
            while(minfifo.size() > 0) {
              if(array[i] >= array[minfifo.back()]) {
                if(i==  width+minfifo.front()) minfifo.pop_front();
                break;
              }
              minfifo.pop_back();
            }
          }  
        }
        for(uint i = array.size(); i <= array.size() + constraint; ++i) {
              if(maxfifo.size()>0) {
                  maxvalues[i-constraint-1] = array[maxfifo.front()];
                if(i-maxfifo.front() >= width) {
                    maxfifo.pop_front();}
              } else {
                  maxvalues[i-constraint-1] = array[array.size()-1];
              }
              if(minfifo.size() > 0) {
                  minvalues[i-constraint-1] = array[minfifo.front()];
                  if(i-minfifo.front() >= width) {
                      minfifo.pop_front();}
              } else {
                  minvalues[i-constraint-1] = array[array.size()-1];
              }
        }
 }
        deque<int> maxfifo, minfifo;


};

// only used for unit testing
double l1diff(const vector<double> &  v, const vector<double> & w) {
    double ans(0);
    for(uint k = 0; k<v.size();++k)
      ans+=abs(v[k]-w[k]);
    return ans;
}
#endif


 

这个不开车的老司机
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++做华容道论文_【论文Summary】DTW
weixin_42515101的博客
12-03 190
【论文Summary】Searching and Mining Trillions of Time Series Subsequences under Dynamic Time Warping标签（空格分隔）： 论文Summary NLP1. 主要解决的问题这篇论文是针对DTW(Dynamic Time Warping)算法进行了一些优化，目的是用一段时间序列片段T1，在大规模的时间序列T2中...
使用c语言实现DTW（动态时间规整）算法
11-07
时间序列中，需要比较相似性的两段时间序列的长度可能并不相等，在语音识别领域表现为不同人的语速不同在这些复杂情况下，使用传统的欧几里得距离无法有效地求的两个时间序列之间的距离
DTW算法C++描述
11-14
c++描写的DTW算法，希望能够帮助大家。如果有什么问题，请大家批评指正。
DTW算法实现代码_C++_dtw_dtw算法c++_
09-29
DTW算法，C++实现，MATLAB实现
c++ 动态时间规整算法（DTW）例子
就很秃然
05-09 1441
#include<iostream> #include<string.h> using namespace std; #define NUM1 6 //序列中样本点的个数简单起见，假设2个序列的样本点一样多 #define NUM2 7 #define max 999 #define Min(a,b) (a<b?a:b) int main() { int i,j,k; //int a[NUM1],b[NUM2]; int b[6]={2,0,0,8,...
WAV音频MFCC参数提取 + DTW语音识别算法 C++代码实现
LP_Cong
09-08 4443
MFCC-DTW Simple MFCC extractor and an speech recognition algorithm (Dynamic Time Warping) 一个MFCC参数提取模板，和语音识别算法（DTW） main.cpp里有详细的用法，提取原理请参考其他博客。识别算法介绍请参考其他博客。抽象成一个类后，我们不必关心内部的实现方法，直接调用函数提
DTW_dtw_语音识别matlab_
09-30
**DTW（动态时间规整）在语音识别中的应用** DTW，全称为Dynamic Time Warping，是一种在序列数据上进行比对的算法，尤其适用于处理时间轴不同但内容相似的序列，比如在语音识别中，它能有效地解决语音信号长度不...
使用matlab 实现DTW算法（源代码）
09-10
动态时间规整（Dynamic Time Warping，DTW）是一种在序列数据之间计算相似度的算法，常用于语音识别、时间序列分析等领域。本教程将详细解释如何使用MATLAB实现DTW算法，并通过源代码深入理解其工作原理。 一、DTW...
dtw算法用matlab代码实现，有图
06-13
标题"dtw算法用matlab代码实现，有图"指出我们将讨论一个使用MATLAB编程语言实现的动态时间规整（Dynamic Time Warping, DTW）算法，并且提供了图表来辅助理解。DTW是一种在不同时长序列之间计算相似性的方法，常...
DTW_dtw_
09-29
动态时间归整（Dynamic Time Warping，简称DTW）是一种在序列数据中寻找最佳匹配对的方法，常用于处理时间序列的比对问题。DTW算法最初由Sakoe和Chiba在1978年提出，主要用于语音识别领域，但后来被广泛应用于其他...
DTW算法 C语言代码
10-17
资源提供DTW算法的c语音实现，和DTW算法的原理.能快速了解语音识别。
基于DTW算法的语音识别原理与C++实现源码
05-17
DTW动态时间规整算法的VC++实现代码
动态时间规整DTW算法源码
03-12
Dynamic Timing Warping，动态时间规整算法，源码
Julia中的 动态时间规整 (DTW) 和相关算法_julia_代码_下载
06-10
Julia 中的动态时间规整 (DTW)、矩阵轮廓和相关算法。 这个包支持任意度量和任意“空间”，也就是说，只要你传递一个向量或更高维数组，你的距离可以操作，你就可以开始了。时间总是被认为是最后一个维度
移动终端手势识别中 DTW 匹配算法研究
04-05
针对现有手势识别算法中存在的计算量复杂、识别率低和效率差等不足,提出一种基于L-ADTW的移动终端手势识别的匹配方法,利用手机内置加速度传感器进行手势识别,采用差分检测方法自动检测出有效手势序列,用改进的起始松弛点对有效手势序列进行校准,使用L-ADTW匹配算法进行有效手势序列段匹配,并将匹配结果与优化阈值比较分析。实验结果表明,提出的L-ADTW算法,在保证手势匹配高效的前提下,使等错率降到2.5%,认证成功率提高了5.37%。
c++矩阵连乘的动态规划算法并输出_动态时间序列精准索引(Exact indexing of dynamic time warping)...
weixin_39881958的博客
11-24 221
作者: James, 2020年3月10日关键字：DTW，动态时间规整，索引0. 序 本文是论文Exact indexing of dynamic time warping的学习笔记[1]。本文结构为：第一部分介绍背景，第二部分介绍DTW，第三部分介绍low-boundary，第四部分介绍index，第五部分致谢。1. 背景 超大规模时间序列数据库的索引问题很重要，传统大量的索引工作都...
动态时间归整/规整/弯曲(Dynamic time warping,DTW)
热门推荐
Hencoff的专栏
06-12 1万+
http://blog.sina.com.cn/s/blog_4b700c4c0102e1gz.html 动态时间规整DTW   在日常的生活中我们最经常使用的距离毫无疑问应该是欧式距离，但是对于一些特殊情况，欧氏距离存在着其很明显的缺陷，比如说时间序列，举个比较简单的例子，序列A：1,1,1,10,2,3，序列B：1,1,1,2,10,3，如果用欧氏距离，也就是
动态时间规整算法
weixin_30344795的博客
11-25 426
http://www.cnblogs.com/luxiaoxun/archive/2013/05/09/3069036.html Dynamic Time Warping（DTW）是一种衡量两个时间序列之间的相似度的方法，主要应用在语音识别领域来识别两段语音是否表示同一个单词。 1. DTW方法原理 在时间序列中，需要比较相似性的两段时间序列的长度可能并不相等，在语音识别领域表现为不同人的语...
dtw matlab
最新发布
12-30
DTW（动态时间规整）是一种用于比较两个序列之间相似度的算法，常用于时间序列数据的模式识别和聚类分析中。在MATLAB中，有许多方法可以实现DTW算法。 MATLAB中提供了一个称为'dtw'的函数，可以直接计算两个时间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值