径向距离函数

python DEA: 考虑非期望产出的非径向距离函数NDDF

千次阅读 2020-07-08 15:05:55

上一版非径向距离函数在这普通非径向距离函数 现在很多研究在测度效率时要考虑非期望产出，如环境技术中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科研的技巧，欢迎一起交流、学习、合作。
关于我的博客内容、其他相关的研究问题，有问题可以下方👇评论、或私信我~

收起

展开全文

python DEA:强/弱处置性假设下的考虑非期望产出的非径向距离函数

热门讨论 2020-07-23 09:18:03

非径向距离函数 考虑非期望产出的非径向距离函数 这一版更新比较简单，增加了强处置性假设下的非径向距离函数（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 DEA: 非径向距离函数（non-radial directional distance function）

千次阅读 2020-07-01 09:20:00

最近在想怎么用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()



该模块依据了这个公式：



文章是张宁老师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的缩写，指的是给定一个空间，在此空间以一个对象为中心，去寻找周围对象的的概率。对于分子模拟的径向分布函数实则也是求解...
收起
C++ 算法
径向基函数
2020-11-27 08:49:47
任意一个满足Φ（x）=Φ（||x||）特性的函数Φ都叫做径向基函数，标准的一般使用欧式距离（也叫做欧式径向基函数），尽管其他距离函数也是可以的。在神经网络结构中，可以作为全连接层和ReLU层的主要函数。一些径向...
收起
径向基函数网络matlab程序
2020-04-21 19:40:10
任意一个满足Φ（x）=Φ(‖x‖)特性的函数Φ都叫做径向基函数，标准的一般使用欧氏距离（也叫做欧式径向基函数），尽管其他距离函数也是可以的。在神经网络结构中，可以作为全连接层和ReLU层的主要函数。
收起
高斯径向基函数(RBF)神经网络
万次阅读 多人点赞 2019-04-03 00:53:52
高斯径向基函数(RBF)神经网络牛顿插值法-知乎 ...说径向基网络之前，先聊下径向基函数径向基函数（英语：radial basis function，缩写为RBF）是一个取值仅依赖于到原点距离的实值函数，即 ϕ(x...
收起
机器学习
人工神经网络——径向基函数(RBF)神经网络
万次阅读 多人点赞 2015-10-24 15:32:45
径向基函数神经网络的优点：逼近能力，分类能力和学习速度等方面都优于BP神经网络，结构简单、训练简洁、学习收敛速度快、能够逼近任意非线性函数，克服局部极小值问题。原因在于其参数初始化具有一定的方法，并非...
收起
文档 matlab 神经网络
径向基函数分类
千次阅读 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.显然不能确定，...
收起
机器学习算法
径向基函数神经网络简述
2019-08-08 23:15:36
径向基函数神经网络是不同于BP神经网络的另一种的前馈神经网络，由输入层、一层非线性隐层（径向基层）和线性输出层组成的。关于径向基函数神经网络，首先要介绍一个定理，cover定理，对于一个复杂的在低维空间...
收起
径向基函数神经网络（RBFNN）详解
万次阅读 多人点赞 2019-09-13 16:29:05
径向基函数神经网络（RBFNN）前言 RBFNN是20世纪80年代末提出的一种单隐层、以函数逼近为基础的前馈神经网络。随着研究日渐成熟，RBFNN以其结构简单、非线性逼近能力强以及良好的推广能力，受到各领域研究者的极...
收起
深度学习 RBFNN 神经网络
径向基函数（RBF）
千次阅读 2016-12-06 15:29:04
径向基函数的基本概念公式进行阐述
收起
「机器学习」径向基函数RBF
2020-01-13 21:05:33
径向基函数定义：某种沿镜像对称的标量函数。（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‖)特性的函数Φ都叫做径向量函数，标准的一般使用欧氏距离，尽管其他距离函数也是可以的。一些径向函数代表性的用到近似给定的函数，这种近似可以...
收起
RBF（径向基函数）网络
2018-02-07 23:47:00
其中q为隐层神经元个数，Ci和ωi分别是第i个隐层神经元所对应的中心和权重，ρ(x,Ci)是径向基函数，这是某种沿径向对称的标量函数，通常定义为样本x到数据中心Ci之间的欧氏距离的单调函数。常用的高斯径向基函数...
收起

python DEA: 考虑非期望产出的非径向距离函数NDDF

Cite the work

python DEA:强/弱处置性假设下的考虑非期望产出的非径向距离函数

Cite the work

python DEA: 非径向距离函数（non-radial directional distance function）

Cite the work

RBF径向基函数

一、径向基函数

二、径向基网络

三、参数计算

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

径向分布函数

径向基函数

径向基函数网络matlab程序

高斯径向基函数(RBF)神经网络

人工神经网络——径向基函数(RBF)神经网络

径向基函数分类

高斯径向基函数的理解

径向基函数神经网络简述

径向基函数神经网络（RBFNN）详解

径向基函数（RBF）

「机器学习」径向基函数RBF

机器学习——径向基函数

高斯核函数（径向基函数）

径向基函数(RBF)

RBF（径向基函数）网络

径向距离函数