• 关于

# in_array()函数

的搜索结果

#coding=utf-8 import numpy as np import matplotlib.pylab as plt import random class NeuralNetwork(object): def __init__(self, sizes, act, act_derivative, cost_derivative): #sizes表示神经网络各层的神经元个数，第一层为输入层，最后一层为输出层 #act为神经元的激活函数 #act_derivative为激活函数的导数 #cost_derivative为损失函数的导数 self.num_layers = len(sizes) self.sizes = sizes self.biases = [np.random.randn(nueron_num, 1) for nueron_num in sizes[1:]] self.weights = [np.random.randn(next_layer_nueron_num, nueron_num) for nueron_num, next_layer_nueron_num in zip(sizes[:-1], sizes[1:])] self.act=act self.act_derivative=act_derivative self.cost_derivative=cost_derivative #前向反馈（正向传播） def feedforward(self, a): #逐层计算神经元的激活值，公式(4) for b, w in zip(self.biases, self.weights): a = self.act(np.dot(w, a)+b) return a #随机梯度下降算法 def SGD(self, training_data, epochs, batch_size, learning_rate): #将训练样本training_data随机分为若干个长度为batch_size的batch #使用各个batch的数据不断调整参数，学习率为learning_rate #迭代epochs次 n = len(training_data) for j in range(epochs): random.shuffle(training_data) batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)] for batch in batches: self.update_batch(batch, learning_rate) print("Epoch {0} complete".format(j)) def update_batch(self, batch, learning_rate): #根据一个batch中的训练样本，调整各个参数值 nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] for x, y in batch: delta_nabla_b, delta_nabla_w = self.backprop(x, y) nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)] nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)] #计算梯度，并调整各个参数值 self.weights = [w-(learning_rate/len(batch))*nw for w, nw in zip(self.weights, nabla_w)] self.biases = [b-(learning_rate/len(batch))*nb for b, nb in zip(self.biases, nabla_b)] #反向传播 def backprop(self, x, y): #保存b和w的偏导数值 nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] #正向传播 activation = x #保存每一层神经元的激活值 activations = [x] #保存每一层神经元的z值 zs = [] for b, w in zip(self.biases, self.weights): z = np.dot(w, activation)+b zs.append(z) activation = self.act(z) activations.append(activation) #反向传播得到各个参数的偏导数值 #公式(13) d = self.cost_derivative(activations[-1], y) * self.act_derivative(zs[-1]) #公式(17) nabla_b[-1] = d #公式(14) nabla_w[-1] = np.dot(d, activations[-2].transpose()) #反向逐层计算 for l in range(2, self.num_layers): z = zs[-l] sp = self.act_derivative(z) #公式(36)，反向逐层求参数偏导 d = np.dot(self.weights[-l+1].transpose(), d) * sp #公式(38) nabla_b[-l] = d #公式(37) nabla_w[-l] = np.dot(d, activations[-l-1].transpose()) return (nabla_b, nabla_w) #距离函数的偏导数 def distance_derivative(output_activations, y): #损失函数的偏导数 return 2*(output_activations-y) # sigmoid函数 def sigmoid(z): return 1.0/(1.0+np.exp(-z)) # sigmoid函数的导数 def sigmoid_derivative(z): return sigmoid(z)*(1-sigmoid(z)) if __name__ == "__main__": #创建一个5层的全连接神经网络，每层的神经元个数为1，8，5，3，1 #其中第一层为输入层，最后一层为输出层 network=NeuralNetwork([1,8,5,3,1],sigmoid,sigmoid_derivative,distance_derivative) #训练集样本 x = np.array([np.linspace(-7, 7, 200)]).T #训练集结果，由于使用了sigmoid作为激活函数，需保证其结果落在(0,1)区间内 y = (np.cos(x)+1)/2 #使用随机梯度下降算法（SGD）对模型进行训练 #迭代5000次；每次随机抽取40个样本作为一个batch；学习率设为0.1 training_data=[(np.array([x_value]),np.array([y_value])) for x_value,y_value in zip(x,y)] network.SGD(training_data,5000,40,0.1) #测试集样本 x_test = np.array([np.linspace(-9, 9, 120)]) #测试集结果 y_predict = network.feedforward(x_test) #图示对比训练集和测试集数据 plt.plot(x,y,'r',x_test.T,y_predict.T,'*') plt.show()

