精华内容
下载资源
问答
  • 粒子群算法 求函数最小值,matlab代码。链接是讲解粒子群算法 ... 我用ubuntu下matlab编写的代码,你在windows下可能有中文乱码,不过都是注释,你可以博客链接中查看主要代码部分,不影响的
  • 粒子群算法 求函数最小值,matlab代码。链接是讲解粒子群算法 ... 我用ubuntu下matlab编写的代码,你在windows下可能有中文乱码,不过都是注释,你可以博客链接中查看主要代码部分,不影响的
  • 为什么边缘(即梯度大的地方)...因为sift中提取的特征点就不是边缘,而是“斑点”,这也就是为什么sift算法中会有一步“去除强边缘响应点”。 关于何为“斑点“,以及是如何用DoG极值代表“斑点“的详细过程参考: ...

    为什么边缘(即梯度大的地方)明明对应二阶导的零点,而在sift中却找的是LoG的近似DoG的极值点:
    因为sift中提取的特征点就不是边缘,而是“斑点”,这也就是为什么sift算法中会有一步“去除强边缘响应点”。
    关于何为“斑点“,以及是如何用DoG极值代表“斑点“的详细过程参考:
    https://www.cnblogs.com/YiXiaoZhou/p/5892083.html

    展开全文
  • 午后的阳光,那么灿烂,如果不是温度过高,那么西湖看看风景还是不错的。想着,现在西湖边应该是平静的湖面,加上无数知了在柳枝上演奏着交响曲吧。小看了下非诚勿扰,那男生为了女孩唐静付出了7年,唉,可是他错...

              午后的阳光,那么灿烂,如果不是温度过高,那么去西湖看看风景还是不错的。想着,现在西湖边应该是平静的湖面,加上无数知了在柳枝上演奏着交响曲吧。小看了下非诚勿扰,那男生为了女孩唐静付出了7年,唉,可是他错了,女孩根本不爱他,不过期间他的执着和付出,很让我感动,也许自己不太像他那样,才会让自己有现在的处境吧。也许吧。小感慨下。不过现在也挺好的,上上班,写写文章,然后天气凉快点还可以到处玩,杭州是个旅游休闲的好地方啊。扯远了,吃了饭回来,还是有些小感触啊。

            回归正题,既然二分法讲完了,那么继续三分法吧。二分法适用于求单调的时候用的,就比如说排序好的数组,那是递增的或者递减的。如果像出现了下图二次函数那样的怎么求他的最值呢?

            二分法早就失去了他的意义了。不过还是可以用三分法来实现的,就是二分中再来二分。比如我们定义了LRm = (L + R) / 2mm = (mid + R) / 2; 如果mid靠近极值点,则R = mm;否则就是mm靠近极值点,则L = m;这样的话,极值还是可以求的。具体的还是看看题目吧。

     

    zoj   3203   Light Bulb

    --------------------------------------------------------------------------------

    Time Limit: 1 Second      Memory Limit: 32768 KB

     

    --------------------------------------------------------------------------------

    Compared to wildleopard's wealthiness, his brother mildleopard is rather poor. His house is narrow and he has only one light bulb in his house. Every night, he is wandering in his incommodious house, thinking of how to earn more money. One day, he found that the length of his shadow was changing from time to time while walking between the light bulb and the wall of his house. A sudden thought ran through his mind and he wanted to know the maximum length of his shadow.

     

    Input

     

    The first line of the input contains an integer T (T <= 100), indicating the number of cases.

     

    Each test case contains three real numbers H, h and D in one line. H is the height of the light bulb while h is the height of mildleopard. D is distance between the light bulb and the wall. All numbers are in range from 10-2 to 103, both inclusive, and H - h >= 10-2.

     

    Output

     

    For each test case, output the maximum length of mildleopard's shadow in one line, accurate up to three decimal places..

     

    Sample Input

     

     

    3

    2 1 0.5

    2 0.5 3

    4 3 4

     

    Sample Output

     

     

    1.000

    0.750

    4.000

            题意很简单,就是人左右走动,求影子L的最长长度。

            由图可知,当人走进时,当影子刚好没有投到墙上的时候,是最长的。接着影子到了墙上就变小了,所以可以用三分法来求最值。当然用高数的求导还是可以解决的,只是定义域要注意下。

    #include <stdio.h>
    
    int main()
    
    { 
    
    int t; 
    
    scanf("%d", &t); 
    
    while(t--) 
    
    {  
    
    	double h, H, D;  
    
    	scanf("%lf%lf%lf", &H, &h, &D);  
    
    	double left = 0, right = D * h / H;   
    
    	int size = 100;  
    
    	double mid, midmid, ans1, ans2; 
    
            while(size--)  
    
    	{    
    
    		mid = (left + right) / 2;    
    
    		midmid = (mid + right) / 2;      
    
    		ans1 = ((h*D-H*mid)/(H-h)*H)/((h*D-H*mid)/(H-h)+D)+mid;     
    
    		ans2 = ((h*D-H*midmid)/(H-h)*H)/((h*D-H*midmid)/(H-h)+D)+midmid;    
    
    		if(ans1 > ans2) right = midmid;     
    
            	else left = mid;  
    
    	}  
    
    	printf("%.3lf\n", ans1); 
    
    	}
    
    return 0;
    
    }
    
    


     

            这个基本上是模版吧,只是那个函数要自己去写,只要解决了这个函数,就一直让他循环求极值吧,差不多100次就可以找到这个点了。

     

    再来看一道题目

    hdu  2438Turn the corner

    Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
    Total Submission(s): 404    Accepted Submission(s): 103
    
    
    Problem Description
    Mr. West bought a new car! So he is travelling around the city.One day he comes to a vertical corner. The street he is currently in has a width x, the street he wants to turn to has a width y. The car has alength l and a width d. Can Mr. West go across the corner?
     
    Input
    Every line has four real numbers, x, y, l and w. Proceed to the end of file.
     
    Output
    If he can go across the corner, print "yes". Print "no" otherwise.
     
    Sample Input
    10 6 13.5 4
    10 6 14.5 4
     
     
    Sample Output
    yes
    no

           

     

     

             其实就是汽车能不能拐弯的问题,告诉你X, Y, l, d判断是否能够拐弯,由下图可知,如果d大于X,Y的话,那么怎么样汽车也过不了。接着就是三分求下图那个最值了,如果到了这个地步,所求的h还是比Y小的话,那么肯定是可以拐弯的。

     

    #include <cstdio>
    #include <cmath>
    const double pi = 3.1415926535;
    int main()
    {
          double x, y, l, w;
          while(scanf("%lf%lf%lf%lf", &x, &y, &l, &w) != EOF)
          {
                int size = 100;
                double left = 0, right = pi / 2;
                double mid = 0, midmid = 0, ans1, ans2;
                if(x < w || y < w){printf("no\n"); continue;}  
                while(size--)
                {
                      mid = (left+right) / 2;
                      midmid = (mid+right) / 2;
                      ans1 = (x-l*sin(mid)-w/cos(mid)) / tan(mid);
                      ans2 = (x-l*sin(midmid)-w/cos(midmid)) / tan(midmid);
                      if(ans1 < ans2) right = midmid;
                      else left = mid;
                }
                if(fabs(ans1) > y) printf("no\n");
                else printf("yes\n");
          }
    return 0;
    }
    

     
    这两题几乎就是用了三分的模版,然后就是简单的公式推导,然后就可以很方便的实现了,接着我们来看看稍微复杂点的吧。

    xmu 1125.越野车大赛

    Description

    TheBeet正在参加一场越野车大赛。比赛的场地如右图:共分三块,每一块地面的长宽均为NM,但地表情况不同,越野车在这段路面上的最高速度也不同。蓝色线表示TheBeet可能的行车路线。

    比赛的要求是要求选手从比赛的场地左上角驾车至右下角。TheBeet想知道如果他在所有路段都以最快速度行驶(不考虑加速阶段),最快能在多少时间内完成比赛。

    Input

      输入数据的第一行为两个正整数N M(N<=3000,M<=1000),表示一块路面的长和宽。
      第二行为三个正整数S1,S2,S3(0<S1,S2,S3<=100),从上至下依次表示各个路面上越野车的最高速度。

    Output

      输出一个实数表示TheBeet最快能在多少时间内完成比赛。请输出一个尽可能精确的数字,控制误差在±0.000001的内。

    Sample Input

    30 10
    2 5 3

    Sample Output

    13.7427361525

    Hint

      如果你的输出和结果的相差在0.000001之内,则认为是正确答案。

     

            分析下该题,其实也是要求求最值,不过这个最值是满足两个地方的要求,想想和三分有什么关系呢?其实还是一样的,只是这里要用到两个三分了,不仅仅满足第一个要求,第二个要求也要一并给他满足了,接着这样的最值就是题目所要求的了。下面是搓搓的代码:

     

    #include <iostream>
    #include <cstdio>
    #include <cmath>
    using namespace std;
    const double pi = 3.141592654;
    
    
    
    inline double dis(double x1, double y1, double x2, double y2)
    {
             return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }
    
     
    int main()
    {
             double n, m, a, b, c;
             while(cin >> n >> m)
             {
                      cin >> a >> b >> c;
                      double left1 = 0, right1 = pi / 2;
                      double mid1, midmid1, mid2, midmid2, ans1, ans11, ans2, ans3, ans4, ans5, ans44, ans55;
                      int size = 30;
                      while(size--)
                      {
                               mid1 = (left1 + right1) / 2;
                               midmid1 = (mid1 + right1) / 2;
                               ans1 = dis((n - m / tan(mid1)), m, n, 0);
                               ans11 = dis((n - m / tan(midmid1)), m, n, 0);
                               int size1 = 30;
                               double left2 = 0, right2 = pi / 2;
                               while(size1--)
                               {
                                        mid2 = (left2 + right2) / 2;
                                        midmid2 = (mid2 + right2) / 2;
                                        ans2 = dis((n - m / tan(mid1)), m, (n - m / tan(mid1) - m / tan(mid2)), 2*m);
                                        ans3 = dis((n - m / tan(mid1)), m, (n - m / tan(mid1)- m / tan(midmid2)), 2*m);
                                        ans4 = ans1 / c + ans2 / b + dis(0, 3*m, (n - m / tan(mid1) - m / tan(mid2)), 2*m) / a;
                                        ans5 = ans1 / c + ans3 / b + dis(0, 3*m, (n - m / tan(mid1) - m / tan(midmid2)), 2*m) / a;
                                        if(ans4 > ans5) left2 = mid2;
                                        else right2 = midmid2;
                               }
                               
    
    			left2 = 0, right2 = pi / 2;
             			size1 = 30;
             			while(size1--)
             			{
                      			mid2 = (left2 + right2) / 2;
                      			midmid2 = (mid2 + right2) / 2;
                       		ans2 = dis((n - m / tan(midmid1)), m, (n - m / tan(midmid1) - m / tan(mid2)), 2*m);
                      			ans3 = dis((n - m / tan(midmid1)), m, (n - m / tan(midmid1) - m / tan(midmid2)), 2*m);
                      			ans44 = ans11 / c + ans2 / b + dis(0, 3 * m, (n - m / tan(midmid1) - m / tan(mid2)), 2*m) / a;
                      			ans55 = ans11 / c + ans3 / b + dis(0, 3 * m, (n - m / tan(midmid1) - m / tan(midmid2)),2*m) /a;
                      			if(ans44 > ans55) left2 = mid2;
                      			else right2 = midmid2;
       			}
       			if(ans4 > ans44) left1 = mid1;
       			else right1 = midmid1;
      		}
      		printf("%.10lf\n", ans4);
     	}
    
    return 0;
    
    }
    
    


     

            至此,三分法就是这样的了,很简单吧,总结下,就是要求出那个公式,然后调用那个框架。只要理解了原理,题目都是换汤不换药的。小憩片刻,还是回公司看看书去吧。这时代,不看书,不多学点东西,会被时代淘汰的。。。。。。

     

     

     

    展开全文
  • 常用去除离群值的算法

    千次阅读 2019-07-23 16:57:41
    数据预处理的方法主要包括去极值、标准化、中性化。那么这里介绍以下常用的去离群值的方法,所谓离群值就是异常值,这个和极值其实并不一样。常用的剔除离群值的方法有MAD、、百分位法。参考资料:数据预处理(上)...

    1.引言:

           数据预处理的方法主要包括去极值、标准化、中性化。那么这里介绍以下常用的去离群值的方法,所谓离群值就是异常值,这个和极值其实并不一样。常用的剔除离群值的方法有MAD、3\sigma、百分位法。参考资料:数据预处理(上)之离群值处理、标准化数据预处理(下)之中性化

    2.MAD算法

            MAD,即median absolute deviation,可译为绝对中位值偏差。其大致思想是通过判断每一个元素与中位值的偏差是否处于合理的范围内来判断该元素是否为离群值。具体方法如下:

    (1)计算所有元素的中位值X_{median}

    (2)计算所有元素与中位值的绝对偏差:bias = \left | X_{i} -X_{median}|

    (3)取得绝对偏差的中位值MAD = bias_{median}

    (4)确定参数n,则可以对所有的数据作如下调整:

    在这里我没有调整离群值,而是直接将其剔除了。

    代码如下:

    import numpy as np
    
    # MAD法: media absolute deviation
    def MAD(dataset, n):
        median = np.median(dataset)  # 中位数
        deviations = abs(dataset - median)
        mad = np.median(deviations)
    
        remove_idx = np.where(abs(dataset - median) >  n * mad)
        new_data = np.delete(dataset, remove_idx)
    
        return new_data

    2.3\sigma

          3\sigma法又称为标准差法。标准差本身可以体现因子的离散程度,和MAD算法类似,只是3\sigma法用到的不是中位值,而是均值,并且n的取值为3,代码如下:

    # 3sigma法
    def three_sigma(dataset, n= 3):
        mean = np.mean(dataset)
        sigma = np.std(dataset)
    
        remove_idx = np.where(abs(dataset - mean) > n * sigma)
        new_data = np.delete(dataset, remove_idx)
    
        return new_data

    3.百分位法

           百分位计算的逻辑是将因子值进行升序的排序,对排位百分位高于97.5%或排位百分位低于2.5%的因子值,类似于比赛中”去掉几个最高分,去掉几个最低分“的做法。代码如下:这里参数采用的是20%和80%,具体取值,还需具体情况具体分析。

    # 百分位法:原始参数 min=0.025, max=0.975
    def percent_range(dataset, min= 0.20, max= 0.80):
        range_max = np.percentile(dataset, max * 100)
        range_min = -np.percentile(-dataset, (1 - min) * 100)
    
        # 剔除前20%和后80%的数据
        new_data = []
        for value in dataset:
            if value < range_max and value > range_min:
                new_data.append(value)
        return new_data

    这三个方法思路简单,易于实现,但是只能处理一维数据,接下来,再考虑更复杂但却更精准的可适用于多维数据的离群值处理方法!参考资料:离群点检测---基于kNN的离群点检测、LOF算法和CLOF算法

    展开全文
  • 使用pandas对算法进行了改进,速度比以前快了30倍。%%time# 导入函数库import jqdataimport numpy as npimport pandas as pdimport mathfrom statsmodels import regressionimport statsmodels.api as smimport ...

    使用pandas对算法进行了改进,速度比以前快了30倍。

    %%time

    # 导入函数库

    import jqdata

    import numpy as np

    import pandas as pd

    import math

    from statsmodels import regression

    import statsmodels.api as sm

    import matplotlib.pyplot as plt

    def winsorize(factor, std=3, have_negative = True):

    '''

    去极值函数

    factor:以股票code为index,因子值为value的Series

    std为几倍的标准差,have_negative 为布尔值,是否包括负值

    输出Series

    '''

    r=factor.dropna().copy()

    if have_negative == False:

    r = r[r>=0]

    else:

    pass

    #取极值

    edge_up = r.mean()+std*r.std()

    edge_low = r.mean()-std*r.std()

    r[r>edge_up] = edge_up

    r[r< edge_low] = edge_low

    return r

    #标准化函数:

    def standardize(s,ty=2):

    '''

    s为Series数据

    ty为标准化类型:1 MinMax,2 Standard,3 maxabs

    '''

    data=s.dropna().copy()

    if int(ty)==1:

    re = (data - data.min())/(data.max() - data.min())

    elif ty==2:

    re = (data - data.mean())/data.std()

    elif ty==3:

    re = data/10**np.ceil(np.log10(data.abs().max()))

    return re

    #中性化函数

    #传入:mkt_cap:以股票为index,市值为value的Series,

    #factor:以股票code为index,因子值为value的Series,

    #输出:中性化后的因子值series

    def neutralization(factor,mkt_cap = False, industry = True):

    df = pd.DataFrame([],index = factor.index)

    y = factor

    if type(mkt_cap) == pd.Series:

    LnMktCap = mkt_cap.apply(lambda x:math.log(x))

    if industry: #行业、市值

    dummy_industry = get_industry_exposure(df)

    x = pd.concat([LnMktCap,dummy_industry],axis = 1)

    else: #仅市值

    x = LnMktCap

    elif industry: #仅行业

    dummy_industry = get_industry_exposure(df)#API函数

    x = dummy_industry

    result = sm.OLS(y.astype(float),x.astype(float)).fit()

    return result.resid

    #为股票池添加行业标记,return df格式 ,为中性化函数的子函数

    def get_industry_exposure(df):

    df = df.copy()

    industry_index=jqdata.get_industries(name='sw_l1').index

    for i in range(0,len(industry_index)):

    codes = get_industry_stocks(industry_index[i],date='2020-07-17')

    if len(codes) == 0:

    s = pd.Series([0]*len(df), index = df.index)

    df[industry_index[i]] = s

    else:

    s = pd.Series([1]*len(codes), index = codes)

    df[industry_index[i]] = s

    return df.fillna(0)

    def get_win_stand_neutra(stocks):

    h=get_fundamentals(query(valuation.pb_ratio,valuation.code,valuation.market_cap)\

    .filter(valuation.code.in_(stocks)))

    stocks_pb_se=pd.Series(list(h.pb_ratio),index=list(h.code))

    stocks_pb_win_standse=standardize(winsorize(stocks_pb_se))

    stocks_mktcap_se=pd.Series(list(h.market_cap),index=list(h.code))

    stocks_neutra_se=neutralization(stocks_pb_win_standse,stocks_mktcap_se)#市值中性化

    return stocks_neutra_se

    #对沪深300成分股完成

    stocks=get_index_stocks('000300.XSHG')

    #stocks = get_all_securities(date = '2020-07-17').index

    print get_win_stand_neutra(stocks)

    2020-07-17

    展开全文
  • 前三种算法都属于概率性原理的算法(区别于工程优化里面的梯度下降,牛顿算法等连续直接的搜索算法,可以参考我这篇文章,求多元函数极值的情况分类与对应的算法),可以避免局部最优。 而禁忌搜索算法是靠禁忌表...
  • sift算法

    千次阅读 2013-08-29 15:29:07
    1、检测尺度空间极值点,初步确定关键点位置和所在尺度。 2、抽取稳定的关键点,精确确定关键点的位置和尺度,同时去除低对比度的关键点和不稳定的边缘响应点,以增强匹配稳定性、提高抗噪声能力。 3、为每个关键点...
  • 算法采用Copula函数刻画随机因子间的相关结构,支持粒子合理利用自身经验信息和群体共享信息,解决了粒子群优化算法在寻优过程中没有考虑随机因子作用而造成全局优化能力不足的缺陷;采用添加极值扰动算子的策略,...
  • AD数据采集滤波算法

    2020-04-14 21:02:58
    背景知识 数字滤波常应用实时低通滤波,硬件滤波常应用于实时高通滤波。 在设计滤波算法时,应考虑采用速度、干扰类型(脉冲干扰、周期性干扰)、采用数据变化特性(如变化速度、变化方向速度)...去极值平均滤波 N:...
  • RMQ问题——ST算法

    2017-10-21 10:25:12
    前言 例题 problem ST算法 核心的预处理 how to 询问 code前言OI竞赛里常考到区间极值...这篇blog讲的是ST算法(我曾经写过线段树的blog,有兴趣可以看看)不墨迹,直接上例题吧例题problem题目描述2008年9月25日
  • 这道题目可以使用三分法求凸函数极值解决,(否则就要用那些机器学习的算法去做)。 但这道题目是二元函数,这个时候可以考虑偏导的含义,先控制一个变量不变,让另一个变量变化得出一个极值,几何意义上其实就是用x=...
  • 算法基于三维光场重建的深度图像序列,采用双边滤波及插值算法对图像进行去除噪声,利用基于边缘曲率极值的角点检测算法,并通过最小曲率偏差的列间度量匹配实现了图像之间的精确配准,采用改进的加权平均方法对...
  • 仍记得当初写了一篇去除极值的均值滤波算法相关的博客,该算法用在了ADC采样上面。当初偶然看见还有一种递推均值滤波算法,用在了实时波形输出上面。没有代码实现,本着早晚会用到以及要使用抽象数据类型队列的想法...
  • 目的:使用一个线性函数拟合上面这些数据;该线性函数如下只有两个参数,利用梯度下降找出使损失值最小时,对应的两个参数值,即得到了线性函数。算法三要素:1)设置线性函数,即假设函数(Hypothesis);2)选定...
  • 数值试验 算法中使人工鱼逃逸局部极值实现全局寻优的因素主要有以下几种 觅食行为中try_number的次数较少时为人工鱼提供了随机游动的机 会从而能跳出局部极值的邻域; 随机步长的采用使得在前往局部极值的途中有可能...
  • 细菌觅食优化算法

    2019-03-18 19:56:37
    消耗掉,这些必然导致细菌被迫迁移到新的区域 寻找食物,在模型中表现为迁移操作。 这种迁移未 必导致细菌寻找不到新的食物,反而会对种群的良 好生长起到促进作用,在经过复制操作之后细菌若 按照一定的概率进行迁移,...
  • 考虑到个体之间的相互影响关系,每个粒子的个体极值用所有粒子个体极值的平均值代替。通过几个典型测试函数仿真及F-检验结果表明,提出的算法在搜索速度、收敛精度、鲁棒性方面较已有改进算法有了显著提高,并且具有...
  • Benders分解算法详解

    千次阅读 2020-08-01 15:36:32
    最近在学习Benders Decomposition,看了不少的文章博客,但我感觉写的都不是很清楚,细节地方解释的也不够到位,于是就读了英文论文原文,发现原文写的还是相当清楚的。本文也基于那篇论文,对Benders ...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 191
精华内容 76
关键字:

去极值算法