为什么叫做径向基函数

假设x、x0∈RN，以x0为中心，x到x0的径向距离为半径所形成的‖x-x0‖构成的函数系满足k(x)＝O。‖x-x0‖称为径向基函数。

创新互联建站专注于伊通网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供伊通营销型网站建设，伊通网站制作、伊通网页设计、伊通网站官网定制、成都小程序开发服务，打造伊通网络公司原创品牌,更为您提供伊通网站排名全网营销落地服务。

考虑径向基函数插值在一些不同领域的来源.

最早可能是Krige ,他在1951 年把矿藏的沉积看成是一个各向同性的稳定的随机函数的实现. 从而导出了广泛应用于矿藏分析的Kriging 方法. 在这方面的进一步深入的理论工作主要是由Mathron 完成的.

1971 年Hardy 用径向基函数Multi-Quadric来处理飞机外形设计曲面拟合问题, 取得了非常好的效果.

1975 年Duchon 从样条弯曲能最小的理论出发导出了多元问题的薄板样条. 这些从不同领域导出的方法, 事实上都是径向基函数的插值方法,

他们所用的径向基函数有:

1)Kriging 方法的Gauss 分布函数

2)Hardy 的Multi2Quadric 函数

3)Duchon 的薄板样条

python的seaborn.kdeplot有什么用

kde(kernel density estimation)是核密度估计。核的作用是根据离散采样，估计连续密度分布。

如果原始采样是《阴阳师》里的式神，那么kernel（核函数）就相当于御魂。

假设现在有一系列离散变量X = [4, 5, 5, 6, 12, 14, 15, 15, 16, 17],可见5和15的概率密度应该要高一些，但具体有多高呢？有没有三四层楼那么高，有没有华莱士高？如果要估计的是没有出现过的3呢？这就要自己判断了。

核函数就是给空间的每个离散点都套上一个连续分布。最简单的核函数是Parzen窗，类似一个方波：

这时候单个离散点就可以变成区间，空间或者高维空间下的超立方，实质上是进行了升维。

设h=4，则3的概率密度为：

(只有4对应的核函数为1，其他皆为0)

kernel是非负实值对称可积函数，表示为K，且一本满足：

这样才能保证cdf仍为1。

实际上应用最多的是高斯核函数(Gaussian Kernel)，也就是标准正态分布。所谓核密度估计就是把所有离散点的核函数加起来，得到整体的概率密度分布。核密度估计在很多机器学习算法中都有应用，比如K近邻、K平均等。

在支持向量机里，也有“核”的概念，同样也是给数据升维，最常用的还是高斯核函数，也叫径向基函数(Radial Basis Funtion)。

seaborn.kdeplot内置了多种kerne，总有一款适合你。

人工智能是学习什么？

1、学习并掌握一些数学知识

高等数学是基础中的基础，一切理工科都需要这个打底，数据挖掘、人工智能、模式识别此类跟数据打交道的又尤其需要多元微积分运算基础。

线性代数很重要，一般来说线性模型是你最先要考虑的模型，加上很可能要处理多维数据，你需要用线性代数来简洁清晰的描述问题，为分析求解奠定基础。

概率论、数理统计、随机过程更是少不了，涉及数据的问题，不确定性几乎是不可避免的，引入随机变量顺理成章，相关理论、方法、模型非常丰富。很多机器学习的算法都是建立在概率论和统计学的基础上的，比如贝叶斯分类器、高斯隐马尔可夫链。

再就是优化理论与算法，除非你的问题是像二元一次方程求根那样有现成的公式，否则你将不得不面对各种看起来无解但是要解的问题，优化将是你的GPS为你指路。

以上这些知识打底，就可以开拔了，针对具体应用再补充相关的知识与理论，比如说一些我觉得有帮助的是数值计算、图论、拓扑，更理论一点的还有实/复分析、测度论，偏工程类一点的还有信号处理、数据结构。

2、掌握经典机器学习理论和算法

如果有时间可以为自己建立一个机器学习的知识图谱，并争取掌握每一个经典的机器学习理论和算法，我简单地总结如下：

1) 回归算法：常见的回归算法包括最小二乘法（OrdinaryLeast Square），逻辑回归（Logistic Regression），逐步式回归（Stepwise Regression），多元自适应回归样条（MultivariateAdaptive Regression Splines）以及本地散点平滑估计（Locally Estimated Scatterplot Smoothing）；

