精华内容
下载资源
问答
  • 上一版非径向距离函数在这 普通非径向距离函数 现在很多研究在测度效率时要考虑非期望产出,如环境技术中CO2排放,银行业中的不良贷款等,这里我写了一个考虑非期望产出的非径向距离函数 class DEAProblem: def __...

    点赞发Nature
    关注中Science

    上一版非径向距离函数在这
    普通非径向距离函数

    现在很多研究在测度效率时要考虑非期望产出,如环境技术中CO2排放,银行业中的不良贷款等,这里我写了一个考虑非期望产出的非径向距离函数

    import numpy as np
    import pandas as pd
    import pulp
    
    class DEAProblem:
        def __init__(
            self,
            inputs,
            outputs,
            bad_outs,
            weight_vector,
            directional_factor=None,
            returns="CRS",
            disp="weak disposability",
            in_weights=[0, None],
            out_weights=[0, None],
            badout_weights=[0, None],
        ):
            self.inputs = inputs
            self.outputs = outputs
            self.bad_outs = bad_outs
            self.returns = returns
            self.weight_vector = (
                weight_vector  # weight vector in directional distance function
            )
            self.disp = disp
    
            self.J, self.I = self.inputs.shape  # no of DMUs, inputs
            _, self.R = self.outputs.shape  # no of outputs
            _, self.S = self.bad_outs.shape  # no of bad outputs
            self._i = range(self.I)  # inputs
            self._r = range(self.R)  # outputs
            self._s = range(self.S)  # bad_output
            self._j = range(self.J)  # DMUs
            if directional_factor == None:
                self.gx = self.inputs
                self.gy = self.outputs
                self.gb = self.bad_outs
            else:
                self.gx = directional_factor[: self.I]
                self.gy = directional_factor[self.I : (self.I + self.J)]
                self.gy = directional_factor[(self.I + self.J) :]
    
            self._in_weights = in_weights  # input weight restrictions
            self._out_weights = out_weights  # output weight restrictions
            self._badout_weights = badout_weights  # bad output weight restrictions
    
            # creates dictionary of pulp.LpProblem objects for the DMUs
            self.dmus = self._create_problems()
    
        def _create_problems(self):
            """
            Iterate over the DMU and create a dictionary of LP problems, one
            for each DMU.
            """
    
            dmu_dict = {}
            for j0 in self._j:
                dmu_dict[j0] = self._make_problem(j0)
            return dmu_dict
    
        def _make_problem(self, j0):
            """
            Create a pulp.LpProblem for a DMU.
            """
    
            # Set up pulp
            prob = pulp.LpProblem("".join(["DMU_", str(j0)]), pulp.LpMaximize)
            self.weights = pulp.LpVariable.dicts(
                "Weight", (self._j), lowBound=self._in_weights[0]
            )
            self.betax = pulp.LpVariable.dicts(
                "scalingFactor_x", (self._i), lowBound=0, upBound=1
            )
    
            self.betay = pulp.LpVariable.dicts("scalingFactor_y", (self._r), lowBound=0)
    
            self.betab = pulp.LpVariable.dicts(
                "scalingFactor_b", (self._s), lowBound=0, upBound=1
            )
    
            # Set returns to scale
            if self.returns == "VRS":
                prob += pulp.lpSum([self.weights[j] for j in self.weights]) == 1
    
            # Set up objective function
            prob += pulp.lpSum(
                [(self.weight_vector[i] * self.betax[i]) for i in self._i]
                + [(self.weight_vector[self.I + r] * self.betay[r]) for r in self._r]
                + [
                    (self.weight_vector[self.I + self.R + s] * self.betab[s])
                    for s in self._s
                ]
            )
    
            # Set up constraints
            for i in self._i:
                prob += (
                    pulp.lpSum(
                        [(self.weights[j0] * self.inputs.values[j0][i]) for j0 in self._j]
                    )
                    <= self.inputs.values[j0][i] - self.betax[i] * self.gx.values[j0][i]
                )
            for r in self._r:
                prob += (
                    pulp.lpSum(
                        [(self.weights[j0] * self.outputs.values[j0][r]) for j0 in self._j]
                    )
                    >= self.outputs.values[j0][r] + self.betay[r] * self.gy.values[j0][r]
                )
    
            if self.disp == "weak disposability":
                for s in self._s:  # weak disposability
                    prob += (
                        pulp.lpSum(
                            [
                                (self.weights[j0] * self.bad_outs.values[j0][s])
                                for j0 in self._j
                            ]
                        )
                        == self.bad_outs.values[j0][s]
                        - self.betab[s] * self.gb.values[j0][s]
                    )
    
            elif self.disp == "strong disposability":
                for s in self._s:  # strong disposability
                    prob += (
                        pulp.lpSum(
                            [
                                (self.weights[j0] * self.bad_outs.values[j0][s])
                                for j0 in self._j
                            ]
                        )
                        >= self.bad_outs.values[j0][s]
                        - self.betab[s] * self.gb.values[j0][s]
                    )
    
            return prob
    
        def solve(self):
            """
            Iterate over the dictionary of DMUs' problems, solve them, and collate
            the results into a pandas dataframe.
            """
    
            sol_status = {}
            sol_weights = {}
            sol_efficiency = {}
    
            for ind, problem in list(self.dmus.items()):
                problem.solve()
                sol_status[ind] = pulp.LpStatus[problem.status]
                sol_weights[ind] = {}
                for v in problem.variables():
                    sol_weights[ind][v.name] = v.varValue
                sol_efficiency[ind] = pulp.value(problem.objective)
            return sol_status, sol_efficiency, sol_weights
    

    简单说,这是一个考虑弱处置性的NDDF模型,input就是决策单元的输入,output是决策单元的输出,bad_outs是决策单元的非期望产出, weight_vector是计算距离函数的权重向量。

    你们可以测试一下,有什么问题、有什么思路都可以联系我交流,我还在持续更新中。

    希望以后能做成一个比较完整的开源模块给大家用。

    举个例子

    X = pd.DataFrame(
        np.array(
            [
                [20, 300],
                [30, 200],
                [40, 100],
                [20, 200],
                [10, 400],
                [11, 222],
                [12, 321],
                [14, 231],
            ]
        )
    )
    y = pd.DataFrame(np.array([[20], [30], [40], [30], [50], [21], [32], [42]]))
    b = pd.DataFrame(np.array([[10], [20], [10], [10], [10], [12], [-2], [-1]]))
    weight = [1 / 6, 1 / 6, 1 / 3, 1 / 3]
    names = pd.DataFrame(
        ["Bratislava", "Zilina", "Kosice", "Presov", "Poprad", "ala", "ba", "ca"],
        columns=["DMU"],
    )
    
    solve = DEAProblem(X, y, b, weight, disp="weak disposability").solve()
    
    status = pd.DataFrame.from_dict(solve[0], orient="index", columns=["status"])
    efficiency = pd.DataFrame.from_dict(solve[1], orient="index", columns=["efficiency"])
    weights = pd.DataFrame.from_dict(solve[2], orient="index")
    results = pd.concat([names, status, efficiency, weights], axis=1)
    
    print(results.round(decimals=4))
    
     DMU   status  efficiency  Weight_0  Weight_1  Weight_2  Weight_3  
    0  Bratislava  Optimal      0.9182       0.0       0.0    0.0728       0.0   
    1      Zilina  Optimal      0.5078       0.0       0.0    0.0830       0.0   
    2      Kosice  Optimal      0.0000       0.0       0.0    1.0000       0.0   
    3      Presov  Optimal      0.4663       0.0       0.0    0.0830       0.0   
    4      Poprad  Optimal      0.0000       0.0       0.0    0.0000       0.0   
    5         ala  Optimal      0.5646       0.0       0.0    0.0000       0.0   
    6          ba  Optimal      0.4458       0.0       0.0    0.0000       0.0   
    7          ca  Optimal      0.0000       0.0       0.0    0.0000       0.0   
    

    Cite the work

    Yang, F.; Choi, Y.: Lee, H. Life-cycle data envelopment analysis to measure efficiency and cost-effectiveness of environmental regulation in China’s transport sector. Ecological indicators 2021
    Choi, Y.; Yang, F.; Lee, H. On the Unbalanced Atmospheric Environmental Performance of Major Cities in China. Sustainability 2020, 12, 5391. https://doi.org/10.3390/su12135391

    ————————update 2020/12/4——————————
    更新了VRS的计算方法
    from

            if self.returns == "VRS":
                prob += pulp.lpSum([weight for weight in self.weights]) == 1
    

    to

            if self.returns == "VRS":
                prob += pulp.lpSum([self.weights[j] for j in self.weights]) == 1
    

    ————————
    我是仁荷大学的经管博士生(我的google scholar, 我的Github),关注能源转型过程中的环境、经济问题。

    专注于分享利用python科研的技巧,欢迎一起交流、学习、合作。

    关于我的博客内容、其他相关的研究问题,有问题可以下方👇评论、或私信我~

    展开全文
  • 径向距离函数 考虑非期望产出的非径向距离函数 这一版更新比较简单,增加了强处置性假设下的非径向距离函数(NDDF)计算。比较强\弱处置假设下的NDDF,可以计算相应的环境规制成本[ Technological Forecasting &...

    点赞发Nature
    关注中Science

    Matlab DEA 程序包
    pyDEA安装
    非径向距离函数
    考虑非期望产出的非径向距离函数

    这一版更新比较简单,增加了强处置性假设下的非径向距离函数(NDDF)计算。比较强\弱处置假设下的NDDF,可以计算相应的环境规制成本[ Technological Forecasting & Social Change 96 (2015) 62–70].

    import numpy as np
    import os
    import pandas as pd
    import pickle
    import pulp
    import time
    
    def read_excel(iteration):
        dea_inout = pd.read_excel(
            os.path.join(dir_data, xls), sheet_name=str(iteration), header=0
        )
        return dea_inout
    
    class DEAProblem:
        def __init__(self, inputs, outputs, bad_outs, weight_vector,  disp='weak disposability', directional_factor=None, returns='CRS',
                     in_weights=[0, None], out_weights=[0, None],badout_weights=[0, None]):
            self.inputs = inputs
            self.outputs = outputs
            self.bad_outs = bad_outs
            self.returns = returns
            self.disp = disp
            self.weight_vector = weight_vector # weight vector in directional distance function      
            
            self.J, self.I = self.inputs.shape  # no of DMUs, inputs
            _, self.R = self.outputs.shape  # no of outputs
            _, self.S = self.bad_outs.shape # no of bad outputs
            self._i = range(self.I)  # inputs
            self._r = range(self.R)  # outputs
            self._s = range(self.S)  # bad_output
            self._j = range(self.J)  # DMUs
            if directional_factor == None:
                self.gx = self.inputs
                self.gy = self.outputs
                self.gb = self.bad_outs
            else:
                self.gx = directional_factor[:self.I]
                self.gy = directional_factor[self.I:(self.I+self.J)]
                self.gy = directional_factor[(self.I+self.J):]
    
            
            self._in_weights = in_weights  # input weight restrictions
            self._out_weights = out_weights  # output weight restrictions
            self._badout_weights = badout_weights # bad output weight restrictions
            
            # creates dictionary of pulp.LpProblem objects for the DMUs
            self.dmus = self._create_problems()
        
        def _create_problems(self):
            """
            Iterate over the DMU and create a dictionary of LP problems, one
            for each DMU.
            """
    
            dmu_dict = {}
            for j0 in self._j:
                dmu_dict[j0] = self._make_problem(j0)
            return dmu_dict
        
        def _make_problem(self, j0):
            """
            Create a pulp.LpProblem for a DMU.
            """
    
            # Set up pulp
            prob = pulp.LpProblem("".join(["DMU_", str(j0)]), pulp.LpMaximize)
            self.weights = pulp.LpVariable.dicts("Weight", (self._j),
                                                      lowBound=self._in_weights[0])
            self.betax = pulp.LpVariable.dicts("scalingFactor_x", (self._i),
                                                      lowBound=0,upBound=1)
    
            self.betay = pulp.LpVariable.dicts("scalingFacotr_y", (self._r),
                                                      lowBound=0)
       
            self.betab = pulp.LpVariable.dicts("scalingFacotr_b", (self._s),
                                                      lowBound=0, upBound=1)
            
            # Set returns to scale
            if self.returns == "VRS":
                prob += pulp.lpSum([weight for weight in self.weights]) == 1
    
            # Set up objective function      
            prob += pulp.lpSum([(self.weight_vector[i]*self.betax[i]) for i in self._i]
                               +[(self.weight_vector[self.I+r]*self.betay[r]) for r in self._r]
                              +[(self.weight_vector[self.I+self.R+s]*self.betab[s]) for s in self._s])
    
            # Set up constraints
            for i in self._i:
                prob += pulp.lpSum([(self.weights[j0]*
                                                  self.inputs.values[j0][i]) for j0 in self._j]) <= self.inputs.values[j0][i]-self.betax[i]*self.gx.values[j0][i]
            for r in self._r:
                prob += pulp.lpSum([(self.weights[j0]*
                                                  self.outputs.values[j0][r]) for j0 in self._j]) >= self.outputs.values[j0][r]+self.betay[r]*self.gy.values[j0][r]
            
            if  self.disp == "weak disposability":  
                for s in self._s:   # weak disposability
                    prob += pulp.lpSum([(self.weights[j0]*
                                                    self.bad_outs.values[j0][s]) for j0 in self._j]) == self.bad_outs.values[j0][s]-self.betab[s]*self.gb.values[j0][s]
            
            elif self.disp =="strong disposability":
                for s in self._s:
                    prob += pulp.lpSum([(self.weights[j0]*
                                                    self.bad_outs.values[j0][s]) for j0 in self._j]) >= self.bad_outs.values[j0][s]-self.betab[s]*self.gb.values[j0][s] 
            return prob
        
        def solve(self):
            """
            Iterate over the dictionary of DMUs' problems, solve them, and collate
            the results into a pandas dataframe.
            """
    
            sol_status = {}
            sol_weights = {}
            sol_efficiency = {}
    
            for ind, problem in list(self.dmus.items()):
                problem.solve()
                sol_status[ind] = pulp.LpStatus[problem.status]
                sol_weights[ind] = {}
                for v in problem.variables():
                    sol_weights[ind][v.name] = v.varValue
                sol_efficiency[ind] = pulp.value(problem.objective)
            return sol_status, sol_efficiency, sol_weights
    
    def inout_data(iteration, data_columnslist):
        dea_data = read_excel(iteration)
        data_df = dea_data.loc[:, data_columnslist]
        return data_df
    
    def results_df(inputs, outputs, undesirable_output, weight, names, disp):
        solve = DEAProblem(inputs, outputs, undesirable_output, weight,disp).solve()
        status = pd.DataFrame.from_dict(solve[0], orient="index", columns=["status"])
        efficiency = pd.DataFrame.from_dict(
            solve[1], orient="index", columns=["efficiency"]
        )
        weight = pd.DataFrame.from_dict(solve[2], orient="index")
        results = pd.concat([names, status, efficiency, weight], axis=1)
        return results.round(decimals=4)
    
    dir_data = r"~\Data_input"
    xls = r"DEA_inout.xlsx"
    
    input_columns = ["a", "b", "c"]
    output_columns = ["d"]
    undesirable_outputs = ["e", "f"]
    weight = [0, 0, 1 / 3, 1 / 3, 1 / 6, 1 / 6]
    names = ["DMU name"]
    iteration = 1000
    
    

    Cite the work

    Yang, F.; Choi, Y.: Lee, H. Life-cycle data envelopment analysis to measure efficiency and cost-effectiveness of environmental regulation in China’s transport sector. Ecological indicators 2021. https://doi.org/10.1016/j.ecolind.2021.107717
    Choi, Y.; Yang, F.; Lee, H. On the Unbalanced Atmospheric Environmental Performance of Major Cities in China. Sustainability 2020, 12, 5391. https://doi.org/10.3390/su12135391

    ————————
    我是仁荷大学的博士生(我的google scholar, 我的Github),关注能源转型过程中的环境、经济问题。

    专注于分享利用python科研的技巧,欢迎一起交流、学习、合作。

    关于我的博客内容、其他相关的研究问题,有问题可以下方👇评论、或私信我~

    展开全文
  • 最近在想怎么用python实现非径向距离函数 之前用了pyDEA包https://pypi.org/project/pyDEA/,那个包比较简陋,只有普通的CCR BCC模型。 另一方面,MaxDEA因为是打包好的嘛,所以不够灵活。所以想自己做一个NDDF的...

    点赞发Nature
    关注中Science

    最近在想怎么用python实现非径向距离函数

    之前用了pyDEA包https://pypi.org/project/pyDEA/,那个包比较简陋,只有普通的CCR BCC模型。

    另一方面,MaxDEA因为是打包好的嘛,所以不够灵活。所以想自己做一个NDDF的模型出来。

    所以用pyDEA的初始代码进行了一些改造,直接上代码:

    import numpy as np
    import pandas as pd
    import pulp
    
    class DEAProblem:
        def __init__(self, inputs, outputs, weight_vector, directional_factor=None, returns='CRS',
                     in_weights=[0, None], out_weights=[0, None]):
            self.inputs = inputs
            self.outputs = outputs
            self.returns = returns
            self.weight_vector = weight_vector # weight vector in directional distance function      
            
            self.J, self.I = self.inputs.shape  # no of DMUs, inputs
            _, self.R = self.outputs.shape  # no of outputs
            self._i = range(self.I)  # inputs
            self._r = range(self.R)  # outputs
            self._j = range(self.J)  # DMUs
            if directional_factor == None:
                self.gx = self.inputs
                self.gy = self.outputs
            else:
                self.gx = directional_factor[:self.I]
                self.gy = directional_factor[-self.J:]
    
            
            self._in_weights = in_weights  # input weight restrictions
            self._out_weights = out_weights  # output weight restrictions
    
            # creates dictionary of pulp.LpProblem objects for the DMUs
            self.dmus = self._create_problems()
        
        def _create_problems(self):
            """
            Iterate over the DMU and create a dictionary of LP problems, one
            for each DMU.
            """
    
            dmu_dict = {}
            for j0 in self._j:
                dmu_dict[j0] = self._make_problem(j0)
            return dmu_dict
        
        def _make_problem(self, j0):
            """
            Create a pulp.LpProblem for a DMU.
            """
    
            # Set up pulp
            prob = pulp.LpProblem("".join(["DMU_", str(j0)]), pulp.LpMaximize)
            self.weights = pulp.LpVariable.dicts("Weight", (self._j),
                                                      lowBound=self._in_weights[0])
            self.betax = pulp.LpVariable.dicts("scalingFactor_x", (self._i),
                                                      lowBound=0)
    
            self.betay = pulp.LpVariable.dicts("scalingFacotr_y", (self._r),
                                                      lowBound=0)
            
            
            # Set returns to scale
            if self.returns == "VRS":
                prob += pulp.lpSum([weight for weight in self.weights]) == 1
    
            # Set up objective function      
            prob += pulp.lpSum([(self.weight_vector[i]*self.betax[i]) for i in self._i]+[(self.weight_vector[self.I+r]*self.betay[r]) for r in self._r])
    
            # Set up constraints
            for i in self._i:
                prob += pulp.lpSum([(self.weights[j0]*
                                                  self.inputs.values[j0][i]) for j0 in self._j]) <= self.inputs.values[j0][i]-self.betax[i]*self.gx.values[j0][i]
            for r in self._r:
                prob += pulp.lpSum([(self.weights[j0]*
                                                  self.outputs.values[j0][r]) for j0 in self._j]) >= self.outputs.values[j0][r]+self.betay[r]*self.gy.values[j0][r]
            
            return prob
        
        def solve(self):
            """
            Iterate over the dictionary of DMUs' problems, solve them, and collate
            the results into a pandas dataframe.
            """
    
            sol_status = {}
            sol_weights = {}
            sol_efficiency = {}
    
            for ind, problem in list(self.dmus.items()):
                problem.solve()
                sol_status[ind] = pulp.LpStatus[problem.status]
                sol_weights[ind] = {}
                for v in problem.variables():
                    sol_weights[ind][v.name] = v.varValue
                sol_efficiency[ind] = pulp.value(problem.objective)
            return sol_status, sol_efficiency, sol_weights
    
    solve = DEAProblem(X, y, weight).solve()
    

    计算结果
    该模块依据了这个公式:
    NDDF公式
    文章是张宁老师13年发表在RESR上的综述,

    该模块可以自行设定投入X, 产出Y, 方向向量g, 以及权重向量w

    后续还得考虑把undesirable output也加入进去。

    我在编程的时候发现产出扩张系数是有可能大于1的,我以前一直以为扩张系数就是无效率值,发现还是有些不一样的。

    ——————update——————
    考虑非期望产出的NDDF
    考虑强\弱处置性的非期望产出NDDF

    Cite the work

    Yang, F.; Choi, Y.: Lee, H. Life-cycle data envelopment analysis to measure efficiency and cost-effectiveness of environmental regulation in China’s transport sector. Ecological indicators 2021
    Choi, Y.; Yang, F.; Lee, H. On the Unbalanced Atmospheric Environmental Performance of Major Cities in China. Sustainability 2020, 12, 5391. https://doi.org/10.3390/su12135391

    ————————
    我是仁荷大学的博士生(我的google scholar, 我的Github),关注能源转型过程中的环境、经济问题。

    专注于分享利用python科研的技巧,欢迎一起交流、学习、合作。

    关于我的博客内容、其他相关的研究问题,有问题可以下方👇评论、或私信我~

    展开全文
  • RBF径向函数

    万次阅读 2018-07-02 19:10:19
    一、径向基函数径向基函数是某种沿径向对称的标量函数,通常定义为样本到数据中心之间径向距离(通常是欧氏距离)的单调函数(由于距离是径向同性的)。RBF核是一种常用的核函数。它是支持向量机分类中最为常用的核...

    一、径向基函数

    径向基函数是某种沿径向对称的标量函数,通常定义为样本到数据中心之间径向距离(通常是欧氏距离)的单调函数(由于距离是径向同性的)。RBF核是一种常用的核函数。它是支持向量机分类中最为常用的核函数。常用的高斯径向基函数形如:

    其中,可以看做两个特征向量之间的平方欧几里得距离。x’为核函数中心,是一个自由参数,是函数的宽度参数 , 控制了函数的径向作用范围。。一种等价但更为简单的定义是设一个新的参数 \gamma,其表达式为

    因为RBF核函数的值随距离减小,并介于0(极限)和1(当x = x’的时候)之间,所以它是一种现成的相似性度量表示法。核的特征空间有无穷多的维数;对于 =1,它的展开式为:

    径向基函数二维图像:
    RBF核
    RBF 拥有较小的支集。针对选定的样本点,它只对样本附近的输入有反应,如下图。
    这里写图片描述
    RBF 使样本点只被附近(圈内)的输入激活。
    T. Poggio 将 RBF 比作记忆点。与记忆样本越近,该记忆就越被激活。
    RBF 核与多项式核相比具有参数少的优点。因为参数的个数直接影响到模型选择的复杂性。
    其他的径向基函数有:
    Reflected Sigmoidal(反常S型)函数:

    Inverse multiquadrics(拟多二次)函数:

    σ称为径向基函数的扩展常数,它反应了函数图像的宽度,σ越小,宽度越窄,函数越具有选择性。

    二、径向基网络

    RBF(Radial Basis Function,径向基)网络是一种单隐层前馈神经网络,它使用径向基函数作为隐层神经元激活函数,而输出层则是对隐层神经元输出的线性组合。径向基函数网络具有多种用途,包括包括函数近似法、时间序列预测、分类和系统控制。他们最早由布鲁姆赫德(Broomhead)和洛维(Lowe)在1988年建立。
    RBF网络分为标准RBF网络,即隐层单元数等于输入样本数;和广义RBF网络,即隐层单元数小于输入样本数。但广义RBF的隐藏层神经元个数大于输入层神经元个数,因为在标准RBF网络中,当样本数目很大时,就需要很多基函数,权值矩阵就会很大,计算复杂且容易产生病态问题。
    径向基网络:
    径向基网络

    RBF神经网络的基本思想:用RBF作为隐单元的“基”构成隐藏层空间,隐藏层对输入矢量进行变换,将低维的模式输入数据变换到高维空间内,使得在低维空间内的线性不可分问题在高维空间内线性可分。详细一点就是用RBF的隐单元的“基”构成隐藏层空间,这样就可以将输入矢量直接(不通过权连接)映射到隐空间。当RBF的中心点确定以后,这种映射关系也就确定 了。而隐含层空间到输出空间的映射是线性的(注意这个地方区分一下线性映射和非线性映射的关系),即网络输出是隐单元输出的线性加权和,此处的权即为网络可调参数。
    通常采用两步过程来训练RBF网络:第一步,确定神经元中心,常用的方式包括随机采样、聚类等;第二步,利用BP算法等来确定参数。
    [Park and Sandberg,1991]证明,具有足够多隐层神经元的RBF网络能以任意精度逼近任意连续函数。
    且RBF网络可以处理系统内的难以解析的规律性,具有良好的泛化能力,并有很快的学习收敛速度。
    RBF网络学习收敛得比较快的原因:当网络的一个或多个可调参数(权值或阈值)对任何一个输出都有影响时,这样的网络称为全局逼近网络。由于对于每次输入,网络上的每一个权值都要调整,从而导致全局逼近网络的学习速度很慢。BP网络就是一个典型的例子。如果对于输入空间的某个局部区域只有少数几个连接权值影响输出,则该网络称为局部逼近网络。常见的局部逼近网络有RBF网络、小脑模型(CMAC)网络、B样条网络等。

    三、参数计算

    中心点的计算:
    标准RBF的样本点即为中心
    广义RBF的中心点通过随机采用、聚类等方法确定
    w和β的计算:
    人为指定:所有神经元的β都一样,β=1/2(的平方),=dmax/根号下的2M。dmax为任意两个样本点距离的最大值,M为样本个数。
    BP算法迭代确定。

    四、RBF神经网络与SVM with RBF Kernel的区别和联系:

    从模型上看,区别不大,区别在于训练方式。
    RBF神经网络训练分两阶段。第一阶段为非监督学习,从数据中选取记忆样本(上上图中的紫色中心)。例如聚类算法可在该阶段使用。第二阶段为监督学习,训练记忆样本与样本输出的联系。该阶段根据需要可使用 AD/BP。(AD,即 Automatic Differentiation (Backpropagation) )

    展开全文
  • 径向分布函数

    万次阅读 热门讨论 2018-10-14 17:22:15
    径向分布函数RDF实现算法 RDF实现算法 RDF是径向分布函数的Radical distribution function的缩写,指的是给定一个空间,在此空间以一个对象为中心,去寻找周围对象的的概率。对于分子模拟的径向分布函数实则也是求解...
  • 径向函数

    2020-11-27 08:49:47
    任意一个满足Φ(x)=Φ(||x||)特性的函数Φ都叫做径向基函数,标准的一般使用欧式距离(也叫做欧式径向基函数),尽管其他距离函数也是可以的。在神经网络结构中,可以作为全连接层和ReLU层的主要函数。 一些径向...
  • 任意一个满足Φ(x)=Φ(‖x‖)特性的函数Φ都叫做径向基函数,标准的一般使用欧氏距离(也叫做欧式径向基函数),尽管其他距离函数也是可以的。在神经网络结构中,可以作为全连接层和ReLU层的主要函数。
  • 高斯径向函数(RBF)神经网络

    万次阅读 多人点赞 2019-04-03 00:53:52
    高斯径向函数(RBF)神经网络 牛顿插值法-知乎 ...说径向基网络之前,先聊下径向函数径向函数(英语:radial basis function,缩写为RBF)是一个取值仅依赖于到原点距离的实值函数,即 ϕ(x...
  • 人工神经网络——径向函数(RBF)神经网络

    万次阅读 多人点赞 2015-10-24 15:32:45
    径向函数神经网络的优点:逼近能力,分类能力和学习速度等方面都优于BP神经网络,结构简单、训练简洁、学习收敛速度快、能够逼近任意非线性函数,克服局部极小值问题。原因在于其参数初始化具有一定的方法,并非...
  • 径向函数分类

    千次阅读 2018-04-12 16:04:56
    目前,最常用的径向函数是高斯核函数,其公式如下: 其中,xc为中心点坐标,x为待分类的坐标,||x-xc||为欧几里得距离,σ为可调的宽度参数。python代码:#径向函数,gamma=1/(2*σ)^2def rbf(v1,v2,gamma=10): ...
  • 高斯径向函数的理解

    万次阅读 2016-12-01 20:02:06
    高斯径向函数的理解 提出问题 有这样一个函数f(x,y)为:P(x,y)->R,也就是函数f为二维空间上的一个点到实数集R上的映射。现在我们给出一些这样的训练实例即给出一些[p(x,y),f(x,y)],怎么来确定f.显然不能确定,...
  • 径向函数神经网络是不同于BP神经网络的另一种的前馈神经网络,由输入层、一层非线性隐层(径向基层)和线性输出层组成的。 关于径向函数神经网络,首先要介绍一个定理,cover定理,对于一个复杂的在低维空间...
  • 径向函数神经网络(RBFNN)详解

    万次阅读 多人点赞 2019-09-13 16:29:05
    径向函数神经网络(RBFNN) 前言 RBFNN是20世纪80年代末提出的一种单隐层、以函数逼近为基础的前馈神经网络。随着研究日渐成熟,RBFNN以其结构简单、非线性逼近能力强以及良好的推广能力,受到各领域研究者的极...
  • 径向函数(RBF)

    千次阅读 2016-12-06 15:29:04
    径向函数的基本概念公式进行阐述
  • 径向函数 定义:某种沿镜像对称的标量函数。(Radial Basis Function) 设定一个中心点xc,空间中任一点x到xc之间的欧式距离的单调函数成为径向函数。 k(||x-xc||) #径向函数公示 ...
  • 机器学习——径向函数

    千次阅读 2017-04-10 08:52:54
    径向函数是关于空间中点的函数,且函数值只和距离原点的距离有关(一般使用欧式距离)。径向函数的表达式为: ϕ(x)=ϕ(||x||)\phi(x)=\phi(||x||)
  • 高斯核函数径向函数

    万次阅读 2014-02-26 11:20:47
    通常定义为空间中任一点x到某一中心xc之间欧氏距离的单调函数 , 可记作 k(||x-xc||), 其作用往往是局部的 , 即当x远离xc时函数取值很小。最常用的径向函数是高斯核函数 ,形式为 k(||x-xc||)=exp{- ||x-xc||^2/(2*...
  • 径向函数(RBF)

    2013-05-30 12:48:00
    Radial basis function(径向基...任意一个满足Φ(x)=Φ(‖x‖)特性的函数Φ都叫做径向量函数,标准的一般使用欧氏距离,尽管其他距离函数也是可以的。 一些径向函数代表性的用到近似给定的函数,这种近似可以...
  • 其中q为隐层神经元个数,Ci和ωi分别是第i个隐层神经元所对应的中心和权重,ρ(x,Ci)是径向函数,这是某种沿径向对称的标量函数,通常定义为样本x到数据中心Ci之间的欧氏距离的单调函数。常用的高斯径向函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,960
精华内容 3,184
关键字:

径向距离函数