10个你可能从未用过的PHP函数：报错

kun坤 2020-06-12 22:13:10 0 浏览量 回答数 1

10个你可能从未用过的PHP函数:配置报错

kun坤 2020-05-31 19:10:38 0 浏览量 回答数 1

in_array()在多维数组上不起作用。您可以编写一个递归函数来为您做到这一点： function in_array_r(\$needle, \$haystack, \$strict = false) { foreach (\$haystack as \$item) { if ((\$strict ? \$item === \$needle : \$item == \$needle) || (is_array(\$item) && in_array_r(\$needle, \$item, \$strict))) { return true; } } return false; } 问题来源于stack overflow

RAY Python框架内存不足

tensorflow LSTM时间序列预测问题?报错

#coding=utf-8 import numpy as np import tensorflow as tf import matplotlib as mpl mpl.use('Agg') from matplo...

a123456678 2019-12-02 02:17:44 0 浏览量 回答数 0

vc中程序调用ntgraph控件

#include "stdafx.h" #include "gt.h" #include "gtDlg.h" #include&lt;iostream&gt; #include&lt;fstream&gt; #include&lt;mat...
a123456678 2019-12-01 19:22:49 1175 浏览量 回答数 1

ThinkPHP 自动验证定义的附加规则如下：regex：使用正则进行验证（默认）unique：验证唯一性confirm：验证表单中的两个字段是否相同equal：验证是否等于某个值in：验证是否在某个范围内function：使用函数验证callback：使用方法验证自动验证例子各种自动验证参考例子如下：// 默认情况下用正则进行验证 array('title','require','标题不能为空。'), array('order','number','排序必须是数字。',2), array('email','email','邮箱格式不符合要求。'), array('qq','qq','QQ号码不正确。'), // 在新增的时候验证标题title字段是否唯一 array('title','','标题已经存在！',0,'unique',1), // 验证确认密码是否和密码一致 array('repassword','password','确认密码不正确。',0,'confirm'), // 验证class填写的值为 一班 array('class','一班','班级必须填写一班。',0,'equal'), // 当值不为空的时候判断是否在一个范围内 array('value',array(1,2,3),'值的范围不正确。',2,'in'), // 自定义函数验证用户名格式 array('username','checkName','用户名格式不正确。',0,'function'), // 在注册或更改资料是调用 checkEmail 方法检查邮箱 array('email','checkEmail',1,'callback'), 使用正则表达式（regex）验证上述几类附加规则中，使用正则表达式是经常使用的，也是系统默认的验证附加规则。系统内置了如下正则检测规则：require（必须）、email（邮箱格式）、url（URL地址）、currency（货币）、number（数字）、qq（QQ号码）、english（英文字符）。这些附加规则可以直接使用，如果这些附加规则无法满足要求，可以使用自定义的正则规则：array('username','/^{3,15}\$/','用户名不符合要求。'),该规则要求用户名只能为英文字符及下划线和数字组成，且长度为3-15个字节。要了解更多的正则表达式规则参见《PHP 常用正则表达式整理》。使用自定义函数（function）验证使用自定义函数验证附加规则，函数可以是 Common/common.php 里的自定义函数，也可以是 PHP 的内置函数： class UserModel extends Model{ protected \$_validate = array( array('username','checkName','用户名不符合要求。',0,'function'), }; } 自定义 checkName 函数： function checkName(\$username){ if(!preg_match('/^{3,15}\$/', \$username)){ return false; }else{ return true; } } 提示：对于用户名的规则可以直接使用正则验证而无需函数，在此只是为了演示自定义函数的验证的用法而已。使用方法（callback）验证ThinkPHP 自动验证还支持调用当前 Model 类的一个方法来进行验证。 class UserModel extends Model{ protected \$_validate = array( array('email','checkEmail','邮箱已经存在。',1,'callback'), }; // checkEmail方法 2 protected function checkEmail(){ \$User=new Model('User'); // 新用户注册，验证唯一 if(empty(\$_POST<'uid'>)){ if(\$user->getByEmail(\$_POST<'email'>)){ return false; }else{ return true; } }else{ // 更改资料判断邮箱与其他人的邮箱是否相同 if(\$user->where("uid!={\$_POST<'uid'>} and email='{\$_POST<'email'>}'")->find()){ return false; }else{ return true; } } } } 当 checkEmail 方法返回 false 时，验证就不通过。可见 ThinkPHP 自动验证功能十分强大，能满足对表单的各种验证要求。