2) 基于实例的算法：常见的算法包括 k-Nearest Neighbor(KNN), 学习矢量量化（Learning Vector Quantization， LVQ），以及自组织映射算法（Self-Organizing Map ， SOM）；

3) 基于正则化方法：常见的算法包括：Ridge Regression， Least Absolute Shrinkage and Selection Operator（LASSO），以及弹性网络（Elastic Net）；

4) 决策树学习：常见的算法包括：分类及回归树（ClassificationAnd Regression Tree， CART）， ID3 (Iterative Dichotomiser 3)， C4.5， Chi-squared Automatic Interaction Detection(CHAID), Decision Stump, 随机森林（Random Forest）， 多元自适应回归样条（MARS）以及梯度推进机（Gradient Boosting Machine， GBM）；

5) 基于贝叶斯方法：常见算法包括：朴素贝叶斯算法，平均单依赖估计（AveragedOne-Dependence Estimators， AODE），以及Bayesian Belief Network（BBN）；

6) 基于核的算法：常见的算法包括支持向量机（SupportVector Machine， SVM）， 径向基函数（Radial Basis Function ，RBF)， 以及线性判别分析（Linear Discriminate Analysis ，LDA)等；

7) 聚类算法：常见的聚类算法包括 k-Means算法以及期望最大化算法（Expectation Maximization， EM）；

8) 基于关联规则学习：常见算法包括 Apriori算法和Eclat算法等；

9) 人工神经网络：重要的人工神经网络算法包括：感知器神经网络（PerceptronNeural Network）, 反向传递（Back Propagation）， Hopfield网络，自组织映射（Self-OrganizingMap, SOM）。学习矢量量化（Learning Vector Quantization， LVQ）；

10) 深度学习：常见的深度学习算法包括：受限波尔兹曼机（RestrictedBoltzmann Machine， RBN）， Deep Belief Networks（DBN），卷积网络（Convolutional Network）, 堆栈式自动编码器（Stacked Auto-encoders）；

11) 降低维度的算法：常见的算法包括主成份分析（PrincipleComponent Analysis， PCA），偏最小二乘回归（Partial Least Square Regression，PLS）， Sammon映射，多维尺度（Multi-Dimensional Scaling, MDS）, 投影追踪（ProjectionPursuit）等；

12) 集成算法：常见的算法包括：Boosting， Bootstrapped Aggregation（Bagging），AdaBoost，堆叠泛化（Stacked Generalization， Blending），梯度推进机（GradientBoosting Machine, GBM），随机森林（Random Forest）。

3、掌握一种编程工具，比如Python

一方面Python是脚本语言，简便，拿个记事本就能写，写完拿控制台就能跑；另外，Python非常高效，效率比java、r、matlab高。matlab虽然包也多，但是效率是这四个里面最低的。

4、了解行业最新动态和研究成果，比如各大牛的经典论文、博客、读书笔记、微博微信等媒体资讯。

5、买一个GPU，找一个开源框架，自己多动手训练深度神经网络，多动手写写代码，多做一些与人工智能相关的项目。

6、选择自己感兴趣或者工作相关的一个领域深入下去

人工智能有很多方向，比如NLP、语音识别、计算机视觉等等，生命有限，必须得选一个方向深入的钻研下去，这样才能成为人工智能领域的大牛，有所成就。

根据百度百科给的定义，人工智能（Artificial Intelligence），英文缩写为AI。它是研究、开发用于模拟、延伸和扩展人的还能的理论、方法、技术及应用系统的一门新的技术科学。

百度百科关于人工智能的定义详解中说道：人工智能是计算机的一个分支，二十世纪七十年代以来被称为世界三大尖端技术之一（空间技术、能源技术、人工智能）。也被认为是二十一世纪三大尖端技术（基因工程、纳米科学、人工智能）之一。这是因为近三十年来它获得了迅速的发展，在很多学科领域都获得了广泛应用，并取得了丰硕的成果，人工智能已逐步成为一个独立的分支，无论在理论和实践上都已自成一个系统。

综上，从定义上讲，人工智能是一项技术。

哪位能介绍一下 径向基函数？

