• 上一版非径向距离函数在这 普通非径向距离函数 现在很多研究在测度效率时要考虑非期望产出，如环境技术中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

这一版更新比较简单，增加了强处置性假设下的非径向距离函数（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()

该模块依据了这个公式：

文章是张宁老师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’为核函数中心，是一个自由参数，是函数的宽度参数 , 控制了函数的径向作用范围。。一种等价但更为简单的定义是设一个新的参数 ，其表达式为

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

径向基函数二维图像：

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的缩写，指的是给定一个空间，在此空间以一个对象为中心，去寻找周围对象的的概率。对于分子模拟的径向分布函数实则也是求解...
• 任意一个满足Φ（x）=Φ（||x||）特性的函数Φ都叫做径向基函数，标准的一般使用欧式距离（也叫做欧式径向基函数），尽管其他距离函数也是可以的。在神经网络结构中，可以作为全连接层和ReLU层的主要函数。 一些径向...
• 任意一个满足Φ（x）=Φ(‖x‖)特性的函数Φ都叫做径向基函数，标准的一般使用欧氏距离（也叫做欧式径向基函数），尽管其他距离函数也是可以的。在神经网络结构中，可以作为全连接层和ReLU层的主要函数。
• ## 高斯径向基函数(RBF)神经网络

万次阅读 多人点赞 2019-04-03 00:53:52
高斯径向函数(RBF)神经网络 牛顿插值法-知乎 ...说径向基网络之前，先聊下径向函数径向函数（英语：radial basis function，缩写为RBF）是一个取值仅依赖于到原点距离的实值函数，即 ϕ(x...
• 径向函数神经网络的优点：逼近能力，分类能力和学习速度等方面都优于BP神经网络，结构简单、训练简洁、学习收敛速度快、能够逼近任意非线性函数，克服局部极小值问题。原因在于其参数初始化具有一定的方法，并非...
• ## 径向基函数分类

千次阅读 2018-04-12 16:04:56
目前，最常用的径向函数是高斯核函数，其公式如下： 其中，xc为中心点坐标，x为待分类的坐标，||x-xc||为欧几里得距离,σ为可调的宽度参数。python代码：#径向函数，gamma=1/(2*σ)^2def rbf(v1,v2,gamma=10): ...
• 高斯径向函数的理解 提出问题 有这样一个函数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||) #径向函数公示 ...
• 径向函数是关于空间中点的函数，且函数值只和距离原点的距离有关（一般使用欧式距离）。径向函数的表达式为： ϕ(x)=ϕ(||x||)\phi(x)=\phi(||x||)
• 通常定义为空间中任一点x到某一中心xc之间欧氏距离的单调函数 , 可记作 k(||x-xc||), 其作用往往是局部的 , 即当x远离xc时函数取值很小。最常用的径向函数是高斯核函数 ,形式为 k(||x-xc||)=exp{- ||x-xc||^2/(2*...
• Radial basis function（径向基...任意一个满足Φ（x）=Φ(‖x‖)特性的函数Φ都叫做径向量函数，标准的一般使用欧氏距离，尽管其他距离函数也是可以的。 一些径向函数代表性的用到近似给定的函数，这种近似可以...
• 其中q为隐层神经元个数，Ci和ωi分别是第i个隐层神经元所对应的中心和权重，ρ(x,Ci)是径向函数，这是某种沿径向对称的标量函数，通常定义为样本x到数据中心Ci之间的欧氏距离的单调函数。常用的高斯径向函数...

...