Pycharm给出错误: print(' '.join(board[row]).replace('*', ' ')) TypeError: 'int' object is...
kun坤 2019-12-27 16:57:12 6 浏览量 回答数 1

is大龙 2020-03-23 16:46:07 0 浏览量 回答数 1

AttributeError：'NoneType'对象没有属性'_jvm - PySpark UDF

is大龙 2020-03-23 20:21:05 5 浏览量 回答数 1

TLDR ：重要的是，问题是在二维*中设置的。对于大尺寸，这些技术可能无效。 在2D中，我们可以在'O（n log n）`时间内计算每个簇的直径（簇间距离），其中'n'是使用凸包的簇大小。向量化用于加快剩余操作的速度。文章结尾提到了两种可能的渐近改进，欢迎贡献;） *设置和伪造数据： import numpy as np from scipy import spatial from matplotlib import pyplot as plt # set up fake data np.random.seed(0) n_centroids = 1000 centroids = np.random.rand(n_centroids, 2) cluster_sizes = np.random.randint(1, 1000, size=n_centroids) # labels from 1 to n_centroids inclusive labels = np.repeat(np.arange(n_centroids), cluster_sizes) + 1 points = np.zeros((cluster_sizes.sum(), 2)) points[:,0] = np.repeat(centroids[:,0], cluster_sizes) points[:,1] = np.repeat(centroids[:,1], cluster_sizes) points += 0.05 * np.random.randn(cluster_sizes.sum(), 2) 看起来有点像这样： 接下来，基于使用凸包的方法，我们定义一个“直径”函数，用于计算最大簇内距离。 # compute the diameter based on convex hull def diameter(pts): # need at least 3 points to construct the convex hull if pts.shape[0] <= 1: return 0 if pts.shape[0] == 2: return ((pts[0] - pts[1])\*2).sum() # two points which are fruthest apart will occur as vertices of the convex hull hull = spatial.ConvexHull(pts) candidates = pts[spatial.ConvexHull(pts).vertices] return spatial.distance_matrix(candidates, candidates).max() 对于Dunn指数计算，我假设我们已经计算了点，聚类标签和聚类质心。 如果群集数量很大，则以下基于Pandas的解决方案可能会表现良好： import pandas as pd def dunn_index_pandas(pts, labels, centroids): # O(k n log(n)) with k clusters and n points; better performance with more even clusters max_intracluster_dist = pd.DataFrame(pts).groupby(labels).agg(diameter_pandas)[0].max() # O(k^2) with k clusters; can be reduced to O(k log(k)) # get pairwise distances between centroids cluster_dmat = spatial.distance_matrix(centroids, centroids) # fill diagonal with +inf: ignore zero distance to self in "min" computation np.fill_diagonal(cluster_dmat, np.inf) min_intercluster_dist = cluster_sizes.min() return min_intercluster_dist / max_intracluster_dist 否则，我们可以继续使用纯粹的numpy解决方案。 def dunn_index(pts, labels, centroids): # O(k n log(n)) with k clusters and n points; better performance with more even clusters max_intracluster_dist = max(diameter(pts[labels==i]) for i in np.unique(labels)) # O(k^2) with k clusters; can be reduced to O(k log(k)) # get pairwise distances between centroids cluster_dmat = spatial.distance_matrix(centroids, centroids) # fill diagonal with +inf: ignore zero distance to self in "min" computation np.fill_diagonal(cluster_dmat, np.inf) min_intercluster_dist = cluster_sizes.min() return min_intercluster_dist / max_intracluster_dist %time dunn_index(points, labels, centroids) # returned value 2.15 # in 2.2 seconds %time dunn_index_pandas(points, labels, centroids) # returned 2.15 # in 885 ms 对于iid〜U [1,1000]集群大小的1000集群，这需要2.2。秒在我的机器上。在本例中，使用Pandas方法时，此数字下降到0.8秒（许多小集群）。 当集群数量很大时，还有两个其他相关的优化机会： First, I am computing the minimal intercluster distance with a brute force ` O(k^2) ` approach where ` k ` is the number of clusters. This can be reduced to ` O(k log(k)) ` , as discussed here. Second, ` max(diameter(pts[labels==i]) for i in np.unique(labels)) ` requires ` k ` passes over an array of size ` n ` . With many clusters this can become the bottleneck (as in this example). This is somewhat mitigated with the pandas approach, but I expect that this can be optimized a lot further. For current parameters, roughly one third of compute time is spent outside of computing intercluser of intracluster distances. 回答来源：stackoverflow
is大龙 2020-03-23 23:55:18 0 浏览量 回答数 0