基于径向基函数强形式的无单元（RBFS）法是真正意义上的无单元方法，但为了追求精度要求却未达到稀疏化。本文对RBFS进行了改进，通过构造具有占函数性质的形函数，得到了具有稀疏带状性的系数矩阵，提高了计算效率，同时具有RBFS方法的优点。通过求解微分方程，得到节点均布时影响域半径与求解精度的关系曲线，验证了基函数中自由参数最佳取值的计算公式的适用性；并把节点均布下得到的影响域半径和自由参数的规律应用到节点任意排列的情况下，求解结果变化不大，均满足精度要求，由此得出这些规律仍然适用，这种无单元法对节点位置不敏感.

python rbf表示什么分布

径向基（RBF）神经网络python实现

1 from numpy import array, append, vstack, transpose, reshape, \

2                   dot, true_divide, mean, exp, sqrt, log, \

3                   loadtxt, savetxt, zeros, frombuffer

4 from numpy.linalg import norm, lstsq

5 from multiprocessing import Process, Array

6 from random import sample

7 from time import time

8 from sys import stdout

9 from ctypes import c_double

10 from h5py import File

11

12

13 def metrics(a, b):

14     return norm(a - b)

15

16

17 def gaussian (x, mu, sigma):

18     return exp(- metrics(mu, x)**2 / (2 * sigma**2))

21 def multiQuadric (x, mu, sigma):

22     return pow(metrics(mu,x)**2 + sigma**2, 0.5)

23

24

25 def invMultiQuadric (x, mu, sigma):

26     return pow(metrics(mu,x)**2 + sigma**2, -0.5)

27

28

29 def plateSpine (x,mu):

30     r = metrics(mu,x)

31     return (r**2) * log(r)

32

33

34 class Rbf:

35     def __init__(self, prefix = 'rbf', workers = 4, extra_neurons = 0, from_files = None):

36         self.prefix = prefix

37         self.workers = workers

38         self.extra_neurons = extra_neurons

39

40         # Import partial model

41         if from_files is not None:          

42             w_handle = self.w_handle = File(from_files['w'], 'r')

43             mu_handle = self.mu_handle = File(from_files['mu'], 'r')

44             sigma_handle = self.sigma_handle = File(from_files['sigma'], 'r')

45          

46             self.w = w_handle['w']

47             self.mu = mu_handle['mu']

48             self.sigmas = sigma_handle['sigmas']

49          

50             self.neurons = self.sigmas.shape[0]

51

52     def _calculate_error(self, y):

53         self.error = mean(abs(self.os - y))

54         self.relative_error = true_divide(self.error, mean(y))

55

56     def _generate_mu(self, x):

57         n = self.n

58         extra_neurons = self.extra_neurons

59

60         # TODO: Make reusable

61         mu_clusters = loadtxt('clusters100.txt', delimiter='\t')

62

63         mu_indices = sample(range(n), extra_neurons)

64         mu_new = x[mu_indices, :]

65         mu = vstack((mu_clusters, mu_new))

66

67         return mu

68

69     def _calculate_sigmas(self):

70         neurons = self.neurons

71         mu = self.mu

72

73         sigmas = zeros((neurons, ))

74         for i in xrange(neurons):

75             dists = [0 for _ in xrange(neurons)]

76             for j in xrange(neurons):

77                 if i != j:

78                     dists[j] = metrics(mu[i], mu[j])

79             sigmas[i] = mean(dists)* 2

80                       # max(dists) / sqrt(neurons * 2))

81         return sigmas

82

83     def _calculate_phi(self, x):

84         C = self.workers

85         neurons = self.neurons

86         mu = self.mu

87         sigmas = self.sigmas

88         phi = self.phi = None

89         n = self.n

90

91

92         def heavy_lifting(c, phi):

93             s = jobs[c][1] - jobs[c][0]

94             for k, i in enumerate(xrange(jobs[c][0], jobs[c][1])):

95                 for j in xrange(neurons):

96                     # phi[i, j] = metrics(x[i,:], mu[j])**3)

97                     # phi[i, j] = plateSpine(x[i,:], mu[j]))

98                     # phi[i, j] = invMultiQuadric(x[i,:], mu[j], sigmas[j]))

99                     phi[i, j] = multiQuadric(x[i,:], mu[j], sigmas[j])

100                     # phi[i, j] = gaussian(x[i,:], mu[j], sigmas[j]))

101                 if k % 1000 == 0:

102                     percent = true_divide(k, s)*100

103                     print(c, ': {:2.2f}%'.format(percent))

104             print(c, ': Done')

105      

106         # distributing the work between 4 workers

107         shared_array = Array(c_double, n * neurons)

