精华内容
下载资源
问答
  • #include"addp_upool.h" #include "string.h" Dtype_16f maxfour(Dtype_16f a,Dtype_16f b,Dtype_16f c,Dtype_16f d){ return max(max(a,b),max(c,d)); } void cpy_poolbuf(Dtype_16f* In_ddr,Dtype_16f pool_bus...
    #include"addp_upool.h"
    #include "string.h"
    
    Dtype_16f maxfour(Dtype_16f a,Dtype_16f b,Dtype_16f c,Dtype_16f d){
    	return max(max(a,b),max(c,d));
    }
    
    void cpy_poolbuf(Dtype_16f* In_ddr,Dtype_16f pool_bus1[Tww],INT8 Tw,int of){
    	memcpy(pool_bus1, (Dtype_16f *)(In_ddr + of), Tw*sizeof(Dtype_16f));
    }
    void addcpdr2_lin(Dtype_16f* In_ddr,Dtype_16f* In_ddr2,Dtype_16f pool_bus1[Tww],Dtype_16f pool_bus2[Tww],Dtype_11f hz,Dtype_11f wz,Dtype_11f cz,Dtype_11f win,
    		Dtype_19f winxhin,Dtype_16f t,Dtype_11f inchan,INT8 Tw,Dtype_16f inxTh){
    	if(t>=inxTh)
    		return;
    	Dtype_11f t1=t%inchan;
    	Dtype_11f t2=t/inchan;
    	Dtype_11f c=t1+cz;
    	Dtype_11f h=t2+hz;
    	int of=c*winxhin+h*win+wz;
    	cpy_poolbuf(In_ddr, pool_bus1, Tw, of);
    	cpy_poolbuf(In_ddr2, pool_bus2, Tw, of);
    }
    
    void addcplin2_buf(Dtype_16f pool_in[inchannel][Thh][Tww],Dtype_16f pool_bus1[Tww],Dtype_16f pool_bus2[Tww],
    			Dtype_16f t,Dtype_11f inchan,INT8 Tw){
    	if(t<0)
    		return;
    	INT8 t3;
    	Dtype_11f t1=t%inchan;
    	Dtype_11f t2=t/inchan;
    	for(t3=0;t3<Tw;t3++){
    #pragma HLS PIPELINE II=1
    		pool_in[t1][t2][t3]=pool_bus1[t3]+pool_bus2[t3];
    	}
    
    }
    
    void Add(Dtype_16f* In_ddr,Dtype_16f* In_ddr2,Dtype_16f pool_in[inchannel][Thh][Tww],
    		INT8 Th,INT8 Tw, Dtype_11f hz,
    Dtype_11f wz,Dtype_11f cz,Dtype_11f win,Dtype_11f chin, Dtype_19f winxhin){
    		if(cz>=chin)
    			return;
    		INT8 cc,hh,ww;
    		Dtype_11f inchan=inchannel;
    //		int of;
    		Dtype_16f t;
    		static Dtype_16f pool_bus1[Tww];
    		static Dtype_16f pool_bus2[Tww];
    		static Dtype_16f pool_busb1[Tww];
    		static Dtype_16f pool_busb2[Tww];
    		if(cz+inchannel>chin)
    			inchan=chin-cz;
    		Dtype_16f inxTh=inchan*Th;
    		bool pp=true;
    		for(t=0;t<inxTh+1;t++){
    			if(pp)
    			{
    				addcpdr2_lin( In_ddr, In_ddr2, pool_bus1, pool_bus2, hz, wz, cz, win,
    						 winxhin, t, inchan, Tw,inxTh);
    				addcplin2_buf( pool_in, pool_busb1, pool_busb2,
    							 t-1, inchan, Tw);
    				pp=false;
    
    			}
    			else
    			{
    				addcpdr2_lin( In_ddr, In_ddr2, pool_busb1, pool_busb2, hz, wz, cz, win,
    										 winxhin, t, inchan, Tw,inxTh);
    				addcplin2_buf( pool_in, pool_bus1, pool_bus2,
    											 t-1, inchan, Tw);
    				pp=true;
    			}
    		}
    
    
    //		for(cc=0;cc<inchan;cc++){
    //			Dtype_11f C=cc+cz;
    //			for(hh=0;hh<Th;hh++){
    //				Dtype_11f H=hh+hz;
    //				of=C*winxhin+H*win+wz;
    //				cpy_poolbuf(In_ddr, pool_bus1, Tw, of);
    //				cpy_poolbuf(In_ddr2, pool_bus2, Tw, of);
    //				for(ww=0;ww<Tw;ww++){
    //					pool_in[cc][hh][ww]=pool_bus1[ww]+pool_bus2[ww];
    //				}
    //
    //			}
    //
    //		}
    }
    
    void pool_compute(Dtype_16f pool_in[inchannel][Thh][Tww],Dtype_16f pool_lin[tww],Dtype_16f t,
    		Dtype_11f inchan,INT8 tw,Dtype_16f inxth){
    	if(t>=inxth)
    		return;
    	INT8 t3;
    	Dtype_11f t1=t%inchan;
    	Dtype_11f t2=t/inchan;
    	INT8 h2=t2<<1;
    	for(t3=0;t3<tw;t3++){
    #pragma HLS PIPELINE II=2
    		INT8 w2=t3<<1;
    		pool_lin[t3]=maxfour(
    				pool_in[t1][h2][w2],
    				pool_in[t1][h2+1][w2],
    				pool_in[t1][h2][w2+1],
    				pool_in[t1][h2+1][w2+1]
    				);
    	}
    }
    
    void pool_store(Dtype_16f* pool_outddr,Dtype_16f pool_lin[tww],Dtype_11f hzz,Dtype_11f wzz,Dtype_11f cz,Dtype_16f t,
    		Dtype_11f inchan,Dtype_11f Wout,INT8 tw){
    	if(t<0)
    		return;
    	Dtype_11f t1=t%inchan;
    	Dtype_11f t2=t/inchan;
    	Dtype_11f hof=hzz+t2;
    	Dtype_11f cof=cz+t1;
    	int off=cof*Wout*Wout+hof*Wout+wzz;
    	memcpy((Dtype_16f *)(pool_outddr + off),pool_lin,tw*sizeof(Dtype_16f));
    
    }
    
    void Max_pool(Dtype_16f* pool_outddr,Dtype_16f pool_in[inchannel][Thh][Tww],
    		INT8 Th,INT8 Tw, Dtype_11f hz,
    Dtype_11f wz,Dtype_11f cz,Dtype_11f win,Dtype_11f chin){
    	if(cz<0)
    		return;
    //	INT8 cc,hh,ww;
    	Dtype_16f t;
    	Dtype_11f Wout=win>>1;
    	INT8 th=Th>>1;
    	INT8 tw=Tw>>1;
    	Dtype_11f hzz=hz>>1;
    	Dtype_11f wzz=wz>>1;
    	static Dtype_16f pool_lin[tww];
    	static Dtype_16f pool_lin2[tww];
    	Dtype_11f inchan=inchannel;
    	if(cz+inchannel>chin)
    		inchan=chin-cz;
    //	Add(In_ddr,In_ddr2, pool_in,Th, Tw,  hz,wz, cz, win, chin,  winxhin);
    	Dtype_16f inxth=inchan*th;
    	bool pp2=true;
    	for(t=0;t<inxth+1;t++){
    		if(pp2)
    		{
    			pool_compute( pool_in, pool_lin, t, inchan, tw,inxth);
    			pool_store( pool_outddr, pool_lin2, hzz, wzz, cz, t-1,
    					 inchan, Wout, tw);
    			pp2=false;
    		}
    		else
    		{
    			pool_compute( pool_in, pool_lin2, t, inchan, tw,inxth);
    			pool_store( pool_outddr, pool_lin, hzz, wzz, cz, t-1,
    								 inchan, Wout, tw);
    			pp2=true;
    		}
    	}
    //	for(cc=0;cc<inchan;cc++){
    //		for(hh=0;hh<th;hh++){
    //			INT8 h2=hh<<1;
    //			for(ww=0;ww<tw;ww++){
    #pragma HLS PIPELINE II=2
    //				INT8 w2=ww<<1;
    //				pool_lin[ww]=maxfour(
    //						pool_in[cc][h2][w2],
    //						pool_in[cc][h2+1][w2],
    //						pool_in[cc][h2][w2+1],
    //						pool_in[cc][h2+1][w2+1]
    //				);
    //			}
    //			Dtype_11f hof=hzz+hh;
    //			Dtype_11f cof=cz+cc;
    //			Dtype_40f off=cof*Wout*Wout+hof*Wout+wzz;
    //			memcpy((Dtype_16f *)(pool_outddr + off),pool_lin,tw*sizeof(Dtype_16f));
    //		}
    //	}
    }
    
    void up_cp2_lin(Dtype_16f* In_ddr,Dtype_16f upsample[doublTww],Dtype_11f cz,Dtype_11f hz,Dtype_11f wz,
    		Dtype_16f t,Dtype_11f inchan,INT8 Tw,Dtype_19f winxhin,Dtype_11f win,Dtype_16f inxTh){
    	if(t>=inxTh)
    		return;
    	Dtype_11f t1=t%inchan;
    	Dtype_11f t2=t/inchan;
    	Dtype_11f c=t1+cz;
    	Dtype_11f h=t2+hz;
    	INT8 t3;
    	static Dtype_16f upsample_lin[Tww];
    	int of=c*winxhin+h*win+wz;
    	memcpy(upsample_lin, (Dtype_16f *)(In_ddr + of), Tw*sizeof(Dtype_16f));
    	for(t3=0;t3<Tw;t3++){
    #pragma HLS PIPELINE II=1
    		INT8 ww1=t3<<1;
    		upsample[ww1]=upsample_lin[t3];
    		upsample[ww1+1]=upsample_lin[t3];
    	}
    
    }
    
    void up_cplin2_ddr(Dtype_16f* output_ddr,Dtype_16f upsample[doublTww],
    		Dtype_11f cz,Dtype_11f hz,Dtype_11f wz,Dtype_16f t,Dtype_11f inchan,INT8 Tw,Dtype_11f win){
    	if(t<0)
    		return;
    	Dtype_11f t1=t%inchan;
    	Dtype_11f t2=t/inchan;
    	Dtype_11f Wout=win<<1;
    	INT8 DTw=Tw<<1;
    	Dtype_11f cof=t1+cz;
    	Dtype_11f hof=(t2+hz)<<1;
    	Dtype_11f wof=wz<<1;
    	Dtype_11f hof2=hof+1;
    	int of1=cof*Wout*Wout+hof*Wout+wof;
    	int of2=cof*Wout*Wout+hof2*Wout+wof;
    	memcpy((Dtype_16f *)(output_ddr + of1),upsample,DTw*sizeof(Dtype_16f));
    	memcpy((Dtype_16f *)(output_ddr + of2),upsample,DTw*sizeof(Dtype_16f));
    }
    
    void up_sample(Dtype_16f* In_ddr,Dtype_16f* output_ddr,Dtype_11f cz,Dtype_11f hz,Dtype_11f wz,Dtype_11f chin,INT8 Th, INT8 Tw,Dtype_19f winxhin,
    		Dtype_11f win){
    	if(cz>=chin)
    		return;
    	INT8 cc,hh,ww;
    	Dtype_16f t;
    	Dtype_11f inchan=inchannel;
    	static Dtype_16f upsample[doublTww];
    	static Dtype_16f upsample2[doublTww];
    	if(cz+inchannel>chin)
    		inchan=chin-cz;
    	Dtype_16f inxTh=inchan*Th;
    	bool pp4=true;
    	for(t=0;t<inxTh+1;t++){
    		if(pp4)
    		{
    			up_cp2_lin( In_ddr, upsample, cz, hz, wz,t, inchan, Tw, winxhin, win,inxTh);
    			up_cplin2_ddr( output_ddr, upsample2,cz, hz, wz, t-1, inchan, Tw, win);
    			pp4=false;
    		}
    		else
    		{
    			up_cp2_lin( In_ddr, upsample2, cz, hz, wz,t, inchan, Tw, winxhin, win,inxTh);
    			up_cplin2_ddr( output_ddr, upsample,cz, hz, wz, t-1, inchan, Tw, win);
    			pp4=true;
    		}
    
    	}
    //	for(cc=0;cc<inchan;cc++){
    //		for(hh=0;hh<Th;hh++){
    //			Dtype_11f c=cc+cz;
    //			Dtype_11f h=hh+hz;
    //			int of=c*winxhin+h*win+wz;
    //			memcpy(upsample_lin, (Dtype_16f *)(In_ddr + of), Tw*sizeof(Dtype_16f));
    //			for(ww=0;ww<Tw;ww++)
    //			{
    //				INT8 ww1=ww<<1;
    //				upsample[ww1]=upsample_lin[ww];
    //				upsample[ww1+1]=upsample_lin[ww];
    //			}
    //
    //		}
    //	}
    }
    
    
    void add_p_up(Dtype_16f* In_ddr,Dtype_16f* In_ddr2, Dtype_16f* output_ddr,Dtype_11f Hin,
    		 Dtype_11f Win,Dtype_11f CHin,INT3 POOL){
    #pragma HLS INTERFACE m_axi depth=99999 port=In_ddr offset=slave bundle=pool_IN max_read_burst_length=64 max_write_burst_length=64
    #pragma HLS INTERFACE m_axi depth=99999 port=In_ddr2 offset=slave bundle=pool_IN2 max_read_burst_length=64 max_write_burst_length=64
    #pragma HLS INTERFACE m_axi depth=99999 port=output_ddr offset=slave bundle=pool_OUT max_read_burst_length=64 max_write_burst_length=64
    #pragma HLS INTERFACE s_axilite port=Hin bundle=CTRL
    #pragma HLS INTERFACE s_axilite port=Win bundle=CTRL
    #pragma HLS INTERFACE s_axilite port=CHin bundle=CTRL
    #pragma HLS INTERFACE s_axilite port=POOL bundle=CTRL
    #pragma HLS INTERFACE s_axilite port=return bundle=CTRL
    	static Dtype_16f pool_in2[inchannel][Thh][Tww];
    #pragma HLS ARRAY_PARTITION variable=pool_in2 complete dim=1
    //#pragma HLS RESOURCE variable=pool_in2 core=RAM_2P_BRAM
    	static Dtype_16f pool_in[inchannel][Thh][Tww];
    #pragma HLS ARRAY_PARTITION variable=pool_in complete dim=1
    //#pragma HLS RESOURCE variable=pool_in core=RAM_2P_BRAM
    		Dtype_19f winxhin=Win*Hin;
    		Dtype_11f H,W,C;
    		INT8 Th=Thh;
    		INT8 Tw;
    		{
    
    			loop_poolHin:
    			for(H=0;H<Hin;H+=Th){
    				if(H+Th>Hin)
    					Th=Hin-H;
    				Tw=Tww;
    				loop_poolWin:
    				for(W=0;W<Win;W+=Tw){
    					if(W+Tw>Win)
    						Tw=Win-W;
    					bool pp3=true;
    					for(C=0;C<CHin+inchannel;C+=inchannel){
    						if(!POOL)
    						{
    							up_sample(In_ddr, output_ddr, C, H, W, CHin, Th,  Tw, winxhin,
    								 Win);
    						}
    						else
    						{
    							Dtype_11f co=C-inchannel;
    							if(pp3)
    							{
    								Add(In_ddr, In_ddr2, pool_in,Th, Tw,  H,W, C, Win, CHin,  winxhin);
    								Max_pool( output_ddr, pool_in2, Th, Tw,  H,W, co, Win, CHin);
    								pp3=false;
    							}
    							else
    							{
    								Add(In_ddr, In_ddr2, pool_in2,Th, Tw,  H,W, C, Win, CHin,  winxhin);
    								Max_pool( output_ddr, pool_in, Th, Tw,  H,W, co, Win, CHin);
    								pp3=true;
    							}
    
    						}
    
    					}
    				}
    			}
    
    		}
    
    }
    
    
    展开全文
  • upsample Increase sample rate by integer factor collapse all in page Syntax y = upsample(x,n) y = upsample(x,n,phase) Description example y = upsample(x,n) increases the sample rate of x by inserting...

    upsample

    Increase sample rate by integer factor collapse all in page
    Syntax
    y = upsample(x,n)
    y = upsample(x,n,phase)
    Description
    example
    y = upsample(x,n) increases the sample rate of x by inserting n – 1 zeros between samples. If x is a matrix, the function treats each column as a separate sequence.
    y = upsample(x,n,phase) specifies the number of samples by which to offset the upsampled sequence.
    Examples
    collapse all
    Increase Sample Rates
    Open Live Script
    Increase the sample rate of a sequence by a factor of 3.

    x = [1 2 3 4];
    y = upsample(x,3)
    y = 1×12

         1     0     0     2     0     0     3     0     0     4     0     0

    Increase the sample rate of the sequence by a factor of 3 and add a phase offset of 2.

    x = [1 2 3 4];
    y = upsample(x,3,2)
    y = 1×12

         0     0     1     0     0     2     0     0     3     0     0     4

    x1= [1 2 3 4];
    y = upsample(x,3,1)
    y = 1×12

         0     1     0     0     2     0     0     3     0     0     4

    Increase the sample rate of a matrix by a factor of 3.

    x = [1 2;
         3 4;
         5 6];
    y = upsample(x,3)
    y = 9×2

         1     2
         0     0
         0     0
         3     4
         0     0
         0     0
         5     6
         0     0
         0     0

    Input Arguments
    collapse all
    x — Input array
    vector | matrix
    Input array, specified as a vector or matrix. If x is a matrix, the function treats the columns as independent channels.

    Example: cos(pi/4*(0:159)) + randn(1,160) specifies a sinusoid embedded in white Gaussian noise.

    Example: cos(pi./[4;2]*(0:159))' + randn(160,2) specifies a two-channel noisy sinusoid.

    Data Types: single | double
    Complex Number Support: Yes
    n — Upsampling factor
    positive integer
    Upsampling factor, specified as a positive integer.

    Data Types: single | double
    phase — Offset
    0 (default) | positive integer
    Offset, specified as a positive integer from 0 to n – 1.

    Data Types: single | double
    Output Arguments
    collapse all
    y — Upsampled array
    vector | matrix
    Upsampled array, returned as a vector or matrix. y has x × n samples.

     

     

    Matlab中用于计算自相关函数的指令是xcorr.比如矩阵A=[1 2 3];

    xcorr(A)=3.0000 8.0000 14.0000 8.0000 3.0000

    自相关函数是信号间隔的函数,间隔有正负间隔,所以n个长度的信号,有2n-1个自相关函数值,分别描述的是不同信号间隔的相似程度。

    比如,上面的矩阵,最后得到5个结果,其中第三个是自己和自己相乘,最后相加的结果,值最大1*1+2*2+3*3=14。而第二个和第四个分别是间隔正负1的结果也就是1*2+2*3=8,2*1+3*2=8。第1个和第五个分别是间隔正负2,也就是1*3=3,3*1=3。

    使用方法回目录

    c = xcorr(x,y)
    c = xcorr(x)
    c = xcorr(x,y,'option')
    c = xcorr(x,'option')
    c = xcorr(x,y,maxlags)
    c = xcorr(x,maxlags)
    c = xcorr(x,y,maxlags,'option')
    c = xcorr(x,maxlags,'option')
    [c,lags] = xcorr(...)
    功能描述回目录
    xcorr来估计随机过程中的互相关序列,自相关是xcorr的一个特例。
    互相关函数序列为:




    x(n)和y(n)为统计的随机序列,-∞
    c = xcorr(x,y) 返回矢量长度为2*N-1互相关函数序列,其中x和y的矢量长度均为N,如果x和y的长度不一样,则在短的序列后补零直到两者长度相等。
    一般情况下,xcorr计算无正规化的原始相关系数。

    输出矢量C通过c(m) = Rxy(m-N), m=1, ..., 2N-1.得到。
    通常,互相关函数需要正规化来得到更准确的估计值。
    c = xcorr(x) 为矢量x的自相关估计;
    c = xcorr(x,y,'option') 为有正规化选项的互相关计算;其中选项为
    "biased"为有偏的互相关函数估计;
    "unbiased"为无偏的互相关函数估计;
    "coeff"为0延时的正规化序列的自相关计算;
    "none"为原始的互相关计算;
    若需了解更多的有偏和无偏相关估计,请参阅文献[1].
    c= xcorr(x,'option')特指以上某个选项的自相关估计。
    c = xcorr(x,y,maxlags) 返回一个延迟范围在[-maxlags,maxlags]的互相关函数序列,输出c的程度为2*maxlags-1.
    c = xcorr(x,maxlags) 返回一个延迟范围在[-maxlags,maxlags]的自相关函数序列,输出c的程度为2*maxlags-1.
    c = xcorr(x,y,maxlags,'option') 同时指定maxlags和option的互相关计算.
    c = xcorr(x,maxlags,'option') 同时指定maxlags和option的自相关计算.
    [c,lags] = xcorr(...)返回一个在c进行相关估计的延迟矢量lag,其范围为[-maxlags:maxlags],当maxlags没有指定时,其范围为[-N+1,N-1]
    总之,无论是互相关计算还是相关计算都是以序列中间位置进行0lags计算。
    应用举例回目录
    使用高斯白噪声进行自相关估计,其中lags=10;
    ww = randn(1000,1);
    [c_ww,lags] = xcorr(ww,10,'coeff');
    stem(lags,c_ww)

     

     

    ) 相关程度与相关函数的取值有什么联系?
    相关系数只是一个比率,不是等单位量度,无什么单位名称,也不是相关的百分数,一般取小数点后两位来表示。相关系数的正负号只表示相关的方向,绝对值表示相关的程度。因为不是等单位的度量,因而不能说相关系数0.7是0.35两倍,只能说相关系数为0.7的二列变量相关程度比相关系数为0.35的二列变量相关程度更为密切和更高。也不能说相关系数从0.70到0.80与相关系数从0.30到0.40增加的程度一样大。
    对于相关系数的大小所表示的意义目前在统计学界尚不一致,但通常按下是这样认为的:
    相关系数 相关程度
    0.00-±0.30 微相关
    ±0.30-±0.50 实相关
    ±0.50-±0.80 显著相关
    ±0.80-±1.00 高度相关
    matlab计算自相关函数autocorr和xcorr有什么不一样的?xcorr是没有将均值减掉做的相关,autocorr则是减掉了均值。

    用过Matlab的人都知道,Matlab的命令总是能一石三鸟,通过改变输入参数的注释项即可实现不同功能,如今xcorr命令的难点就在于其有四个注释项,这些注释项使得计算的结果各有不同,本文将详细介绍对应每个注释项Matlab是如何计算的,当然本文考虑输入的是一个简单一维序列x=[1,2,3],序列中数据对应的序号依次为1,2,3(请读者在阅读下文时,不要把序号和数据值弄混,这里只是个特例),其他情况读者可以轻松扩展得到。首先确定一下,该序列的均值为2,方差值为0.6667.这个应该不用说怎么算的吧。然后读者需要了解的是该命令意在计算序列中间隔不同距离的数据之间的关系。

    第一:缺省注释项,[a,b]=xcorr(x),通过该命令计算的结果为:a=3 8 14 8 3;b=-2 -1 0 1 2.

    下面介绍一下,该过程计算机是如何计算的,首先讲b的计算,设一维序列的长度为N,则序列中任意两个数据序号相减,最小值为1-N,最大值为N-1,且能取遍两者之间的所有整数,将这些数从小到大排列得到的就是b;然后讲a的计算,在缺省注释项的情况下,a的计算是这样的,a的每一项是对应b的每一项的

    1、当b(1)=-2时,计算a(1)时只用到一组数据——(3,1)注意顺序,只有这两个数据的序号相减(后面数据的序号减去前面的)满足b=-2,因此a(1)的计算公式为:3*1=3

    2、当b(2)=-1时,计算a(2)时用到两组数据——(2,1)和(3,2),这两组数据的序号相减(后面数据的序号减去前面的)满足b=-1,因此a(2)的计算公式为:2*1+3*2=8

    3、当b(3)=0时,计算a(3)时用到三组数据——(1,1)、(2,2)、(3,3),这三组数据的序号相减(后面数据的序号减去前面的)满足b=0,因此a(3)的计算公式为:1*1+2*2+3*3=14

    4、当b(4)=1时,计算a(4)时用到两组数据——(1,2)和(2,3),(读者请对比和情况2的区别),这两组数据的序号相减(后面数据的序号减去前面的)满足b=1,因此a(4)的计算公式为:1*2+2*3=8

    5、当b(5)=2时,计算a(4)时用到一组数据——(1,3),(读者请对比和情况1的区别),这两组数据的序号相减(后面数据的序号减去前面的)满足b=2,因此a(4)的计算公式为:1*3=3

    第二:注释项为‘unbiased’,[a,b]=xcorr(x,‘unbiased’),通过该命令计算的结果为:a=3 4 4.6667 4 3;b=-2 -1 0 1 2.下面介绍计算机如何计算该过程,b的计算在四种注释项的情况下是相同的,就不再讲述了。a的计算仍是和b的每一项相对应的。

    1、当b(1)=-2时,计算a(1)时只用到一组数据(记N=1)——(3,1)注意顺序,只有这两个数据的序号相减(后面数据的序号减去前面的)满足b=-2,因此a(1)的计算公式为:(3*1)/1=3

    2、当b(2)=-1时,计算a(2)时用到两组数据(记N=2)——(2,1)和(3,2),这两组数据的序号相减(后面数据的序号减去前面的)满足b=-1,因此a(2)的计算公式为:(2*1+3*2)/2=4

    3、当b(3)=0时,计算a(3)时用到三组数据(记N=3)——(1,1)、(2,2)、(3,3),这三组数据的序号相减(后面数据的序号减去前面的)满足b=0,因此a(3)的计算公式为:(1*1+2*2+3*3)/3=4.6667

    4、当b(4)=1时,计算a(4)时用到两组数据(记N=2)——(1,2)和(2,3),(读者请对比和情况2的区别),这两组数据的序号相减(后面数据的序号减去前面的)满足b=1,因此a(4)的计算公式为:(1*2+2*3)/2=4

    5、当b(5)=2时,计算a(4)时用到一组数据(记N=1)——(1,3),(读者请对比和情况1的区别),这两组数据的序号相减(后面数据的序号减去前面的)满足b=2,因此a(4)的计算公式为:(1*3)/1=3

    第三:注释项为‘biased’,[a,b]=xcorr(x,‘biased’),通过该命令计算的结果为:a=  1.0000   2.6667    4.6667    2.6667    1.0000,b=-2 -1 0 1 2。下面介绍计算机如何计算该过程,注意到本次计算用到的序列x的长度为3,记为M=3。

    1、当b(1)=-2时,计算a(1)时只用到一组数据——(3,1)注意顺序,只有这两个数据的序号相减(后面数据的序号减去前面的)满足b=-2,因此a(1)的计算公式为:(3*1)/M=1

    2、当b(2)=-1时,计算a(2)时用到两组数据——(2,1)和(3,2),这两组数据的序号相减(后面数据的序号减去前面的)满足b=-1,因此a(2)的计算公式为:(2*1+3*2)/M=2.6667

    3、当b(3)=0时,计算a(3)时用到三组数据——(1,1)、(2,2)、(3,3),这三组数据的序号相减(后面数据的序号减去前面的)满足b=0,因此a(3)的计算公式为:(1*1+2*2+3*3)/M=4.6667

    4、当b(4)=1时,计算a(4)时用到两组数据——(1,2)和(2,3),(读者请对比和情况2的区别),这两组数据的序号相减(后面数据的序号减去前面的)满足b=1,因此a(4)的计算公式为:(1*2+2*3)/M=2.6667

    5、当b(5)=2时,计算a(4)时用到一组数据——(1,3),(读者请对比和情况1的区别),这两组数据的序号相减(后面数据的序号减去前面的)满足b=2,因此a(4)的计算公式为:(1*3)/M=1

    第四:注释项为‘coeff’,[a,b]=xcorr(x,‘coeff’),通过该命令计算的结果为:a= 0.2143   0.5714    1.0000    0.5714    0.2143,b=-2 -1 0 1 2,下面介绍计算机如何计算该过程,这种情况实际是将第三种情况下得到的结果进行归一化,使得b=0时对应的值为1,a(1)=1/4.6667=0.2143;a(2)=2.6667/4.6667=0.5714,a(3)=4.6667/4.6667=1,a(4)=2.6667/4.6667=0.5714,a(5)=1/4.6667=0.2143

     

    另:xcorr命令在工程上的应用通常是对时间上的采样数据序列x进行处理,当数据点采完之后交给Matlab处理时,Matlab是不知道你的采样时间间隔的,它仅仅根据上文所述的计算过程对输入的数据序列x进行计算,但我们可以自己定义时间间隔,例如dt=0.01,此时t=dt*b即代表相关性计算中的时间延迟,前半部分是超前,后半部分是滞后,若R=xcorr(x,‘unbiased’),则通过命令:plot(t,R)即可得到该时域信号的自相关函数曲线。

     

    展开全文
  • MATLAB函数upsample的使用

    千次阅读 2019-10-11 17:35:18
    upsample Increase sample rate by integer factor collapse all in page Syntax y = upsample(x,n) y = upsample(x,n,phase) Description example y = upsample(x,n) increases the sample rate of x by inserting...

    upsample

    Increase sample rate by integer factor collapse all in page
    Syntax
    y = upsample(x,n)
    y = upsample(x,n,phase)
    Description
    example
    y = upsample(x,n) increases the sample rate of x by inserting n – 1 zeros between samples. If x is a matrix, the function treats each column as a separate sequence.
    y = upsample(x,n,phase) specifies the number of samples by which to offset the upsampled sequence.
    Examples
    collapse all
    Increase Sample Rates
    Open Live Script
    Increase the sample rate of a sequence by a factor of 3.

    x = [1 2 3 4];
    y = upsample(x,3)
    y = 1×12

         1     0     0     2     0     0     3     0     0     4     0     0

    Increase the sample rate of the sequence by a factor of 3 and add a phase offset of 2.

    x = [1 2 3 4];
    y = upsample(x,3,2)
    y = 1×12

         0     0     1     0     0     2     0     0     3     0     0     4

    x1= [1 2 3 4];
    y = upsample(x,3,1)
    y = 1×12

         0     1     0     0     2     0     0     3     0     0     4

    Increase the sample rate of a matrix by a factor of 3.

    x = [1 2;
         3 4;
         5 6];
    y = upsample(x,3)
    y = 9×2

         1     2
         0     0
         0     0
         3     4
         0     0
         0     0
         5     6
         0     0
         0     0

    Input Arguments
    collapse all
    x — Input array
    vector | matrix
    Input array, specified as a vector or matrix. If x is a matrix, the function treats the columns as independent channels.

    Example: cos(pi/4*(0:159)) + randn(1,160) specifies a sinusoid embedded in white Gaussian noise.

    Example: cos(pi./[4;2]*(0:159))' + randn(160,2) specifies a two-channel noisy sinusoid.

    Data Types: single | double
    Complex Number Support: Yes
    n — Upsampling factor
    positive integer
    Upsampling factor, specified as a positive integer.

    Data Types: single | double
    phase — Offset
    0 (default) | positive integer
    Offset, specified as a positive integer from 0 to n – 1.

    Data Types: single | double
    Output Arguments
    collapse all
    y — Upsampled array
    vector | matrix
    Upsampled array, returned as a vector or matrix. y has x × n samples.

    展开全文
  • PyTorch Upsample() 函数实现上采样

    千次阅读 2020-08-31 20:05:34
    PyTorch Upsample() 函数实现上采样 import torch import torch.nn as nn input = torch.arange(1, 5, dtype=torch.float32).view(1,1,2,2) print(input) m = nn.Upsample(scale_factor=2, mode='bicubic', align_...

    PyTorch Upsample() 函数实现上采样

    import torch
    import torch.nn as nn
    
    input = torch.arange(1, 5, dtype=torch.float32).view(1,1,2,2)
    print(input)
    
    m = nn.Upsample(scale_factor=2, mode='bicubic', align_corners=True)
    
    m(input)
    

    输出结果如下:

    tensor([[[[1., 2.],
              [3., 4.]]]])
    tensor([[[[1.0000, 1.3148, 1.6852, 2.0000],
              [1.6296, 1.9444, 2.3148, 2.6296],
              [2.3704, 2.6852, 3.0556, 3.3704],
              [3.0000, 3.3148, 3.6852, 4.0000]]]])
    

    Ref:

    1. https://pytorch.org/docs/stable/generated/torch.nn.Upsample.html
    展开全文
  • upsample:将采样率提高整数倍
  • result.add(InstanceNormalization()) if apply_dropout: result.add(tf.keras.layers.Dropout(0.5)) result.add(tf.keras.layers.ReLU()) return result 其实就是反卷积Conv2DTranspose()函数 卷积后先BN,再ReLU...
  • pytorch实现upsample

    千次阅读 2019-08-11 16:16:14
    这里实现的是一个比较偏的upsample,是朋友问我的,顺手记录下来。 实现的效果如下: 输入: 输出: 实现的是按相同值内插。实现方法是meshgrid,这个函数很好用,可以在输入x坐标和y坐标的情况下,返回由其组成...
  • Upsample层对应的是_interpolate函数,但不清楚用actual_shape参数要怎么改,或者有更方便的改法嘛~ 其中_interpolate函数里层的现在是提供scale和out_shape的参数,如下: <pre><code> ...
  • PyTorch - torch.nn.Upsample

    2020-06-02 19:28:13
    PyTorch - torch.nn.Upsample flyfish 上采样 输入是 minibatch x channels x height x width 输出是 H × scale_factor W × scale_factor 本来名字是上采样,还可以根据参数使用变成下采样 与torch.nn....
  • upsample和resample的区别

    千次阅读 2018-03-01 18:05:15
    最近在做cic滤波器设计时,用到了这两个函数,需要仔细研究一下。
  • torch.nn.Upsample函数的问题 使用scale_factor出现 改成size即可
  • 从上述公式中可以看出,ConvTranspose2d中的参数stride参数相当于F.upsample函数中的放缩因子scale。 代入实例以供理解:现有width=60的input,欲反卷积得到output的width=240。即:240 = (60 - 1)* stride + ...
  • GPUS+jacket2.1+函数

    2019-06-21 14:07:52
    Jacket Function Reference;一些相关的函数,abs,acos,acosd,vander,upsample,vertcat等
  • upfirdn.m upsample.m vco.m vcosig.mat vr...upfirdn upsamp le chirp diric gauspul s ...滤波器执行 函数名 conv conv2 deconv fftfilt filter filter2 filtfilt filtic latcfilt medfilt1 sgolayfilt sosfilt ...
  • libtorch 哪些函数比较常用?

    千次阅读 2019-04-17 09:42:00
    //输入32x32 3通道图片 auto input = torch::rand({ 1,3,32,32 }); //输出 auto output_bilinear = torch::upsample_bilinear2d(input, { 8,8 }, false); auto output_nearest = t...
  • dlib.get_frontal_face_detector()函数

    千次阅读 2019-05-15 11:52:04
    其中in Classes 表示采样(upsample)次数 返回值是<class 'dlib.dlib.rectangle'>,就是一个矩形 坐标为[(x1, y1) (x2, y2)] 可以通过函数的left,right,top,bottom方法分别获取对应的x...
  • Face_Recognition 人脸识别函数详解

    千次阅读 2020-04-21 11:46:19
    加载人脸图片文件 load_image_file(file, mode='RGB'): 通过 PIL.image.open 加载图片文件 mode 有两种模式 ‘RGB’ 3通道 和 ‘L' 单通道 ...face_locations(img, number_of_times_to_upsample=1, model="hog"):...
  • from sklearn.utils import resampledf_majority = df[df.balance==0]df_minority = df[df.balance==1]#Upsample minority classdf_minority_upsampled = resample(df_minority,replace=True, # sample with rep...
  • The product of the downsample factor Q and the upsample factor P must be less than 2^31. 原因是resample的两个参数太过接近,比如(44199,44100).b=resample(a,44199,44100);解决方法是因式分解
  • face_recognition模块方法集合

    千次阅读 2018-08-14 17:55:34
    face_recognition API ...函数batch_face_locations batch_face_locations(images, number_of_times_to_upsample=1, batch_size=128) 使用cnn人脸检测器返回一个包含人脸特征的二维数组,如果使用了GPU...
  • 只描述代码每个函数的含义,具体含义参考代码解析。...上采样由upsample表示。 1. convolutional函数函数表示darknet最基本的卷积过程:包括:卷积+BN/偏置+非线性卷积+BN/偏置+非线性卷积+BN/偏置+非线.
  • 如果我们在使用TensorRT时有一些操作并不支持,我们可以自行编写...然后我们要实现该类的一些必要方法,首先是2个构造函数,一个是传参数构建,另一个是从序列化后的比特流构建: Upsample(int scale = 2) : mScale(sc
  • fpn_head的疑惑

    2020-12-28 10:09:19
    <div><p>在fpn_head中,... 为什么在forwad函数还会再进行一次upsample? 是有相关的考虑, 还是代码冗余?</p><p>该提问来源于开源项目:open-mmlab/mmsegmentation</p></div>
  • yolov3相关模块的解析与实现(二) ...def _upsample(inputs, out_shape): ''' :param inputs: 输入 类型tensor 形状 [batch, height_in, width_in, channels]. :param out_shape: 调整后的tensor的形状 类
  • 插值 在离散数据的基础上补插连续函数,使得这条连续曲线通过全部给定的离散数据点。...插值方法的用途:语音处理中用来实现语音的重采样(DownSample/UpSample),图像处理中用来填充图像变换时像素...

空空如也

空空如也

1 2 3
收藏数 53
精华内容 21
关键字:

upsample函数