Python:在Postgres中插入大型dataframe (1.2M行)的问题

kun坤 2019-12-30 09:34:45 0 浏览量 回答数 0

K-Means聚类 首先，我们在一个简单的二维数据集上实现并应用k-means，以了解它如何工作。k-means是一种迭代的、无监督的聚类算法，它将类似的实例组合成集群。该算法通过猜测每个集群的初始centroid，反复向最近的集群分配实例，并重新计算该集群的centroid。首先我们要实现一个函数，它为数据中的每个实例找到最接近的centroid。 import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sb from scipy.io import loadmat %matplotlib inline def find_closest_centroids(X, centroids): m = X.shape[0] k = centroids.shape[0] idx = np.zeros(m) for i in range(m): min_dist = 1000000 for j in range(k): dist = np.sum((X[i,:] - centroids[j,:]) ** 2) if dist < min_dist: min_dist = dist idx[i] = j return idx 测试函数确保它像预期的那样工作，我们使用练习中的测试案例。 data = loadmat('data/ex7data2.mat') X = data['X'] initial_centroids = initial_centroids = np.array([[3, 3], [6, 2], [8, 5]]) idx = find_closest_centroids(X, initial_centroids) idx[0:3] array([0., 2., 1.]) 输出与文本中的预期值相匹配(我们的数组是zero-indexed而不是one-indexed，所以值比练习中的值要低1)。接下来，我们需要一个函数来计算集群的centroid。centroid是当前分配给集群的所有例子的平均值。 def compute_centroids(X, idx, k): m, n = X.shape centroids = np.zeros((k, n)) for i in range(k): indices = np.where(idx == i) centroids[i,:] = (np.sum(X[indices,:], axis=1) / len(indices[0])).ravel() return centroids compute_centroids(X, idx, 3) array([[ 2.42830111, 3.15792418], [ 5.81350331, 2.63365645], [ 7.11938687, 3.6166844 ]]) 此输出也与该练习的预期值相匹配。目前为止一切都很顺利。下一部分涉及到实际运行算法的迭代次数和可视化结果。我们在练习中实现了这一步骤，它没有那么复杂，我将从头开始构建它。为了运行这个算法，我们只需要在分配到最近集群的示例和重新计算集群的centroids之间进行交替操作。 def run_k_means(X, initial_centroids, max_iters): m, n = X.shape k = initial_centroids.shape[0] idx = np.zeros(m) centroids = initial_centroids for i in range(max_iters): idx = find_closest_centroids(X, centroids) centroids = compute_centroids(X, idx, k) return idx, centroids idx, centroids = run_k_means(X, initial_centroids, 10) 我们现在可以使用颜色编码表示集群成员。 cluster1 = X[np.where(idx == 0)[0],:] cluster2 = X[np.where(idx == 1)[0],:] cluster3 = X[np.where(idx == 2)[0],:] fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(cluster1[:,0], cluster1[:,1], s=30, color='r', label='Cluster 1') ax.scatter(cluster2[:,0], cluster2[:,1], s=30, color='g', label='Cluster 2') ax.scatter(cluster3[:,0], cluster3[:,1], s=30, color='b', label='Cluster 3') ax.legend() 我们跳过了初始化centroid的过程。这可能会影响算法的收敛性。 接下来创建一个可以选择随机例子的函数，并将这些例子作为初始的centroid。 def init_centroids(X, k): m, n = X.shape centroids = np.zeros((k, n)) idx = np.random.randint(0, m, k) for i in range(k): centroids[i,:] = X[idx[i],:] return centroids init_centroids(X, 3) array([[ 1.15354031, 4.67866717], [ 6.27376271, 2.24256036], [ 2.20960296, 4.91469264]]) 我们的下一任务是应用K-means实现图像压缩。我们可以使用集群来查找图像中最具有代表性的少量的颜色，并使用集群分配将原来的24位颜色映射到一个低维度的颜色空间。这是我们要压缩的图像。 原始像素数据已经预加载了，把它输入进来。 image_data= loadmat('data/bird_small.mat') image_data {'A': array([[[219, 180, 103], [230, 185, 116], [226, 186, 110], ..., [ 14, 15, 13], [ 13, 15, 12], [ 12, 14, 12]], ..., [[ 15, 19, 19], [ 20, 20, 18], [ 18, 19, 17], ..., [ 65, 43, 39], [ 58, 37, 38], [ 52, 39, 34]]], dtype=uint8), '__globals__': [], '__header__': 'MATLAB 5.0 MAT-file, Platform: GLNXA64, Created on: Tue Jun 5 04:06:24 2012', '__version__': '1.0'} 我们可以快速查看数据的形状，以验证它是否像我们预期的图像。 A= image_data['A'] A.shape (128L,128L,3L) 现在我们需要对数据进行预处理，并将它输入到k-means算法中。 # normalize value ranges A = A / 255. # reshape the array X = np.reshape(A, (A.shape[0] * A.shape[1], A.shape[2])) # randomly initialize the centroids initial_centroids = init_centroids(X, 16) # run the algorithm idx, centroids = run_k_means(X, initial_centroids, 10) # get the closest centroids one last time idx = find_closest_centroids(X, centroids) # map each pixel to the centroid value X_recovered = centroids[idx.astype(int),:] # reshape to the original dimensions X_recovered = np.reshape(X_recovered, (A.shape[0], A.shape[1], A.shape[2])) plt.imshow(X_recovered) 我们在压缩中创建了一些artifact，尽管将原始图像映射到仅16种颜色，但图像的主要特征仍然存在。 这是关于k-means的部分，接下来我们来看关于主成分分析的部分。 主成分分析 PCA是一个可以在数据集中找到“主成分”或者最大方差方向的线性变换。它可以用于其他事物的维度减少。在这个练习中，我们需要实现PCA，并将其应用于一个简单的二维数据集，观察它是如何工作的。从加载和可视化数据集开始。 data = loadmat('data/ex7data1.mat') X = data['X'] fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(X[:, 0], X[:, 1]) PCA的算法相当简单。在保证数据正规化后，输出只是原始数据协方差矩阵的单值分解。由于numpy已经有内置函数来计算矩阵协方差和SVD，我们将利用这些函数而不是从头开始。 def pca(X): # normalize the features X = (X - X.mean()) / X.std() # compute the covariance matrix X = np.matrix(X) cov = (X.T * X) / X.shape[0] # perform SVD U, S, V = np.linalg.svd(cov) return U, S, V U, S, V = pca(X) U, S, V (matrix([[-0.79241747, -0.60997914], [-0.60997914, 0.79241747]]), array([ 1.43584536, 0.56415464]), matrix([[-0.79241747, -0.60997914], [-0.60997914, 0.79241747]])) 现在我们已经有了主成分（矩阵U），我们可以利用它把原始数据投入到一个更低维度的空间，对于这个任务，我们将实现一个函数，它计算投影并只选择顶部K成分，有效地减少了维度的数量。 def project_data(X, U, k): U_reduced = U[:,:k] return np.dot(X, U_reduced) Z = project_data(X, U, 1) Z matrix([[-4.74689738], [-7.15889408], [-4.79563345], [-4.45754509], [-4.80263579], ..., [-6.44590096], [-2.69118076], [-4.61386195], [-5.88236227], [-7.76732508]]) 我们也可以通过改变采取的步骤来恢复原始数据。 def recover_data(Z, U, k): U_reduced = U[:,:k] return np.dot(Z, U_reduced.T) X_recovered = recover_data(Z, U, 1) X_recovered matrix([[ 3.76152442, 2.89550838], [ 5.67283275, 4.36677606], [ 3.80014373, 2.92523637], [ 3.53223661, 2.71900952], [ 3.80569251, 2.92950765], ..., [ 5.10784454, 3.93186513], [ 2.13253865, 1.64156413], [ 3.65610482, 2.81435955], [ 4.66128664, 3.58811828], [ 6.1549641 , 4.73790627]]) 如果我们尝试去可视化恢复的数据，会很容易的发现算法的工作原理。 fig, ax= plt.subplots(figsize=(12,8)) ax.scatter(X_recovered[:,0], X_recovered[:,1]) 注意这些点如何被压缩成一条虚线。虚线本质上是第一个主成分。当我们将数据减少到一个维度时，我们切断的第二个主成分可以被认为是与这条虚线的正交变化。由于我们失去了这些信息，我们的重建只能将这些点与第一个主成分相关联。 我们这次练习的最后一项任务是将PCA应用于脸部图像。通过使用相同降维技术，我们可以使用比原始图像少得多的数据来捕捉图像的“本质”。 faces= loadmat('data/ex7faces.mat') X= faces['X'] X.shape (5000L,1024L) 该练习代码包含一个函数，它将在网格中的数据集中渲染前100个脸部图像。你可以在练习文本中找到它们，不需要重新生成。 face= np.reshape(X[3,:], (32,32)) plt.imshow(face) 只有32 x 32灰度图像。下一步我们要在脸部图像数据集上运行PCA，并取得前100个主成分。 U, S, V= pca(X) Z= project_data(X, U,100) 现在尝试恢复原来的结构并重新渲染它。 X_recovered= recover_data(Z, U,100) face= np.reshape(X_recovered[3,:], (32,32)) plt.imshow(face) 结果并没有像预期的维度数量减少10倍，可能是因为我们丢失了一些细节部分。