108         phi = frombuffer(shared_array.get_obj())

109         phi = phi.reshape((n, neurons))

110

111         jobs = []

112         workers = []

113

114         p = n / C

115         m = n % C

116         for c in range(C):

117             jobs.append((c*p, (c+1)*p + (m if c == C-1 else 0)))

118             worker = Process(target = heavy_lifting, args = (c, phi))

119             workers.append(worker)

120             worker.start()

121

122         for worker in workers:

123             worker.join()

124

125         return phi

126

127     def _do_algebra(self, y):

128         phi = self.phi

129

130         w = lstsq(phi, y)[0]

131         os = dot(w, transpose(phi))

132         return w, os

133         # Saving to HDF5

134         os_h5 = os_handle.create_dataset('os', data = os)

135

136     def train(self, x, y):

137         self.n = x.shape[0]

138

139         ## Initialize HDF5 caches

140         prefix = self.prefix

141         postfix = str(self.n) + '-' + str(self.extra_neurons) + '.hdf5'

142         name_template = prefix + '-{}-' + postfix

143         phi_handle = self.phi_handle = File(name_template.format('phi'), 'w')

144         os_handle = self.w_handle = File(name_template.format('os'), 'w')

145         w_handle = self.w_handle = File(name_template.format('w'), 'w')

146         mu_handle = self.mu_handle = File(name_template.format('mu'), 'w')

147         sigma_handle = self.sigma_handle = File(name_template.format('sigma'), 'w')

148

149         ## Mu generation

150         mu = self.mu = self._generate_mu(x)

151         self.neurons = mu.shape[0]

152         print('({} neurons)'.format(self.neurons))

153         # Save to HDF5

154         mu_h5 = mu_handle.create_dataset('mu', data = mu)

155

156         ## Sigma calculation

157         print('Calculating Sigma...')

158         sigmas = self.sigmas = self._calculate_sigmas()

159         # Save to HDF5

160         sigmas_h5 = sigma_handle.create_dataset('sigmas', data = sigmas)

161         print('Done')

162

163         ## Phi calculation

164         print('Calculating Phi...')

165         phi = self.phi = self._calculate_phi(x)

166         print('Done')

167         # Saving to HDF5

168         print('Serializing...')

169         phi_h5 = phi_handle.create_dataset('phi', data = phi)

170         del phi

171         self.phi = phi_h5

172         print('Done')

173

174         ## Algebra

175         print('Doing final algebra...')

176         w, os = self.w, _ = self._do_algebra(y)

177         # Saving to HDF5

178         w_h5 = w_handle.create_dataset('w', data = w)

179         os_h5 = os_handle.create_dataset('os', data = os)

180

181         ## Calculate error

182         self._calculate_error(y)

183         print('Done')

184

185     def predict(self, test_data):

186         mu = self.mu = self.mu.value

187         sigmas = self.sigmas = self.sigmas.value

188         w = self.w = self.w.value

189

190         print('Calculating phi for test data...')

191         phi = self._calculate_phi(test_data)

192         os = dot(w, transpose(phi))

193         savetxt('iok3834.txt', os, delimiter='\n')

194         return os

195

196     @property

197     def summary(self):

198         return '\n'.join( \

199             ['-----------------',

200             'Training set size: {}'.format(self.n),

201             'Hidden layer size: {}'.format(self.neurons),

202             '-----------------',

203             'Absolute error   : {:02.2f}'.format(self.error),

204             'Relative error   : {:02.2f}%'.format(self.relative_error * 100)])

205

206

207 def predict(test_data):

208     mu = File('rbf-mu-212243-2400.hdf5', 'r')['mu'].value

209     sigmas = File('rbf-sigma-212243-2400.hdf5', 'r')['sigmas'].value

210     w = File('rbf-w-212243-2400.hdf5', 'r')['w'].value

211

212     n = test_data.shape[0]

213     neur = mu.shape[0]

214  

215     mu = transpose(mu)

216     mu.reshape((n, neur))

217

218     phi = zeros((n, neur))

219     for i in range(n):

220         for j in range(neur):

221             phi[i, j] = multiQuadric(test_data[i,:], mu[j], sigmas[j])

222

223     os = dot(w, transpose(phi))

224     savetxt('iok3834.txt', os, delimiter='\n')

225     return os

分享文章：径向基函数Python,径向基函数理解
分享网址：http://scyanting.com/article/dsiijie.html