PHP 5.6引入了第三个参数array_filter()，flag，你可以设置为ARRAY_FILTER_USE_KEY通过键，而不是值进行筛选： \$my_array = ['foo' => 1, 'hello' => 'world']; \$allowed = ['foo', 'bar']; \$filtered = array_filter( \$my_array, function (\$key) use (\$allowed) { return in_array(\$key, \$allowed); }, ARRAY_FILTER_USE_KEY ); 显然，这不如优雅array_intersect_key(\$my_array, array_flip(\$allowed))，但是它确实提供了额外的灵活性，\$allowed可以对键执行任意测试，例如可以包含正则表达式模式而不是纯字符串。 您还可以ARRAY_FILTER_USE_BOTH将值和键都传递给过滤器函数。这是一个基于第一个示例的示例，但请注意，我不建议您使用\$allowed这种方式编码过滤规则： \$my_array = ['foo' => 1, 'bar' => 'baz', 'hello' => 'wld']; \$allowed = ['foo' => true, 'bar' => true, 'hello' => 'world']; \$filtered = array_filter( \$my_array, function (\$val, \$key) use (\$allowed) { // N.b. \$val, \$key not \$key, \$val return isset(\$allowed[\$key]) && ( \$allowed[\$key] === true || \$allowed[\$key] === \$val ); }, ARRAY_FILTER_USE_BOTH ); // ['foo' => 1, 'bar' => 'baz'] 问题来源于stack overflow

import scipy.stats as stimport matplotlib.pyplot as pltimport numpy as npimport collectionsfrom sklearn.preprocessing import MinMaxScalerimport numpy as npimport csvimport mathfrom pylab import*import matplotlib.mlab as mlabfrom sklearn.utils import shuffleimport mathi=0j=[]data = []X = []indicess = []xback =24with open(r'D:error01冬季雨天.csv') as f: reader = csv.reader(f) for row in reader: data.append(row[:])#提取出每一行中的2:14列 data1=[]data = np.array(data)m,n=np.shape(data)for i in range(m): for j in range(n): #print(data[i][j]) data[i][j] = data[i][j].astype('float64')#是从第三列开始的 for i in range(m): for j in range(n): #print(data[i][j]) data1.append(data[i][j]) print("the type of data1",type(data1[1]))data = data.astype('float64') print(data) print("the shape of data",len(data)) 定义最大似然函数后的结果 def mle(x): u = np.mean(x) thea=np.std(x) return u,thea 确定了分布 print(mle(data))u,thea=mle(data)print(u)print(thea)y = st.norm.pdf(data[:6],u,thea)print(y)count, bins, ignored =plt.hist(data,bins=20,normed=False)print("count",len(count))print("bins",len(bins))plt.plot(bins[:20],count,"r")pro=count/np.sum(count)plt.xlabel("x")plt.ylabel("probability density")plt.show() plt.plot(bins[:20],pro,"r",lw=2)plt.show()low=-1.65*thea+u #对应90%的置信度up=1.65*thea+udata0=[]print("下界为",low)print("上界为：",up) with open(r'D:真实值冬季雨天.csv') as f: reader = csv.reader(f) for row in reader: data0.append(row[:]) # 提取出每一行中的2:14列 data01=[]data0 = np.array(data0) print(data0) m,n=np.shape(data0)print("the shape of data0",np.shape(data0))for i in range(m): for j in range(n): #print(data0[i][j]) data0[i][j] = data0[i][j].astype('float64')#是从第三列开始的 for i in range(m): for j in range(n): #print(data[i][j]) data01.append(data0[i][j]) print("the type of data1",type(data1[1])) data0 = data0.astype('float64')data01=map(eval, data01)print(np.shape(data0))print(data0[:4])print(data0[:2,0])datamax=np.max(data0[:,0])datamax=np.max(data0[:,0])p_low = list(map(lambda x: (x-abs(low)*datamax) , data0[:,0]))p_up = list(map(lambda x: (x+up *datamax), data0[:,1]))x=[i for i in range(len(p_low))]print(x) 显示置信区间范围 l=90k=0plt.plot(x[k:l],p_low[k:l], 'g', lw=2, label='下界曲线')plt.plot(x[k:l],p_up[k:l], 'g', lw=2, label='上界曲线')plt.plot(x[k:l],data0[k:l,0], 'b', lw=2, label='真实值')plt.plot(data0[k:l,1], 'r', lw=2, label='预测值')plt.fill_between(x[k:l],p_low[k:l],p_up[k:l],color="c",alpha=0.1)plt.title('置信区间', fontsize=18) # 表的名称plt.legend(loc=0, numpoints=1)leg = plt.gca().get_legend()ltext = leg.get_texts()plt.setp(ltext, fontsize='small') 负责绘制与图或轴相关的数据 savefig('D:/十折交叉验证/LSTM1.jpg') plt.show() 评价置信区间PICP,PINAW,CWC，PICP用来评价预测区间的覆盖率，PINAW预测区间的宽带 count=0 for i in range(len(p_low)): if data0[i][1]>=p_low[i] and data0[i][1]<=p_up[i]: count=count+1 PICP = count/len(p_low)print("PICP",PICP) 对于概率性的区间预测方法，在置信度一样的情况下，预测区间越窄越好 max0=np.max(data0[:,1])min0=np.min(data0[:,1])sum0=list(map(lambda x: (x[1]-x[0]) , zip(p_low,p_up)))sum1=np.sum(sum0)/len(sum0)PINAW = 1/(max0-min0)*sum1print("PINAW",PINAW) 综合指标的评价cwcCWC = PINAW(1+R(PICP)np.exp(-y(PICP-U))) g=90#取值在50-100e0=math.exp(-g*(PICP-u))if PICP>=u: r=0 else: r=1 CWC=PINAW(1+rPICP*e0)print("CWC",CWC)
xuning715 2019-12-02 01:10:12 0 浏览量 回答数 0

(Noob)我有一个程序，它获取一个数组，根据其各自的功能对某些元素进行切片，然后arCalc对它们进行操作。从arSlice返回所有这些值似乎不可行，因为main()中的函数调用需要...
kun坤 2019-12-27 10:12:44 1 浏览量 回答数 1

is大龙 2020-03-24 22:47:23 0 浏览量 回答数 1