• 关于

    array_sum函数

    的搜索结果

回答

coding=gbk #防止出现中文编译错误import numpy as np list_x=[[1,1],[92,2]] #列表array_x=np.array(list_x) #将列表转化成二维数组mat_x=np.mat(list_x) #将列表转化成矩阵mat_x_t=mat_x.T #矩阵转置mat_x_p=mat_x.I #矩阵求逆sum_r=mat_x.sum(axis=0) #矩阵每行求和sum_c=mat_x.sum(axis=1) #矩阵每列求和sum_=np.sum(mat_x[:,:]) #矩阵求和,注意np.sum 不同于summax_=np.max(mat_x) #计算矩阵中所有元素的最大值,这里得到的结果是一个数值max_c2=np.max(mat_x[:,1]) #计算第二列的最大值,注意np.max得到的是一个数值,max得到的是一个1*1的矩阵max_r2=mat_x[1,:].max() #计算第二行的最大值,这里得到的是一个一个数值max_c=np.max(mat_x,0) #计算所有列的最大值,这里使用的是numpy中的max函数max_r=np.max(mat_x,1) #计算所有行的最大值,这里得到是一个矩阵argmax_c=np.argmax(mat_x,0) #计算所有列的最大值对应在该列中的索引argmax_r2=np.argmax(mat_x[1,:]) #计算第二行中最大值对应在该行的索引vstack_x_xt=np.vstack((mat_x,mat_x_t)) #按列合并,即增加行数hstack_x_xt=np.hstack((mat_x,mat_x_t)) #按行合并,即行数不变,扩展列数dimension=mat_x.ndim;m,n=mat_x.shape;size=mat_x.size #元素总个数type=mat_x.dtype #元素的类型print("list_x=",list_x)print("array_x=",array_x)print("mat_x=",mat_x)print("mat_x_t=",mat_x_t)print("mat_x_p=",mat_x_p)print("xx_p=",mat_xmat_x_p) #矩阵相乘print("x.*x=",np.multiply(mat_x,mat_x)) #矩阵点乘print("sum_r=",sum_r)print("sum_c=",sum_c)print("sum_=",sum_)print("max_=",max_)print("max_c2=",max_c2)print("max_r2=",max_r2)print("max_c=",max_c)print("max_r=",max_r)print("argmax_c=",argmax_c)print("argmax_r2=",argmax_r2)print("vstack_x_xt=",vstack_x_xt)print("vstack_x_xt=",vstack_x_xt)print("dimension=",dimension)print("m,n=",m,n)print("size=",size)print("type=",type)以下为计算结果list_x= [[1, 1], [92, 2]]array_x= [[ 1 1] [92 2]]mat_x= [[ 1 1] [92 2]]mat_x_t= [[ 1 92] [ 1 2]]mat_x_p= [[-0.02222222 0.01111111] [ 1.02222222 -0.01111111]]x*x_p= [[ 1. 0.] [ 0. 1.]]x.*x= [[ 1 1] [8464 4]]sum_r= [[93 3]]sum_c= [[ 2] [94]]sum_= 96max_= 92max_c2= 2max_r2= 92max_c= [[92 2]]max_r= [[ 1] [92]]argmax_c= [[1 1]]argmax_r2= 0vstack_x_xt= [[ 1 1] [92 2] [ 1 92] [ 1 2]]vstack_x_xt= [[ 1 1] [92 2] [ 1 92] [ 1 2]]dimension= 2m,n= 2 2size= 4type= int32
元芳啊 2019-12-02 01:04:38 0 浏览量 回答数 0

回答

您需要将其与之耦合以array_map()首先选择该f_count列: array_sum(array_map(function($item) { return $item['f_count']; }, $arr)); 当然,在内部,这会执行一个双循环。只是您在代码中看不到它。您可以array_reduce()用来摆脱一个循环: array_reduce($arr, function(&$res, $item) { return $res + $item['f_count']; }, 0); 但是,如果速度是唯一的利益,那么速度foreach仍然最快: $sum = 0; foreach ($arr as $item) { $sum += $item['f_count']; } 这要归功于您使用的变量的“局部性”,即,没有用于计算最终总和的函数调用。来源:stack overflow
保持可爱mmm 2020-05-11 16:25:38 0 浏览量 回答数 0

回答

由于似乎没有人做过此事,因此我认为最好在某个地方提供参考。我已经通过基准测试或代码掠过来表征这些array_*功能。我试图将更有趣的Big-O放在顶部。此列表不完整。 注意:假设是哈希查找,所有计算出来的Big-O都是O(1),即使它实际上是O(n)。n的系数是如此之低,在大Big-O的特征开始生效之前,存储足够大的数组的内存开销会伤害您。例如,array_key_exists在N = 1和N = 1,000,000时的通话时间差为〜50%。 有趣的地方: isset/ array_key_exists比in_array和快得多array_search +(联盟)比array_merge(看起来更好)快一点。但是它的工作方式有所不同,因此请记住这一点。 shuffle 在与Big-O相同的层上 array_rand array_pop/ array_push比重新索引罚款更快array_shift/array_unshift 查询: array_key_existsO(n)但实际上接近O(1)-这是由于碰撞中的线性轮询,但是由于碰撞的机会非常小,因此系数也非常小。我发现您将哈希查找视为O(1)来给出更现实的big-O。例如,N = 1000和N = 100000之间的差异仅减慢了50%。 isset( $array[$index] )O(n)但实际上接近O(1)-它使用与array_key_exists相同的查找。由于是语言构造,因此如果密钥是硬编码的,将缓存查找,从而在重复使用同一密钥的情况下加快了查找速度。 in_array O(n)-这是因为它将对数组进行线性搜索,直到找到该值为止。 array_search O(n)-它使用与in_array相同的核心功能,但返回值。 队列功能: array_push O(∑ var_i,对于所有i) array_pop O(1) array_shift O(n)-必须重新索引所有键 array_unshift O(n + ∑ var_i,对于所有i)-必须重新索引所有键 数组相交,并集,减法: array_intersect_key 如果交集100%进行O(Max(param_i_size)* ∑param_i_count,对于所有i),如果交集0%相交O(∑param_i_size,对于所有i) array_intersect 如果交集100%对所有i执行O(n ^ 2 * ∑param_i_count,对于所有i),如果交集0%与O(n ^ 2)相交 array_intersect_assoc 如果交集100%进行O(Max(param_i_size)* ∑param_i_count,对于所有i),如果交集0%相交O(∑param_i_size,对于所有i) array_diff O(πparam_i_size,for all i)-那是所有param_sizes的乘积 array_diff_key O(∑ param_i_size,for i!= 1)-这是因为我们不需要遍历第一个数组。 array_merge O(∑ array_i,i!= 1)-不需要遍历第一个数组 (联合)O(n),其中n是第二个数组的大小(即array_first + array_second)-比array_merge少的开销,因为它不必重新编号 array_replace O(∑ array_i,对于所有i) 随机: shuffle 上) array_rand O(n)-需要线性轮询。 明显的Big-O: array_fill 上) array_fill_keys 上) range 上) array_splice O(偏移量+长度) array_slice O(偏移量+长度)或O(n)如果长度= NULL array_keys 上) array_values 上) array_reverse 上) array_pad O(pad_size) array_flip 上) array_sum 上) array_product 上) array_reduce 上) array_filter 上) array_map 上) array_chunk 上) array_combine 上) 我要感谢Eureqa使得找到函数的Big-O很容易。这是一个了不起的免费程序,可以为任意数据找到最佳拟合函数。 编辑: 对于那些怀疑PHP数组查找是的人O(N),我编写了一个基准测试(O(1)对于大多数实际值它们仍然有效)。 php数组查找图 $tests = 1000000; $max = 5000001; for( $i = 1; $i <= $max; $i += 10000 ) { //create lookup array $array = array_fill( 0, $i, NULL ); //build test indexes $test_indexes = array(); for( $j = 0; $j < $tests; $j++ ) { $test_indexes[] = rand( 0, $i-1 ); } //benchmark array lookups $start = microtime( TRUE ); foreach( $test_indexes as $test_index ) { $value = $array[ $test_index ]; unset( $value ); } $stop = microtime( TRUE ); unset( $array, $test_indexes, $test_index ); printf( "%d,%1.15f\n", $i, $stop - $start ); //time per 1mil lookups unset( $stop, $start ); } 问题来源于stack overflow
保持可爱mmm 2020-01-15 16:54:32 0 浏览量 回答数 0

回答

由于数据集与上次练习中使用的数据集相同,我们将重新使用上次的代码来加载数据。 上传参考链接:https://developer.aliyun.com/ask/260171 import numpy as np import pandas as pd import matplotlib.pyplot as plt from scipy.io import loadmat %matplotlib inline data = loadmat('data/ex3data1.mat') data {'X': array([[ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], ..., [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.]]), '__globals__': [], '__header__': 'MATLAB 5.0 MAT-file, Platform: GLNXA64, Created on: Sun Oct 16 13:09:09 2011', '__version__': '1.0', 'y': array([[10], [10], [10], ..., [ 9], [ 9], [ 9]], dtype=uint8)} 我们以后需要和经常使用变量,先创建一些有用的变量。 X = data['X'] y = data['y'] X.shape, y.shape ((5000L, 400L), (5000L, 1L) )``` 我们还需要对标签进行专有热编码。专有热编码将类标签\(n \)(出于\(k \)类)转换为长度\(k \)的向量,其中索引\(n \)为“ hot”(1),其余为零。scikit-学习有一个内置的实用工具,我们可以使用它。 ```js from sklearn.preprocessing import OneHotEncoder encoder = OneHotEncoder(sparse=False) y_onehot = encoder.fit_transform(y) y_onehot.shape (5000L, 10L) 为这个练习创建的神经网络具有与我们实例数据(400 +偏差单元)大小匹配的输入层,25个单位的隐藏层(带有26个偏差单元)和10个单位的输出层对应我们的独热编码类标签。我们需要实现成本函数,用它来评估一组给定的神经网络参数的损失,源数学函数有助于将成本函数分解成多个。以下是计算成本所需的函数。 def sigmoid(z): return 1 / (1 + np.exp(-z)) def forward_propagate(X, theta1, theta2): m = X.shape[0] a1 = np.insert(X, 0, values=np.ones(m), axis=1) z2 = a1 * theta1.T a2 = np.insert(sigmoid(z2), 0, values=np.ones(m), axis=1) z3 = a2 * theta2.T h = sigmoid(z3) return a1, z2, a2, z3, h def cost(params, input_size, hidden_size, num_labels, X, y, learning_rate): m = X.shape[0] X = np.matrix(X) y = np.matrix(y) # reshape the parameter array into parameter matrices for each layer theta1 = np.matrix(np.reshape(params[:hidden_size * (input_size + 1)], (hidden_size, (input_size + 1)))) theta2 = np.matrix(np.reshape(params[hidden_size * (input_size + 1):], (num_labels, (hidden_size + 1)))) # run the feed-forward pass a1, z2, a2, z3, h = forward_propagate(X, theta1, theta2) # compute the cost J = 0 for i in range(m): first_term = np.multiply(-y[i,:], np.log(h[i,:])) second_term = np.multiply((1 - y[i,:]), np.log(1 - h[i,:])) J += np.sum(first_term - second_term) J = J / m return J 我们之前已经使用过sigmoid函数。正向传播函数计算给定当前参数的每个训练实例的假设(换句话说,给定神经网络当前的状态和一组输入,它能计算出神经网络每一层假设向量(由\(h \)表示)的形状,包含了每个类的预测概率,应该与y的独热编码相匹配。最后成本函数运行正向传播步,并计算实例的假设(预测)和真实标签之间的误差。 可以快速测试一下它是否按预期的工作。从中间步骤中看到的输出也有助于了解发生了什么。 # initial setup input_size = 400 hidden_size = 25 num_labels = 10 learning_rate = 1 # randomly initialize a parameter array of the size of the full network's parameters params = (np.random.random(size=hidden_size * (input_size + 1) + num_labels * (hidden_size + 1)) - 0.5) * 0.25 m = X.shape[0] X = np.matrix(X) y = np.matrix(y) # unravel the parameter array into parameter matrices for each layer theta1 = np.matrix(np.reshape(params[:hidden_size * (input_size + 1)], (hidden_size, (input_size + 1)))) theta2 = np.matrix(np.reshape(params[hidden_size * (input_size + 1):], (num_labels, (hidden_size + 1)))) theta1.shape, theta2.shape ((25L, 401L), (10L, 26L)) a1, z2, a2, z3, h = forward_propagate(X, theta1, theta2) a1.shape, z2.shape, a2.shape, z3.shape, h.shape ((5000L, 401L), (5000L, 25L), (5000L, 26L), (5000L, 10L), (5000L, 10L)) 计算假设矩阵\(h \)后的成本函数,用成本方程式计算\(y \)和\(h \)之间的总偏差。 cost(params, input_size, hidden_size, num_labels, X, y_onehot, learning_rate) 6.8228086634127862 下一步是在成本函数中增加正则化,增加了与参数大小相关的惩罚项。这个方程式可以归结为一行代码,将其添加到成本函数中。只需在返回语句之前添加以下内容。 J+= (float(learning_rate)/ (2 * m))* (np.sum(np.power(theta1[:,1:],2))+ np.sum(np.power(theta2[:,1:],2))) 接下来是反向传播算法,反向传播算法计算参数更新以减少训练数据的误差。我们首先需要的是一个函数,用来计算我们先前创建的Sigmoid函数梯度。 def sigmoid_gradient(z): return np.multiply(sigmoid(z), (1 - sigmoid(z))) 现在我们准备用反向传播算法来计算梯度,由于反向传播算法所需的计算是成本函数要求的超集,我们将扩展成本函数来执行反向传播算法,并返回成本和梯度函数。 backprop函数中调用了现有的成本函数来使设计更加正确的原因是,backprop函数使用了成本函数计算的一些其他变量。我跳过了完整的实现,添加了渐变正则化。 def backprop(params, input_size, hidden_size, num_labels, X, y, learning_rate): ##### this section is identical to the cost function logic we already saw ##### m = X.shape[0] X = np.matrix(X) y = np.matrix(y) # reshape the parameter array into parameter matrices for each layer theta1 = np.matrix(np.reshape(params[:hidden_size * (input_size + 1)], (hidden_size, (input_size + 1)))) theta2 = np.matrix(np.reshape(params[hidden_size * (input_size + 1):], (num_labels, (hidden_size + 1)))) # run the feed-forward pass a1, z2, a2, z3, h = forward_propagate(X, theta1, theta2) # initializations J = 0 delta1 = np.zeros(theta1.shape) # (25, 401) delta2 = np.zeros(theta2.shape) # (10, 26) # compute the cost for i in range(m): first_term = np.multiply(-y[i,:], np.log(h[i,:])) second_term = np.multiply((1 - y[i,:]), np.log(1 - h[i,:])) J += np.sum(first_term - second_term) J = J / m # add the cost regularization term J += (float(learning_rate) / (2 * m)) * (np.sum(np.power(theta1[:,1:], 2)) + np.sum(np.power(theta2[:,1:], 2))) ##### end of cost function logic, below is the new part ##### # perform backpropagation for t in range(m): a1t = a1[t,:] # (1, 401) z2t = z2[t,:] # (1, 25) a2t = a2[t,:] # (1, 26) ht = h[t,:] # (1, 10) yt = y[t,:] # (1, 10) d3t = ht - yt # (1, 10) z2t = np.insert(z2t, 0, values=np.ones(1)) # (1, 26) d2t = np.multiply((theta2.T * d3t.T).T, sigmoid_gradient(z2t)) # (1, 26) delta1 = delta1 + (d2t[:,1:]).T * a1t delta2 = delta2 + d3t.T * a2t delta1 = delta1 / m delta2 = delta2 / m # add the gradient regularization term delta1[:,1:] = delta1[:,1:] + (theta1[:,1:] * learning_rate) / m delta2[:,1:] = delta2[:,1:] + (theta2[:,1:] * learning_rate) / m # unravel the gradient matrices into a single array grad = np.concatenate((np.ravel(delta1), np.ravel(delta2))) return J, grad 成本函数的第一部分通过“神经网络”(正向传播函数)运行数据和当前参数来计算误差,将输出与真实标签作比较。数据集的总误差表示为\(J \)。这部分是我们之前的过的成本函数。 成本函数的其余部分的本质是回答“下次运行网络时,如何调整参数以减少误差?”,它通过计算每层的贡献与总误差,提出“梯度”矩阵(或者改变参数和方向)进行适当调整。 backprop计算中最难的部分是获取矩阵维度。顺便说一下,不是只有你对使用A * B和np.multiply(A,B)感到疑惑。 让我们测试一下,以确保函数返回我们所期望的。 J, grad = backprop(params, input_size, hidden_size, num_labels, X, y_onehot, learning_rate) J, grad.shape (6.8281541822949299, (10285L,)) 最后训练我们的神经网络,利用它做出的预测,这和先前的多层次逻辑回归大致相同。 from scipy.optimize import minimize # minimize the objective function fmin = minimize(fun=backprop, x0=params, args=(input_size, hidden_size, num_labels, X, y_onehot, learning_rate), method='TNC', jac=True, options={'maxiter': 250}) fmin status: 3 success: False nfev: 250 fun: 0.33900736818312283 x: array([ -8.85740564e-01, 2.57420350e-04, -4.09396202e-04, ..., 1.44634791e+00, 1.68974302e+00, 7.10121593e-01]) message: 'Max. number of function evaluations reach' jac: array([ -5.11463703e-04, 5.14840700e-08, -8.18792403e-08, ..., -2.48297749e-04, -3.17870911e-04, -3.31404592e-04]) nit: 21 由于目标函数不太可能完全收敛,我们对迭代次数进行限制。我们的总成本已经下降到0.5以下,这是算法正常工作的一个指标。我们用它找到的参数,然后通过神经网络正向传播它们以获得一些预测。我们必须重构优化器的输出,以匹配神经网络所期望的参数矩阵形状,然后运行正向传播函数以生成输入数据的假设。 X = np.matrix(X) theta1 = np.matrix(np.reshape(fmin.x[:hidden_size * (input_size + 1)], (hidden_size, (input_size + 1)))) theta2 = np.matrix(np.reshape(fmin.x[hidden_size * (input_size + 1):], (num_labels, (hidden_size + 1)))) a1, z2, a2, z3, h = forward_propagate(X, theta1, theta2) y_pred = np.array(np.argmax(h, axis=1) + 1) y_pred array([[10], [10], [10], ..., [ 9], [ 9], [ 9]], dtype=int64) 最后计算准确度以观察我们训练过的神经网络的工作状况 correct = [1 if a == b else 0 for (a, b) in zip(y_pred, y)] accuracy = (sum(map(int, correct)) / float(len(correct))) print 'accuracy = {0}%'.format(accuracy * 100) accuracy = 99.22% 我们完成了,我们已经成功地实施了一个基本的反向传播的前馈式神经网络,并用它来分类手写数字图像。
珍宝珠 2019-12-02 03:22:37 0 浏览量 回答数 0

回答

首先加载数据集。与前面的示例不同,我们的数据文件是MATLAB的本体格式,不能被pandas自动识别,所以把它加载在Python中需要使用SciPy utility。 import numpy as np import pandas as pd import matplotlib.pyplot as plt from scipy.io import loadmat %matplotlib inline data = loadmat('data/ex3data1.mat') data {'X': array([[ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], ..., [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.], [ 0., 0., 0., ..., 0., 0., 0.]]), '__globals__': [], '__header__': 'MATLAB 5.0 MAT-file, Platform: GLNXA64, Created on: Sun Oct 16 13:09:09 2011', '__version__': '1.0', 'y': array([[10], [10], [10], ..., [ 9], [ 9], [ 9]], dtype=uint8)} 快速检查加载到储存器中的矩阵的形状 data['X'].shape, data['y'].shape > ((5000L, 400L), (5000L, 1L)) 我们已经加载了我们的数据。图像在martix X 被表现为400维的向量。这400个“特征”是原始20×20图像中每个像素的灰度强度。类标签在向量y中表示图像中数字的数字类。下面的图片给出了一些数字的例子。每个带有白色手写数字的灰色框代表我们数据集中400维的行。 我们的第一个任务是修改逻辑回归的实现以完全向量化(即没有“for”循环),这是因为矢量化代码除了简洁扼要,还能够利用线性代数优化,并且比迭代代码快得多。我们在练习二中的成本函数实现已经向量化。所以我们在这里重复使用相同的实现。请注意,我们正在跳到最终的正则化版本。 def sigmoid(z): return 1 / (1 + np.exp(-z)) def cost(theta, X, y, learningRate): theta = np.matrix(theta) X = np.matrix(X) y = np.matrix(y) first = np.multiply(-y, np.log(sigmoid(X * theta.T))) second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T))) reg = (learningRate / 2 * len(X)) * np.sum(np.power(theta[:,1:theta.shape[1]], 2)) return np.sum(first - second) / (len(X)) + reg 这个成本函数与我们在先前练习中创建的函数是相同的,如果你不确定我们如何做到这一点,在运行之前查看以前的文章。 接下来,我们需要计算梯度的函数。我们已经在前面的练习中定义了它,我们在更新步骤中需要去掉“for”循环。这是可供参考的原始代码: def gradient_with_loop(theta, X, y, learningRate): theta = np.matrix(theta) X = np.matrix(X) y = np.matrix(y) parameters = int(theta.ravel().shape[1]) grad = np.zeros(parameters) error = sigmoid(X * theta.T) - y for i in range(parameters): term = np.multiply(error, X[:,i]) if (i == 0): grad[i] = np.sum(term) / len(X) else: grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i]) return grad 梯度函数详细的阐述了如何改变一个参数,以获得一个比之前好的答案。如果你不熟悉线性代数,这一系列运作背后的数学是很难理解的。 现在我们需要创建一个不使用任何循环的梯度函数的版本。在我们的新版本中,我们将去掉“for”循环,并使用线性代数(除了截距参数,它需要单独计算)计算每个参数的梯度。 还要注意,我们将数据结构转换为NumPy矩阵。这样做是为了使代码看起来更像Octave,而不是数组,这是因为矩阵自动遵循矩阵运算规则与element-wise运算。我们在下面的例子中使用矩阵。 def gradient(theta, X, y, learningRate): theta = np.matrix(theta) X = np.matrix(X) y = np.matrix(y) parameters = int(theta.ravel().shape[1]) error = sigmoid(X * theta.T) - y grad = ((X.T * error) / len(X)).T + ((learningRate / len(X)) * theta) # intercept gradient is not regularized grad[0, 0] = np.sum(np.multiply(error, X[:,0])) / len(X) return np.array(grad).ravel() 现在我们已经定义了成本和梯度函数,接下来创建一个分类器。对于本章练习的任务,我们有10个可能的分类,由于逻辑回归一次只能区分两个类别,我们需要一个方法去处理多类别场景。在这个练习中我们的任务是实现一对多的分类,其中k个不同类的标签导致了k个分类器,每个分类器在“class i”和“not class i”之间做决定。我们将在一个函数中完成分类器的训练,计算10个分类器的最终权重,并将权重返回作为k X(n + 1)数组,其中n是参数数。 from scipy.optimize import minimize def one_vs_all(X, y, num_labels, learning_rate): rows = X.shape[0] params = X.shape[1] # k X (n + 1) array for the parameters of each of the k classifiers all_theta = np.zeros((num_labels, params + 1)) # insert a column of ones at the beginning for the intercept term X = np.insert(X, 0, values=np.ones(rows), axis=1) # labels are 1-indexed instead of 0-indexed for i in range(1, num_labels + 1): theta = np.zeros(params + 1) y_i = np.array([1 if label == i else 0 for label in y]) y_i = np.reshape(y_i, (rows, 1)) # minimize the objective function fmin = minimize(fun=cost, x0=theta, args=(X, y_i, learning_rate), method='TNC', jac=gradient) all_theta[i-1,:] = fmin.x return all_theta 这里需要注意的几点:首先,我们为theta添加了一个额外的参数(带有一列训练数据)以计算截距项。其次,我们将y从类标签转换为每个分类器的二进制值(要么是I类,要么不是I类)。最后,我们使用SciPy的较新优化API来最小化每个分类器的成本函数。API利用目标函数、初始参数集、优化方法和jacobian(梯度)函数,将优化程序找到的参数分配给参数数组。 实现向量化代码的一个更具挑战性的部分是正确地写入所有的矩阵交互,所以通过查看正在使用的数组/矩阵的形状来做一些健全性检查是有用的,我们来看看上面的函数中使用的一些数据结构。 rows = data['X'].shape[0] params = data['X'].shape[1] all_theta = np.zeros((10, params + 1)) X = np.insert(data['X'], 0, values=np.ones(rows), axis=1) theta = np.zeros(params + 1) y_0 = np.array([1 if label == 0 else 0 for label in data['y']]) y_0 = np.reshape(y_0, (rows, 1)) X.shape, y_0.shape, theta.shape, all_theta.shape > ((5000L, 401L), (5000L, 1L), (401L,), (10L, 401L)) 注意,theta是一维数组,所以当它被转换为计算梯度的代码中的矩阵时,它变成一个(1×401)矩阵。 我们还要检查y中的类标签,以确保它们看起来像我们期望的。 np.unique(data['y']) > array([1, 2, 3, 4, 5, 6, 7, 8, 9,10], dtype=uint8) 确保函数正常运行,并获得一些合理的输出。 all_theta= one_vs_all(data['X'], data['y'],10,1) all_theta array([[ -5.79312170e+00, 0.00000000e+00, 0.00000000e+00, ..., 1.22140973e-02, 2.88611969e-07, 0.00000000e+00], [ -4.91685285e+00, 0.00000000e+00, 0.00000000e+00, ..., 2.40449128e-01, -1.08488270e-02, 0.00000000e+00], [ -8.56840371e+00, 0.00000000e+00, 0.00000000e+00, ..., -2.59241796e-04, -1.12756844e-06, 0.00000000e+00], ..., [ -1.32641613e+01, 0.00000000e+00, 0.00000000e+00, ..., -5.63659404e+00, 6.50939114e-01, 0.00000000e+00], [ -8.55392716e+00, 0.00000000e+00, 0.00000000e+00, ..., -2.01206880e-01, 9.61930149e-03, 0.00000000e+00], [ -1.29807876e+01, 0.00000000e+00, 0.00000000e+00, ..., 2.60651472e-04, 4.22693052e-05, 0.00000000e+00]]) 最后一步是使用训练过的分类器预测每个图像的标签。对于这一步骤,对于每个训练实例(使用矢量化代码),我们将计算每个类的类概率,并将输出类标签分配给具有最高概率的类。 def predict_all(X, all_theta): rows = X.shape[0] params = X.shape[1] num_labels = all_theta.shape[0] # same as before, insert ones to match the shape X = np.insert(X, 0, values=np.ones(rows), axis=1) # convert to matrices X = np.matrix(X) all_theta = np.matrix(all_theta) # compute the class probability for each class on each training instance h = sigmoid(X * all_theta.T) # create array of the index with the maximum probability h_argmax = np.argmax(h, axis=1) # because our array was zero-indexed we need to add one for the true label prediction h_argmax = h_argmax + 1 return h_argmax 现在我们可以使用predict_all函数为每个实例生成类预测,并了解分类器的工作情况。 y_pred = predict_all(data['X'], all_theta) correct = [1 if a == b else 0 for (a, b) in zip(y_pred, data['y'])] accuracy = (sum(map(int, correct)) / float(len(correct))) print 'accuracy = {0}%'.format(accuracy * 100) > accuracy = 97.58% 接近98%,相当不错,逻辑回归是一个相对简单的方法。 可参考:http://www.atyun.com/4260.html
珍宝珠 2019-12-02 03:22:33 0 浏览量 回答数 0

回答

最大似然估计(MLE)是获得分布参数的点估计的最重要的过程之一。这是您需要开始的。 分析解决方案: 跨国公司分布的一个扩展二项式分布为其MLE可以分析获得。请参阅此数学堆栈交换帖(MLE for Multinomial Distribution)以获得完整的分析解决方案。该过程从定义似然函数开始,L(p)以观测数据x(i)为条件,其中p和x是k 类/类别的概率和观察到的出现,并且i = 0,1,... k。它是给定参数集(p)观察一组观测值(x)的可能性的度量: L(p)等于: 主要思想是在参数范围(p)上最大化似然函数值。给定总观测值n(即所有类别的出现总和),点估计等于: a.values/a.values.sum() # point estimates for p = x/n # array([[0. ], [0.02941176], [0.05882353], [0.08823529], # [0.05882353], [0.02941176], [0.17647059], [0. ], # [0.02941176], [0.02941176], [0.20588235], [0.29411765]]) 数值解: 上述结果也可以用数字方法获得scipy.optimize.minimize。请注意,L(p)是阶乘和指数项的乘积。阶乘项是常数,不依赖于参数值(p),因此不考虑优化。对于指数项,最好执行对数转换以简化目标函数; MLE的常见做法,因为log是单调递增函数。此外,由于scipy.optimize.minimize用于最小化,我们将使用对数变换似然函数的负数。注意 最大化函数值等于最小化其负值。 import pandas as pd import numpy as np import scipy.optimize as sciopt # bounds for parameters to lie between (0,1), # absolute zero (0) for lower bound avoided as log takes an infinite value bnds = [(0.001e-12,1) for i in range(12)] # Initializing parameters value for optimization init_parameters = np.asarray([0.1 for i in range(12)]) # Negative Log Likelihood Function neg_log_lik = lambda p: -np.sum([a.values[i]*np.log(p[i]) for i in range(12)]) # Constraint sum(p) = 1 cons = {'type': 'eq', 'fun': lambda p: (sum([p[i] for i in range(12)]) - 1) } # Minimizing neg_log_lik results = sciopt.minimize(neg_log_lik, x0 = init_parameters, method='SLSQP', bounds= bnds, constraints= cons) results.x # point estimates for p # array([1.00000000e-15, 2.94179308e-02, 5.88243586e-02, 8.82394605e-02, # 5.88243586e-02, 2.94059735e-02, 1.76454713e-01, 1.00000000e-15, # 2.94134577e-02, 2.94135714e-02, 2.05849197e-01, 2.94156978e-01]) 有关上述实现的详细信息,请参阅scipy.optimize.minimize 文档。 不知道对不对
寒喵 2019-12-02 01:08:50 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倍,可能是因为我们丢失了一些细节部分。
珍宝珠 2019-12-02 03:22:40 0 浏览量 回答数 0

回答

异常检测 我们的第一个任务是利用高斯模型判断数据集里未标记的例子是否应该被认为是异常的。我们可以在简单的二维数据集上开始,这样就可以很容易的看到算法如何工作。 加载数据并绘图 import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sb from scipy.io import loadmat %matplotlib inline data = loadmat('data/ex8data1.mat') X = data['X'] X.shape (307L,2L) fig, ax= plt.subplots(figsize=(12,8)) ax.scatter(X[:,0], X[:,1]) 在中心有一个非常紧密的集群,有几个值离集群比较远。在这个简单的例子中,这几个值可以被视为异常。为了找到原因,我们需要估算数据中每个特征的高斯分布。我们需要用均值和方差定义概率分布。为此,我们将创建一个简单的函数,计算数据集中每个特征的均值和方差。 def estimate_gaussian(X): mu = X.mean(axis=0) sigma = X.var(axis=0) return mu, sigma mu, sigma = estimate_gaussian(X) mu, sigma (array([14.11222578, 14.99771051]), array([1.83263141, 1.70974533])) 现在我们已经有了模型参数,接下来需要确定概率阈值,它用来表明例子应该是否被视为异常值。我们需要使用一系列标签验证数据(真正的异常数据已经被标出),并且在给出不同阈值的情况下测试模型的识别性能。 Xval = data['Xval'] yval = data['yval'] Xval.shape, yval.shape ((307L,2L), (307L,1L)) 我们还需要一种方法来计算数据点属于给定参数集正态分布的概率。幸运的是SciPy内置了这种方法。 from scipy import stats dist = stats.norm(mu[0], sigma[0]) dist.pdf(X[:,0])[0:50] array([ 0.183842 , 0.20221694, 0.21746136, 0.19778763, 0.20858956, 0.21652359, 0.16991291, 0.15123542, 0.1163989 , 0.1594734 , 0.21716057, 0.21760472, 0.20141857, 0.20157497, 0.21711385, 0.21758775, 0.21695576, 0.2138258 , 0.21057069, 0.1173018 , 0.20765108, 0.21717452, 0.19510663, 0.21702152, 0.17429399, 0.15413455, 0.21000109, 0.20223586, 0.21031898, 0.21313426, 0.16158946, 0.2170794 , 0.17825767, 0.17414633, 0.1264951 , 0.19723662, 0.14538809, 0.21766361, 0.21191386, 0.21729442, 0.21238912, 0.18799417, 0.21259798, 0.21752767, 0.20616968, 0.21520366, 0.1280081 , 0.21768113, 0.21539967, 0.16913173]) 在不清楚的情况下,我们只需要计算数据集第一维度的前50个实例的分布概率,这些概率是通过计算该维度的均值和方差得到的。 在我们计算的高斯模型参数中,计算并保存数据集中的每一个值的概率密度。 p = np.zeros((X.shape[0], X.shape[1])) p[:,0] = stats.norm(mu[0], sigma[0]).pdf(X[:,0]) p[:,1] = stats.norm(mu[1], sigma[1]).pdf(X[:,1]) p.shape (307L,2L) 我们还需要为验证集(使用相同的模型参数)执行此操作。我们将使用这些概率和真实标签来确定最优概率阈值,进而指定数据点作为异常值。 pval = np.zeros((Xval.shape[0], Xval.shape[1])) pval[:,0] = stats.norm(mu[0], sigma[0]).pdf(Xval[:,0]) pval[:,1] = stats.norm(mu[1], sigma[1]).pdf(Xval[:,1]) 接下来我们需要一个函数,在给出的概率密度和真实标签中找到最佳阈值。为了执行这步操作,我们需要计算不同值的epsilon的F1分数,F1是true positive, false positive和 false negative数值的函数。 def select_threshold(pval, yval): best_epsilon = 0 best_f1 = 0 f1 = 0 step = (pval.max() - pval.min()) / 1000 for epsilon in np.arange(pval.min(), pval.max(), step): preds = pval < epsilon tp = np.sum(np.logical_and(preds == 1, yval == 1)).astype(float) fp = np.sum(np.logical_and(preds == 1, yval == 0)).astype(float) fn = np.sum(np.logical_and(preds == 0, yval == 1)).astype(float) precision = tp / (tp + fp) recall = tp / (tp + fn) f1 = (2 * precision * recall) / (precision + recall) if f1 > best_f1: best_f1 = f1 best_epsilon = epsilon return best_epsilon, best_f1 epsilon, f1 = select_threshold(pval, yval) epsilon, f1 (0.0095667060059568421,0.7142857142857143) 最后我们在数据集上应用阈值,可视化结果。 # indexes of the values considered to be outliers outliers = np.where(p < epsilon) fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(X[:,0], X[:,1]) ax.scatter(X[outliers[0],0], X[outliers[0],1], s=50, color='r', marker='o') 结果还不错,红色的点是被标记为离群值的点,视觉上这些看起来很合理。有一些分离(但没有被标记)的右上角的点也可能是一个离群值,但这是相当接近的。 协同过滤 推荐系统使用项目和基于用户的相似性计算,以检查用户的历史偏好,从而为用户推荐可能感兴趣的新“东西”。在这个练习中,我们将实现一种特殊的推荐算法,称为协同过滤,并将其应用于电影评分的数据集。首先加载并检查我们要处理的数据。 data= loadmat('data/ex8_movies.mat') data {'R': array([[1, 1, 0, ..., 1, 0, 0], [1, 0, 0, ..., 0, 0, 1], [1, 0, 0, ..., 0, 0, 0], ..., [0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0]], dtype=uint8), 'Y': array([[5, 4, 0, ..., 5, 0, 0], [3, 0, 0, ..., 0, 0, 5], [4, 0, 0, ..., 0, 0, 0], ..., [0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0]], dtype=uint8), '__globals__': [], '__header__': 'MATLAB 5.0 MAT-file, Platform: GLNXA64, Created on: Thu Dec 1 17:19:26 2011', '__version__': '1.0'} Y是一个包含从一到五的评分的数据组,R是一个包含二进制值的“指示器”数据组,它表明了用户是否对电影进行了评分。两者应该具有相同的形状。 Y = data['Y'] R = data['R'] Y.shape, R.shape ((1682L,943L), (1682L,943L)) 我们可以通过Y中的一行平均值来评估电影的平均评分。 Y[1,R[1,:]].mean() 2.5832449628844114 如果它是图片的话,我们也通过渲染矩阵来可视化数据。 fig, ax = plt.subplots(figsize=(12,12)) ax.imshow(Y) ax.set_xlabel('Users') ax.set_ylabel('Movies') fig.tight_layout() 接下来我们将实现协同过滤的成本函数。“成本”是指电影评分预测偏离真实预测的程度。在文本练习中,成本函数是给定的。它以文本中的X和Theta参数矩阵为基础,这些展开到参数输入中,以便使用SciPy的优化包。注意,我已经在注释中包含了数组/矩阵形状,以帮助说明矩阵交互如何工作。 def cost(params, Y, R, num_features): Y = np.matrix(Y) # (1682, 943) R = np.matrix(R) # (1682, 943) num_movies = Y.shape[0] num_users = Y.shape[1] # reshape the parameter array into parameter matrices X = np.matrix(np.reshape(params[:num_movies * num_features], (num_movies, num_features))) # (1682, 10) Theta = np.matrix(np.reshape(params[num_movies * num_features:], (num_users, num_features))) # (943, 10) # initializations J = 0 # compute the cost error = np.multiply((X * Theta.T) - Y, R) # (1682, 943) squared_error = np.power(error, 2) # (1682, 943) J = (1. / 2) * np.sum(squared_error) return J 我们提供一系列预先训练过并且我们可以评估的参数进行测试。为了减少评估时间,我们研究较小的子集。 users = 4 movies = 5 features = 3 params_data = loadmat('data/ex8_movieParams.mat') X = params_data['X'] Theta = params_data['Theta'] X_sub = X[:movies, :features] Theta_sub = Theta[:users, :features] Y_sub = Y[:movies, :users] R_sub = R[:movies, :users] params = np.concatenate((np.ravel(X_sub), np.ravel(Theta_sub))) cost(params, Y_sub, R_sub, features) 22.224603725685675 答案与练习文本中的结果匹配。接下来需要实现梯度计算,与练习四中神经网络的实现一样,我们会扩展成本函数计算梯度。 def cost(params, Y, R, num_features): Y = np.matrix(Y) # (1682, 943) R = np.matrix(R) # (1682, 943) num_movies = Y.shape[0] num_users = Y.shape[1] # reshape the parameter array into parameter matrices X = np.matrix(np.reshape(params[:num_movies * num_features], (num_movies, num_features))) # (1682, 10) Theta = np.matrix(np.reshape(params[num_movies * num_features:], (num_users, num_features))) # (943, 10) # initializations J = 0 X_grad = np.zeros(X.shape) # (1682, 10) Theta_grad = np.zeros(Theta.shape) # (943, 10) # compute the cost error = np.multiply((X * Theta.T) - Y, R) # (1682, 943) squared_error = np.power(error, 2) # (1682, 943) J = (1. / 2) * np.sum(squared_error) # calculate the gradients X_grad = error * Theta Theta_grad = error.T * X # unravel the gradient matrices into a single array grad = np.concatenate((np.ravel(X_grad), np.ravel(Theta_grad))) return J, grad J, grad = cost(params, Y_sub, R_sub, features) J, grad (22.224603725685675, array([ -2.52899165, 7.57570308, -1.89979026, -0.56819597, 3.35265031, -0.52339845, -0.83240713, 4.91163297, -0.76677878, -0.38358278, 2.26333698, -0.35334048, -0.80378006, 4.74271842, -0.74040871, -10.5680202 , 4.62776019, -7.16004443, -3.05099006, 1.16441367, -3.47410789, 0. , 0. , 0. , 0. , 0. , 0. ])) 下一步是在成本和梯度计算中添加正则化。最终会创建一个正则化版本的函数。(注意,这个版本包含一个额外的学习速率参数“lambda”) def cost(params, Y, R, num_features, learning_rate): Y = np.matrix(Y) # (1682, 943) R = np.matrix(R) # (1682, 943) num_movies = Y.shape[0] num_users = Y.shape[1] # reshape the parameter array into parameter matrices X = np.matrix(np.reshape(params[:num_movies * num_features], (num_movies, num_features))) # (1682, 10) Theta = np.matrix(np.reshape(params[num_movies * num_features:], (num_users, num_features))) # (943, 10) # initializations J = 0 X_grad = np.zeros(X.shape) # (1682, 10) Theta_grad = np.zeros(Theta.shape) # (943, 10) # compute the cost error = np.multiply((X * Theta.T) - Y, R) # (1682, 943) squared_error = np.power(error, 2) # (1682, 943) J = (1. / 2) * np.sum(squared_error) # add the cost regularization J = J + ((learning_rate / 2) * np.sum(np.power(Theta, 2))) J = J + ((learning_rate / 2) * np.sum(np.power(X, 2))) # calculate the gradients with regularization X_grad = (error * Theta) + (learning_rate * X) Theta_grad = (error.T * X) + (learning_rate * Theta) # unravel the gradient matrices into a single array grad = np.concatenate((np.ravel(X_grad), np.ravel(Theta_grad))) return J, grad J, grad = cost(params, Y_sub, R_sub, features, 1.5) J, grad (31.344056244274221, array([ -0.95596339, 6.97535514, -0.10861109, 0.60308088, 2.77421145, 0.25839822, 0.12985616, 4.0898522 , -0.89247334, 0.29684395, 1.06300933, 0.66738144, 0.60252677, 4.90185327, -0.19747928, -10.13985478, 2.10136256, -6.76563628, -2.29347024, 0.48244098, -2.99791422, -0.64787484, -0.71820673, 1.27006666, 1.09289758, -0.40784086, 0.49026541])) 结果与执行代码的预期输出匹配,看起来正则化是有效的。在训练模型之前,还有最后一步:创建我们自己的电影评分模型,这样我们就可以使用这个模型来生成个性化的建议。我们得到了一个将电影索引链接到其标题的文件。把文件加载到字典中,并使用练习文本提供的一些样本评分。 movie_idx = {} f = open('data/movie_ids.txt') for line in f: tokens = line.split(' ') tokens[-1] = tokens[-1][:-1] movie_idx[int(tokens[0]) - 1] = ' '.join(tokens[1:]) ratings = np.zeros((1682, 1)) ratings[0] = 4 ratings[6] = 3 ratings[11] = 5 ratings[53] = 4 ratings[63] = 5 ratings[65] = 3 ratings[68] = 5 ratings[97] = 2 ratings[182] = 4 ratings[225] = 5 ratings[354] = 5 print('Rated {0} with {1} stars.'.format(movie_idx[0], str(int(ratings[0])))) print('Rated {0} with {1} stars.'.format(movie_idx[6], str(int(ratings[6])))) print('Rated {0} with {1} stars.'.format(movie_idx[11], str(int(ratings[11])))) print('Rated {0} with {1} stars.'.format(movie_idx[53], str(int(ratings[53])))) print('Rated {0} with {1} stars.'.format(movie_idx[63], str(int(ratings[63])))) print('Rated {0} with {1} stars.'.format(movie_idx[65], str(int(ratings[65])))) print('Rated {0} with {1} stars.'.format(movie_idx[68], str(int(ratings[68])))) print('Rated {0} with {1} stars.'.format(movie_idx[97], str(int(ratings[97])))) print('Rated {0} with {1} stars.'.format(movie_idx[182], str(int(ratings[182])))) print('Rated {0} with {1} stars.'.format(movie_idx[225], str(int(ratings[225])))) print('Rated {0} with {1} stars.'.format(movie_idx[354], str(int(ratings[354])))) Rated Toy Story (1995) with 4 stars. Rated Twelve Monkeys (1995) with 3 stars. Rated Usual Suspects, The (1995) with 5 stars. Rated Outbreak (1995) with 4 stars. Rated Shawshank Redemption, The (1994) with 5 stars. Rated While You Were Sleeping (1995) with 3 stars. Rated Forrest Gump (1994) with 5 stars. Rated Silence of the Lambs, The (1991) with 2 stars. Rated Alien (1979) with 4 stars. Rated Die Hard 2 (1990) with 5 stars. Rated Sphere (1998) with 5 stars. 我们可以在数据集中添加自定义评分向量。 R = data['R'] Y = data['Y'] Y = np.append(Y, ratings, axis=1) R = np.append(R, ratings != 0, axis=1) 开始训练协同过滤模型,我们将通过成本函数、参数向量和输入的数据矩阵使评分正规化,并且运行优化程序。 from scipy.optimize import minimize movies = Y.shape[0] users = Y.shape[1] features = 10 learning_rate = 10. X = np.random.random(size=(movies, features)) Theta = np.random.random(size=(users, features)) params = np.concatenate((np.ravel(X), np.ravel(Theta))) Ymean = np.zeros((movies, 1)) Ynorm = np.zeros((movies, users)) for i in range(movies): idx = np.where(R[i,:] == 1)[0] Ymean[i] = Y[i,idx].mean() Ynorm[i,idx] = Y[i,idx] - Ymean[i] fmin = minimize(fun=cost, x0=params, args=(Ynorm, R, features, learning_rate), method='CG', jac=True, options={'maxiter': 100}) fmin status: 1 success: False njev: 149 nfev: 149 fun: 38953.88249706676 x: array([-0.07177334, -0.08315075, 0.1081135 , ..., 0.1817828 , 0.16873062, 0.03383596]) message: 'Maximum number of iterations has been exceeded.' jac: array([ 0.01833555, 0.07377974, 0.03999323, ..., -0.00970181, 0.00758961, -0.01181811]) 由于所有的优化程序都是“unrolled”,因此要正确地工作,需要将我们的矩阵重新调整回原来的维度。 X = np.matrix(np.reshape(fmin.x[:movies * features], (movies, features))) Theta = np.matrix(np.reshape(fmin.x[movies * features:], (users, features))) X.shape, Theta.shape ((1682L,10L), (944L,10L)) 我们训练过的参数有X和Theta,使用这些为我们以前添加的用户提供建议。 predictions = X * Theta.T my_preds = predictions[:, -1] + Ymean sorted_preds = np.sort(my_preds, axis=0)[::-1] sorted_preds[:10] matrix([[ 5.00000264], [ 5.00000249], [ 4.99999831], [ 4.99999671], [ 4.99999659], [ 4.99999253], [ 4.99999238], [ 4.9999915 ], [ 4.99999019], [ 4.99998643]] 这给了我们一个有序的最高评分名单,但我们失去了评分的索引。我们需要使用argsort来了解预测评分对应的电影。 idx = np.argsort(my_preds, axis=0)[::-1] print("Top 10 movie predictions:") for i in range(10): j = int(idx[i]) print('Predicted rating of {0} for movie {1}.'.format(str(float(my_preds[j])), movie_idx[j])) Top 10 movie predictions: Predicted rating of 5.00000264002 for movie Prefontaine (1997). Predicted rating of 5.00000249142 for movie Santa with Muscles (1996). Predicted rating of 4.99999831018 for movie Marlene Dietrich: Shadow and Light (1996) . Predicted rating of 4.9999967124 for movie Saint of Fort Washington, The (1993). Predicted rating of 4.99999658864 for movie They Made Me a Criminal (1939). Predicted rating of 4.999992533 for movie Someone Else's America (1995). Predicted rating of 4.99999238336 for movie Great Day in Harlem, A (1994). Predicted rating of 4.99999149604 for movie Star Kid (1997). Predicted rating of 4.99999018592 for movie Aiqing wansui (1994). Predicted rating of 4.99998642746 for movie Entertaining Angels: The Dorothy Day Story (1996). 实际上推荐的电影并没有很好地符合练习文本中的内容。原因不太清楚,我还没有找到任何可以解释的理由,在代码中可能有错误。不过,即使有一些细微的差别,这个例子的大部分也是准确的。
珍宝珠 2019-12-02 03:22:42 0 浏览量 回答数 0

回答

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

问题

MPP计算引擎 SELECT语法是什么?

语法描述 [ WITH with_query [, ...] ]SELECT [ ALL | DISTINCT ] select_expr [, ...][ FROM from_item [, ...] ][ WHERE conditi...
nicenelly 2019-12-01 21:25:30 1617 浏览量 回答数 0

问题

MPP计算引擎 SELECT语法是什么?

语法描述 <PRE prettyprinted? linenums> [ WITH with_query [, ...] ]SELECT [ ALL | DISTINCT ] select_expr [, ...][ FROM...
nicenelly 2019-12-01 21:10:51 1381 浏览量 回答数 0

问题

数独益智游戏,内含正方形数字

两天前,我遇到了一个数独问题,尝试使用Python 3解决。我被告知确实存在一个解决方案,但是我不确定是否存在多个解决方案。 问题如下:数独的9x9网格完全为空。但是,...
is大龙 2020-03-23 20:21:05 5 浏览量 回答数 1

问题

Lambda表达式和函数是什么?

Lambda Expression Lambda表达式写为 ->: x -> x + 1(x, y) -> x + yx -> regexp_like(x, 'a+')x ...
nicenelly 2019-12-01 21:26:42 1371 浏览量 回答数 0

问题

从截断的高斯分布生成numpy向量化值

我有一个函数,它从截断的正态分布中生成一个值,并带有一个while循环,该循环可确保舍弃位于截断之外的任何生成的值,并将其替换为另一代,直到其位于范围之内。 def g...
is大龙 2020-03-24 22:47:23 0 浏览量 回答数 1

回答

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

回答

Pandas是Python的一个大数据处理模块。Pandas使用一个二维的数据结构DataFrame来表示表格式的数据,相比较于Numpy,Pandas可以存储混合的数据结构,同时使用NaN来表示缺失的数据,而不用像Numpy一样要手工处理缺失的数据,并且Pandas使用轴标签来表示行和列。 DataFrame类: DataFrame有四个重要的属性: index:行索引。 columns:列索引。 values:值的二维数组。 name:名字。 构建方法,DataFrame(sequence),通过序列构建,序列中的每个元素是一个字典。 frame=DateFrame构建完之后,假设frame中有’name’,’age’,’addr’三个属性,可以使用fame[‘name’]查看属性列内容,也可以fame.name这样直接查看。 frame按照’属性提取出来的每个列是一个Series类。 DataFrame类可以使用布尔型索引。 groupby(str|array…)函数:可以使用frame中对应属性的str或者和frame行数相同的array作为参数还可以使用一个会返回和frame长度相同list的函数作为参数,如果使用函数做分组参数,这个用做分组的函数传入的参数将会是fame的index,参数个数任意。使用了groupby函数之后配合,size()函数就可以对groupby结果进行统计。 groupby后可以使用: size():就是count sum():分组求和 apply(func,axis=0):在分组上单独使用函数func返回frame,不groupby用在DataFrame会默认将func用在每个列上,如果axis=1表示将func用在行上。 reindex(index,column,method):用来重新命名索引,和插值。 size():会返回一个frame,这个frame是groupby后的结果。 sum(n).argsort():如果frame中的值是数字,可以使用sum函数计算frame中摸个属性,各个因子分别求和,并返回一个Series,这个Series可以做为frame.take的参数,拿到frame中对应的行。 pivot_table(操作str1,index=str2,columns=str3,aggfunc=str4)透视图函数: str1:是给函数str4作为参数的部分。 str2:是返回frame的行名。 str3:是返回frame的列名。 str4:是集合函数名,有’mean’,’sum’这些,按照str2,str3分组。 使用透视图函数之后,可以使用.sum()这类型函数,使用后会按照index和columns的分组求和。 order_index(by,ascending): 返回一个根据by排序,asceding=True表示升序,False表示降序的frame concat(list):将一个列表的frame行数加起来。 ix[index]:就是行索引,DataFrame的普通下标是列索引。 take(index):作用和ix差不多,都是查询行,但是ix传入行号,take传入行索引。 unstack():将行信息变成列信息。 apply(func,axis=0)和applymap(func):apply用在DataFrame会默认将func用在每个列上,如果axis=1表示将func用在行上。applymap表示func用在每个元素上。 combine_first(frame2):combine_first会把frame中的空值用frame1中对应位置的数据进行填充。Series方法也有相同的方法。 stack()函数,可以将DataFrame的列转化成行,原来的列索引成为行的层次索引。(stack和unstack方法是两个互逆的方法,可以用来进行Series和DataFrame之间的转换) duplicated():返回一个布尔型Series,表示各行是否重复。 drop_duplicates():返回一个移除了重复行后的DataFrame pct_change():Series也有这个函数,这个函数用来计算同colnums两个相邻的数字之间的变化率。 corr():计算相关系数矩阵。 cov():计算协方差系数矩阵。 corrwith(Series|list,axis=0):axis=0时计算frame的每列和参数的相关系数。 数据框操作 df.head(1) 读取头几条数据 df.tail(1) 读取后几条数据 df[‘date’] 获取数据框的date列 df.head(1)[‘date’] 获取第一行的date列 df.head(1)‘date’ 获取第一行的date列的元素值 sum(df[‘ability’]) 计算整个列的和 df[df[‘date’] == ‘20161111’] 获取符合这个条件的行 df[df[‘date’] == ‘20161111’].index[0] 获取符合这个条件的行的行索引的值 df.iloc[1] 获取第二行 df.iloc1 获取第二行的test2值 10 mins to pandas df.index 获取行的索引 df.index[0] 获取第一个行索引 df.index[-1] 获取最后一个行索引,只是获取索引值 df.columns 获取列标签 df[0:2] 获取第1到第2行,从0开始,不包含末端 df.loc[1] 获取第二行 df.loc[:,’test1’] 获取test1的那一列,这个冒号的意思是所有行,逗号表示行与列的区分 df.loc[:,[‘test1’,’test2’]] 获取test1列和test2列的数据 df.loc[1,[‘test1’,’test2’]] 获取第二行的test1和test2列的数据 df.at[1,’test1’] 表示取第二行,test1列的数据,和上面的方法类似 df.iloc[0] 获取第一行 df.iloc[0:2,0:2] 获取前两行前两列的数据 df.iloc[[1,2,4],[0,2]] 获取第1,2,4行中的0,2列的数据 (df[2] > 1).any() 对于Series应用any()方法来判断是否有符合条件的
世事皆空 2019-12-02 01:07:19 0 浏览量 回答数 0

问题

试图将Fuple写入Flink Kafka接收器

我正在尝试编写一个流媒体应用程序,它既可以读取也可以写入Kafka。我目前有这个,但我必须把我的元组课程串起来。 object StreamingJob { def main(args: Array[String]) { // set u...
flink小助手 2019-12-01 19:23:59 571 浏览量 回答数 1

回答

首先要做的就是研究简单的二维数据集,看看线性的SVM是如何在不同C值(类似于线性/逻辑回归中的正则化项)的数据集上工作的。 加载数据 import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sb from scipy.io import loadmat %matplotlib inline raw_data = loadmat('data/ex6data1.mat') raw_data {'X': array([[ 1.9643 , 4.5957 ], [ 2.2753 , 3.8589 ], [ 2.9781 , 4.5651 ], ..., [ 0.9044 , 3.0198 ], [ 0.76615 , 2.5899 ], [ 0.086405, 4.1045 ]]), '__globals__': [], '__header__': 'MATLAB 5.0 MAT-file, Platform: GLNXA64, Created on: Sun Nov 13 14:28:43 2011', '__version__': '1.0', 'y': array([[1], [1], [1], ..., [0], [0], [1]], dtype=uint8)} 我们将它可视化为散点图,类标签由符号表示(‘ + ‘为 positive,’ o ‘为negative)。 data = pd.DataFrame(raw_data['X'], columns=['X1', 'X2']) data['y'] = raw_data['y'] positive = data[data['y'].isin([1])] negative = data[data['y'].isin([0])] fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(positive['X1'], positive['X2'], s=50, marker='x', label='Positive') ax.scatter(negative['X1'], negative['X2'], s=50, marker='o', label='Negative') ax.legend() 注意,有一个比其他值更positive的离群值的例子。这些类仍然是线性可分的,但它是一个非常紧密的组合。我们将训练一个线性支持向量机来学习类边界。在这个练习中,我们不需要从头开始执行SVM,所以我将使用scikit- learn的内置工具。 from sklearn import svm svc = svm.LinearSVC(C=1, loss='hinge', max_iter=1000) svc LinearSVC(C=1, class_weight=None, dual=True, fit_intercept=True, intercept_scaling=1, loss='hinge', max_iter=1000, multi_class='ovr', penalty='l2', random_state=None, tol=0.0001, verbose=0) 第一次试验取值C=1,观察它怎样运行 svc.fit(data[['X1', 'X2']], data['y']) svc.score(data[['X1', 'X2']], data['y']) 0.98039215686274506 看来它错误的分类了离散值。让我们看看当C值更大时会怎样。 svc2= svm.LinearSVC(C=100, loss='hinge', max_iter=1000) svc2.fit(data[['X1','X2']], data['y']) svc2.score(data[['X1','X2']], data['y']) 1.0 这次我们得到了更好的训练集的分类。然而随着C值的增加,我们创建了一个不再适合该数据的决策边界。我们可以通过每个等级预测的置信度来可视化它,这是点与超平面的距离的函数。 data['SVM 1 Confidence'] = svc.decision_function(data[['X1', 'X2']]) fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(data['X1'], data['X2'], s=50, c=data['SVM 1 Confidence'], cmap='seismic') ax.set_title('SVM (C=1) Decision Confidence') data['SVM 1 Confidence'] = svc.decision_function(data[['X1', 'X2']]) fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(data['X1'], data['X2'], s=50, c=data['SVM 1 Confidence'], cmap='seismic') ax.set_title('SVM (C=1) Decision Confidence') data['SVM 2 Confidence'] = svc2.decision_function(data[['X1', 'X2']]) fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(data['X1'], data['X2'], s=50, c=data['SVM 2 Confidence'], cmap='seismic') ax.set_title('SVM (C=100) Decision Confidence') 边界附近点的颜色差别有点微妙。在第一个图像中,边界附近的点是强烈的红色或蓝色,表明它们在超平面的可靠范围内。在第二个图像中不是的,这样其中一些点几乎是白色的,表明它们与超平面直接相邻。 现在我们将从线性SVM转移到能够使用内核进行非线性分类的SVM。首先,我们需要实现一个高斯核函数。为了完全透明,尽管scikit- learn有一个高斯内核,我们仍然从头开始实现高斯核函数 。 def gaussian_kernel(x1, x2, sigma): return np.exp(-(np.sum((x1 - x2) ** 2) / (2 * (sigma ** 2)))) x1 = np.array([1.0, 2.0, 1.0]) x2 = np.array([0.0, 4.0, -1.0]) sigma = 2 gaussian_kernel(x1, x2, sigma) 0.32465246735834974 这个结果与预期值相匹配。接下来,我们将检查另一个非线性决策边界的数据集。 raw_data = loadmat('data/ex6data2.mat') data = pd.DataFrame(raw_data['X'], columns=['X1', 'X2']) data['y'] = raw_data['y'] positive = data[data['y'].isin([1])] negative = data[data['y'].isin([0])] fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(positive['X1'], positive['X2'], s=30, marker='x', label='Positive') ax.scatter(negative['X1'], negative['X2'], s=30, marker='o', label='Negative') ax.legend() 对于这个数据集,我们将使用内置的RBF内核构建一个支持向量机分类器,并检查它在训练数据上的准确性。为了使决策边界可视化,这次我们将基于具有负类标签的实例预测概率来遮蔽点。我们从结果中看到大部分都是正确的。 svc = svm.SVC(C=100, gamma=10, probability=True) svc.fit(data[['X1', 'X2']], data['y']) data['Probability'] = svc.predict_proba(data[['X1', 'X2']])[:,0] fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(data['X1'], data['X2'], s=30, c=data['Probability'], cmap='Reds') 对于第三个数据集,我们得到了训练和验证集,并基于验证集性能为SVM模型寻找最优超参数。尽管我们可以很容易地使用scikit- learn的内置网格搜索来实现这一点,但为了更多的练习,我们将从头开始实现一个简单的网格搜索。 raw_data = loadmat('data/ex6data3.mat') X = raw_data['X'] Xval = raw_data['Xval'] y = raw_data['y'].ravel() yval = raw_data['yval'].ravel() C_values = [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30, 100] gamma_values = [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30, 100] best_score = 0 best_params = {'C': None, 'gamma': None} for C in C_values: for gamma in gamma_values: svc = svm.SVC(C=C, gamma=gamma) svc.fit(X, y) score = svc.score(Xval, yval) if score > best_score: best_score = score best_params['C'] = C best_params['gamma'] = gamma best_score, best_params (0.96499999999999997, {'C':0.3,'gamma':100}) 现在我们继续练习的最后一部分。在这个部分,我们的目标是使用SVMs构建一个垃圾邮件过滤器。在练习文本中,有一个任务需要对一些文本进行预处理,以使获得适合SVM的数据格式,这个任务非常简单,而其他预处理步骤(例如HTML删除、词干、规范化等)都已经完成了。我不会重复这些步骤,而是跳过机器学习任务,其中包括从预处理的训练中创建分类器,以及由垃圾邮件和非垃圾邮件转换为单词发生向量的测试数据集。 svc = svm.SVC() svc.fit(X, y) print('Test accuracy = {0}%'.format(np.round(svc.score(Xtest, ytest) * 100, 2))) Test accuracy= 95.3% 这个结果与默认参数有关。我们可能会使用一些参数调优来提高它的精度,但是95%的精度仍然不差。
珍宝珠 2019-12-02 03:22:39 0 浏览量 回答数 0

问题

MaxCompute用户指南:SQL:内建函数:聚合函数

聚合函数,其输入与输出是多对一的关系,即将多条输入记录聚合成一条输出值。可以与SQL 中的 group by 语句联用。 COUNT 函数声明: bigint count([distin...
行者武松 2019-12-01 22:03:00 1503 浏览量 回答数 0

问题

sparkstreaming mapWithState状态保存问题

sparkstreaming mapWithState状态保存问题,我们该如何保证sparkstreaming在任务重启后可以保证我们的可以从checkpoint中读取到之前的状态,我发现我做不到。期望得到帮助。下面是代码 package ...
引领时尚s 2019-12-01 19:32:33 1034 浏览量 回答数 1

问题

MaxCompute用户指南:SQL:UDF:Java UDF

MaxCompute 的 UDF 包括:UDF,UDAF 和 UDTF 三种函数,本文将重点介绍如何通过 Java 实现这三种函数。 参数与返回值类型 MaxCompute2.0 版本升级后...
行者武松 2019-12-01 22:03:02 1529 浏览量 回答数 0

回答

逻辑回归 逻辑回归实际上是一种分类算法。我怀疑它这样命名是因为它与线性回归在学习方法上很相似,但是成本和梯度函数表述不同。特别是,逻辑回归使用了一个sigmoid或“logit”激活函数,而不是线性回归的连续输出。 首先导入和检查我们将要处理的数据集。 import numpy as np import pandas as pd import matplotlib.pyplot as plt %matplotlib inline import os path = os.getcwd() + '\data\ex2data1.txt' data = pd.read_csv(path, header=None, names=['Exam 1', 'Exam 2', 'Admitted']) data.head() 在数据中有两个连续的自变量——“Exam 1”和“Exam 2”。我们的预测目标是“Admitted”的标签。值1表示学生被录取,0表示学生没有被录取。我们看有两科成绩的散点图,并使用颜色编码来表达例子是positive或者negative。 positive = data[data['Admitted'].isin([1])] negative = data[data['Admitted'].isin([0])] fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted') ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted') ax.legend() ax.set_xlabel('Exam 1 Score') ax.set_ylabel('Exam 2 Score') 从这个图中我们可以看到,有一个近似线性的决策边界。它有一点弯曲,所以我们不能使用直线将所有的例子正确地分类,但我们能够很接近。现在我们需要实施逻辑回归,这样我们就可以训练一个模型来找到最优决策边界,并做出分类预测。首先需要实现sigmoid函数。 def sigmoid(z): return 1 / (1 + np.exp(-z)) 这个函数是逻辑回归输出的“激活”函数。它将连续输入转换为0到1之间的值。这个值可以被解释为分类概率,或者输入的例子应该被积极分类的可能性。利用带有界限值的概率,我们可以得到一个离散标签预测。它有助于可视化函数的输出,以了解它真正在做什么。 nums = np.arange(-10, 10, step=1) fig, ax = plt.subplots(figsize=(12,8)) ax.plot(nums, sigmoid(nums), 'r') 我们的下一步是写成本函数。成本函数在给定一组模型参数的训练数据上评估模型的性能。这是逻辑回归的成本函数。 def cost(theta, X, y): theta = np.matrix(theta) X = np.matrix(X) y = np.matrix(y) first = np.multiply(-y, np.log(sigmoid(X * theta.T))) second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T))) return np.sum(first - second) / (len(X)) 注意,我们将输出减少到单个标量值,该值是“误差”之和,是模型分配的类概率与示例的真实标签之间差别的量化函数。该实现完全是向量化的——它在语句(sigmoid(X * theta.T))中计算模型对整个数据集的预测。 测试成本函数以确保它在运行,首先需要做一些设置。 # add a ones column - this makes the matrix multiplication work out easier data.insert(0, 'Ones', 1) # set X (training data) and y (target variable) cols = data.shape[1] X = data.iloc[:,0:cols-1] y = data.iloc[:,cols-1:cols] # convert to numpy arrays and initalize the parameter array theta X = np.array(X.values) y = np.array(y.values) theta = np.zeros(3) 检查数据结构的形状,以确保它们的值是合理的。这种技术在实现矩阵乘法时非常有用 X.shape, theta.shape, y.shape ((100L, 3L), (3L,), (100L, 1L)) 现在计算初始解的成本,将模型参数“theta”设置为零。 cost(theta, X, y) 0.69314718055994529 我们已经有了工作成本函数,下一步是编写一个函数,用来计算模型参数的梯度,以找出改变参数来提高训练数据模型的方法。在梯度下降的情况下,我们不只是在参数值周围随机地jigger,看看什么效果最好。并且在每次迭代训练中,我们通过保证将其移动到减少训练误差(即“成本”)的方向来更新参数。我们可以这样做是因为成本函数是可微分的。这是函数。 def gradient(theta, X, y): theta = np.matrix(theta) X = np.matrix(X) y = np.matrix(y) parameters = int(theta.ravel().shape[1]) grad = np.zeros(parameters) error = sigmoid(X * theta.T) - y for i in range(parameters): term = np.multiply(error, X[:,i]) grad[i] = np.sum(term) / len(X) return grad 我们并没有在这个函数中执行梯度下降——我们只计算一个梯度步骤。在练习中,使用“fminunc”的Octave函数优化给定函数的参数,以计算成本和梯度。因为我们使用的是Python,所以我们可以使用SciPy的优化API来做同样的事情。 import scipy.optimize as opt result = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y)) cost(result[0], X, y) 0.20357134412164668 现在我们的数据集里有了最优模型参数,接下来我们要写一个函数,它使用我们训练过的参数theta来输出数据集X的预测,然后使用这个函数为我们分类器的训练精度打分。 def predict(theta, X): probability = sigmoid(X * theta.T) return [1 if x >= 0.5 else 0 for x in probability] theta_min = np.matrix(result[0]) predictions = predict(theta_min, X) correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)] accuracy = (sum(map(int, correct)) % len(correct)) print 'accuracy = {0}%'.format(accuracy) accuracy = 89% 我们的逻辑回归分类器预测学生是否被录取的准确性可以达到89%,这是在训练集中的精度。我们没有保留一个hold-out set或使用交叉验证来获得准确的近似值,所以这个数字可能高于实际的值。 正则化逻辑回归 既然我们已经有了逻辑回归的工作实现,我们将通过添加正则化来改善算法。正则化是成本函数的一个条件,使算法倾向于更简单的模型(在这种情况下,模型会减小系数),原理就是帮助减少过度拟合和帮助模型提高通用化能力。我们使用逻辑回归的正则化版本去解决稍带挑战性的问题, 想象你是工厂的产品经理,你有一些芯片在两种不同测试上的测试结果。通过两种测试,你将会决定那种芯片被接受或者拒绝。为了帮助你做这个决定,你将会有以往芯片的测试结果数据集,并且通过它建立一个逻辑回归模型。 现在可视化数据。 path = os.getcwd() + '\data\ex2data2.txt' data2 = pd.read_csv(path, header=None, names=['Test 1', 'Test 2', 'Accepted']) positive = data2[data2['Accepted'].isin([1])] negative = data2[data2['Accepted'].isin([0])] fig, ax = plt.subplots(figsize=(12,8)) ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted') ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected') ax.legend() ax.set_xlabel('Test 1 Score') ax.set_ylabel('Test 2 Score') 这个数据看起来比以前的例子更复杂,你会注意到没有线性决策线,数据也执行的很好,处理这个问题的一种方法是使用像逻辑回归这样的线性技术,就是构造出由原始特征多项式派生出来的特征。我们可以尝试创建一堆多项式特性以提供给分类器。 degree = 5 x1 = data2['Test 1'] x2 = data2['Test 2'] data2.insert(3, 'Ones', 1) for i in range(1, degree): for j in range(0, i): data2['F' + str(i) + str(j)] = np.power(x1, i-j) * np.power(x2, j) data2.drop('Test 1', axis=1, inplace=True) data2.drop('Test 2', axis=1, inplace=True) data2.head() 现在我们需要去修改成本和梯度函数以包含正则项。在这种情况下,将正则化矩阵添加到之前的计算中。这是更新后的成本函数。 def costReg(theta, X, y, learningRate): theta = np.matrix(theta) X = np.matrix(X) y = np.matrix(y) first = np.multiply(-y, np.log(sigmoid(X * theta.T))) second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T))) reg = (learningRate / 2 * len(X)) * np.sum(np.power(theta[:,1:theta.shape[1]], 2)) return np.sum(first - second) / (len(X)) + reg 我们添加了一个名为“reg”的新变量,它是参数值的函数。随着参数越来越大,对成本函数的惩罚也越来越大。我们在函数中添加了一个新的“learning rate”参数。 这也是等式中正则项的一部分。 learning rate为我们提供了一个新的超参数,我们可以使用它来调整正则化在成本函数中的权重。 接下来,我们将在梯度函数中添加正则化。 def gradientReg(theta, X, y, learningRate): theta = np.matrix(theta) X = np.matrix(X) y = np.matrix(y) parameters = int(theta.ravel().shape[1]) grad = np.zeros(parameters) error = sigmoid(X * theta.T) - y for i in range(parameters): term = np.multiply(error, X[:,i]) if (i == 0): grad[i] = np.sum(term) / len(X) else: grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i]) return grad 与成本函数一样,将正则项加到最初的计算中。与成本函数不同的是,我们包含了确保第一个参数不被正则化的逻辑。这个决定背后的直觉是,第一个参数被认为是模型的“bias”或“intercept”,不应该被惩罚。 我们像以前那样测试新函数 # set X and y (remember from above that we moved the label to column 0) cols = data2.shape[1] X2 = data2.iloc[:,1:cols] y2 = data2.iloc[:,0:1] # convert to numpy arrays and initalize the parameter array theta X2 = np.array(X2.values) y2 = np.array(y2.values) theta2 = np.zeros(11) learningRate = 1 costReg(theta2, X2, y2, learningRate) 0.6931471805599454 我们能使用先前的最优代码寻找最优模型参数。 result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate)) result2 (数组([ 0.35872309, -3.22200653, 18.97106363, -4.25297831, 18.23053189, 20.36386672, 8.94114455, -43.77439015, -17.93440473, -50.75071857, -2.84162964]), 110, 1) 最后,我们可以使用前面应用的相同方法,为训练数据创建标签预测,并评估模型的性能。 theta_min = np.matrix(result2[0]) predictions = predict(theta_min, X2) correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y2)] accuracy = (sum(map(int, correct)) % len(correct)) print 'accuracy = {0}%'.format(accuracy) 准确度 = 91%
珍宝珠 2019-12-02 03:22:33 0 浏览量 回答数 0

回答

首先让我们看一下数据 path = os.getcwd() + '\data\ex1data2.txt' data2 = pd.read_csv(path, header=None, names=['Size', 'Bedrooms', 'Price']) data2.head() Size Bedrooms Price 0 2104 3 399900 1 1600 3 329900 2 2400 3 369000 3 1416 2 232000 4 3000 4 539900 每个变量值的大小都是不同的,一个房子大约有2-5个卧室,可能每个房间的大小都不一样,如果我们在这个数据集上运行原来的回归算法,那么“size”影响的权重就太大了,就会降低“number of bedrooms”的影响,为了解决这个问题,我们需要做一些所谓的“特征标准化”。也就是需要调整特征的比例来平衡竞争关系。一种方法是用特征的均值减去另一个特征的均值,然后除以标准差。这是使用的pandas的代码。 data2= (data2- data2.mean())/ data2.std() data2.head() 接下来我们需要修改练习一中的线性回归的实现,以处理多个因变量。下面是梯度下降函数的代码。 def gradientDescent(X, y, theta, alpha, iters): temp = np.matrix(np.zeros(theta.shape)) parameters = int(theta.ravel().shape[1]) cost = np.zeros(iters) for i in range(iters): error = (X * theta.T) - y for j in range(parameters): term = np.multiply(error, X[:,j]) temp[0,j] = theta[0,j] - ((alpha / len(X)) * np.sum(term)) theta = temp cost[i] = computeCost(X, y, theta) return theta, cost 仔细观察计算误差项的代码行error = (X * theta.T) – y,我们会在矩阵运算中一直使用它。这是线性代数在工作中的力量:不管X中有多少变量(列),只要参数的个数是一致的,这个代码就能正常工作。类似地,只要y中的行数允许,它将计算X中每行的错误项。这是一种将ANY表达式一次性应用于大量实例的有效方法。 由于我们的梯度下降和成本函数都使用矩阵运算,所以处理多元线性回归所需的代码实际上没有变化。我们来测试一下,首先通过初始化创建适当的矩阵来传递函数。 # add ones column data2.insert(0, 'Ones', 1) # set X (training data) and y (target variable) cols = data2.shape[1] X2 = data2.iloc[:,0:cols-1] y2 = data2.iloc[:,cols-1:cols] # convert to matrices and initialize theta X2 = np.matrix(X2.values) y2 = np.matrix(y2.values) theta2 = np.matrix(np.array([0,0,0])) 现在运行,看会发生什么 # perform linear regression on the data set g2, cost2 = gradientDescent(X2, y2, theta2, alpha, iters) # get the cost (error) of the model computeCost(X2, y2, g2) 0.13070336960771897 我们可以绘制训练过程,确认实际误差随着每次迭代梯度下降而减少。 fig, ax = plt.subplots(figsize=(12,8)) ax.plot(np.arange(iters), cost2, 'r') ax.set_xlabel('Iterations') ax.set_ylabel('Cost') ax.set_title('Error vs. Training Epoch') 解决方案的成本或误差随着每个成功的迭代而下降,直到它触底。这正是我们希望发生的事情。我们的算法起作用了。 Python的伟大之处在于它的庞大的开发者社区和丰富的开源软件。在机器学习领域,顶级Python库是scikit-learn。让我们看看如何使用scikit- learn的线性回归类来处理第一部分的简单线性回归任务。 from sklearn import linear_model model = linear_model.LinearRegression() model.fit(X, y) 没有比这更简单的了。“fit”方法有很多参数,我们可以根据我们想要的算法来调整参数,默认值可以感测到遗留下来的问题。试着绘制拟合参数,和之前的结果比较。 x = np.array(X[:, 1].A1) f = model.predict(X).flatten() fig, ax = plt.subplots(figsize=(12,8)) ax.plot(x, f, 'r', label='Prediction') ax.scatter(data.Population, data.Profit, label='Traning Data') ax.legend(loc=2) ax.set_xlabel('Population') ax.set_ylabel('Profit') ax.set_title('Predicted Profit vs. Population Size') 可参考:https://www.johnwittenauer.net/machine-learning-exercises-in-python-part-2/)
珍宝珠 2019-12-02 03:22:32 0 浏览量 回答数 0

回答

1.   【初级】下面属于关键字的是() A. func B. def C. struct D. class 参考答案:AC   2.   【初级】定义一个包内全局字符串变量,下面语法正确的是() A. var str string B. str := "" C. str = "" D. var str = "" 参考答案:AD   3.   【初级】通过指针变量 p 访问其成员变量 name,下面语法正确的是() A. p.name B. (*p).name C. (&p).name D. p->name 参考答案:AB   4.   【初级】关于接口和类的说法,下面说法正确的是() A. 一个类只需要实现了接口要求的所有函数,我们就说这个类实现了该接口 B. 实现类的时候,只需要关心自己应该提供哪些方法,不用再纠结接口需要拆得多细才合理 C. 类实现接口时,需要导入接口所在的包 D. 接口由使用方按自身需求来定义,使用方无需关心是否有其他模块定义过类似的接口 参考答案:ABD   5.   【初级】关于字符串连接,下面语法正确的是() A. str := ‘abc’ + ‘123’ B. str := "abc" + "123" C. str := '123' + "abc" D. fmt.Sprintf("abc%d", 123) 参考答案:BD   6.   【初级】关于协程,下面说法正确是() A. 协程和线程都可以实现程序的并发执行 B. 线程比协程更轻量级 C. 协程不存在死锁问题 D. 通过channel来进行协程间的通信 参考答案:AD   7.   【中级】关于init函数,下面说法正确的是() A. 一个包中,可以包含多个init函数 B. 程序编译时,先执行导入包的init函数,再执行本包内的init函数 C. main包中,不能有init函数 D. init函数可以被其他函数调用 参考答案:AB   8.   【初级】关于循环语句,下面说法正确的有() A. 循环语句既支持for关键字,也支持while和do-while B. 关键字for的基本使用方法与C/C++中没有任何差异 C. for循环支持continue和break来控制循环,但是它提供了一个更高级的break,可以选择中断哪一个循环 D. for循环不支持以逗号为间隔的多个赋值语句,必须使用平行赋值的方式来初始化多个变量  参考答案:CD   9.   【中级】对于函数定义: func add(args ...int) int {  sum :=0  for _,arg := range args {     sum += arg  }  returnsum } 下面对add函数调用正确的是() A. add(1, 2) B. add(1, 3, 7) C. add([]int{1, 2}) D. add([]int{1, 3, 7}...) 参考答案:ABD   【初级】关于类型转化,下面语法正确的是() A. type MyInt int var i int = 1 var jMyInt = i B. type MyIntint var i int= 1 var jMyInt = (MyInt)i C. type MyIntint var i int= 1 var jMyInt = MyInt(i) D. type MyIntint var i int= 1 var jMyInt = i.(MyInt) 参考答案:C   【初级】关于局部变量的初始化,下面正确的使用方式是() A. var i int = 10 B. var i = 10 C. i := 10 D. i = 10 参考答案:ABC   【初级】关于const常量定义,下面正确的使用方式是() A. const Pi float64 = 3.14159265358979323846 const zero= 0.0 B. const ( size int64= 1024 eof = -1 ) C. const ( ERR_ELEM_EXISTerror = errors.New("element already exists") ERR_ELEM_NT_EXISTerror = errors.New("element not exists") ) D. const u, vfloat32 = 0, 3 const a,b, c = 3, 4, "foo" 参考答案:ABD   【初级】关于布尔变量b的赋值,下面错误的用法是() A. b = true B. b = 1 C. b = bool(1) D. b = (1 == 2) 参考答案:BC   【中级】下面的程序的运行结果是() func main() {   if (true) {    defer fmt.Printf("1") } else {    defer fmt.Printf("2") } fmt.Printf("3") } A. 321 B. 32 C. 31 D. 13 参考答案:C   【初级】关于switch语句,下面说法正确的有() A. 条件表达式必须为常量或者整数 B. 单个case中,可以出现多个结果选项 C. 需要用break来明确退出一个case D. 只有在case中明确添加fallthrough关键字,才会继续执行紧跟的下一个case 参考答案:BD   【中级】 golang中没有隐藏的this指针,这句话的含义是() A. 方法施加的对象显式传递,没有被隐藏起来 B. golang沿袭了传统面向对象编程中的诸多概念,比如继承、虚函数和构造函数 C. golang的面向对象表达更直观,对于面向过程只是换了一种语法形式来表达 D. 方法施加的对象不需要非得是指针,也不用非得叫this 参考答案:ACD   【中级】 golang中的引用类型包括() A. 数组切片 B. map C. channel D. interface 参考答案:ABCD   【中级】 golang中的指针运算包括() A. 可以对指针进行自增或自减运算 B. 可以通过“&”取指针的地址 C. 可以通过“*”取指针指向的数据 D. 可以对指针进行下标运算 参考答案:BC   【初级】关于main函数(可执行程序的执行起点),下面说法正确的是() A. main函数不能带参数 B. main函数不能定义返回值 C. main函数所在的包必须为main包 D. main函数中可以使用flag包来获取和解析命令行参数 参考答案:ABCD   【中级】下面赋值正确的是() A. var x = nil B. var x interface{} = nil C. var x string = nil D. var x error = nil 参考答案:BD   【中级】关于整型切片的初始化,下面正确的是() A. s := make([]int) B. s := make([]int, 0) C. s := make([]int, 5, 10) D. s := []int{1, 2, 3, 4, 5} 参考答案:BCD   【中级】从切片中删除一个元素,下面的算法实现正确的是() A. func (s *Slice)Remove(value interface{})error { for i, v := range *s {    if isEqual(value, v) {        if i== len(*s) - 1 {            *s = (*s)[:i]        }else {            *s = append((*s)[:i],(*s)[i + 2:]...)        }        return nil    } } return ERR_ELEM_NT_EXIST } B. func (s*Slice)Remove(value interface{}) error { for i, v:= range *s {     if isEqual(value, v) {         *s =append((*s)[:i],(*s)[i + 1:])         return nil     } } returnERR_ELEM_NT_EXIST } C. func (s*Slice)Remove(value interface{}) error { for i, v:= range *s {     if isEqual(value, v) {         delete(*s, v)         return nil     } } returnERR_ELEM_NT_EXIST } D. func (s*Slice)Remove(value interface{}) error { for i, v:= range *s {     if isEqual(value, v) {         *s =append((*s)[:i],(*s)[i + 1:]...)         return nil     } } returnERR_ELEM_NT_EXIST } 参考答案:D   【初级】对于局部变量整型切片x的赋值,下面定义正确的是() A. x := []int{ 1, 2, 3, 4, 5, 6, } B. x :=[]int{ 1, 2, 3, 4, 5, 6 } C. x :=[]int{ 1, 2, 3, 4, 5, 6} D. x :=[]int{1, 2, 3, 4, 5, 6,} 参考答案:ACD   【初级】关于变量的自增和自减操作,下面语句正确的是() A. i := 1 i++ B. i := 1 j = i++ C. i := 1 ++i D. i := 1 i-- 参考答案:AD   【中级】关于函数声明,下面语法错误的是() A. func f(a, b int) (value int, err error) B. func f(a int, b int) (value int, err error) C. func f(a, b int) (value int, error) D. func f(a int, b int) (int, int, error) 参考答案:C   【中级】如果Add函数的调用代码为: func main() { var a Integer = 1 var b Integer = 2 var i interface{} = &a sum := i.(*Integer).Add(b) fmt.Println(sum) } 则Add函数定义正确的是() A. typeInteger int func (aInteger) Add(b Integer) Integer {  return a + b } B. typeInteger int func (aInteger) Add(b *Integer) Integer {  return a + *b } C. typeInteger int func (a*Integer) Add(b Integer) Integer {  return *a + b } D. typeInteger int func (a*Integer) Add(b *Integer) Integer {  return *a + *b } 参考答案:AC   【中级】如果Add函数的调用代码为: func main() { var a Integer = 1 var b Integer = 2 var i interface{} = a sum := i.(Integer).Add(b) fmt.Println(sum) } 则Add函数定义正确的是() A. typeInteger int func (a Integer)Add(b Integer) Integer {  return a + b } B. typeInteger int func (aInteger) Add(b *Integer) Integer {  return a + *b } C. typeInteger int func (a*Integer) Add(b Integer) Integer {  return *a + b } D. typeInteger int func (a*Integer) Add(b *Integer) Integer {  return *a + *b } 参考答案:A   【中级】关于GetPodAction定义,下面赋值正确的是() type Fragment interface { Exec(transInfo *TransInfo) error } type GetPodAction struct { } func (g GetPodAction) Exec(transInfo*TransInfo) error { ... return nil } A. var fragment Fragment =new(GetPodAction) B. var fragment Fragment = GetPodAction C. var fragment Fragment = &GetPodAction{} D. var fragment Fragment = GetPodAction{} 参考答案:ACD   【中级】关于GoMock,下面说法正确的是() A. GoMock可以对interface打桩 B. GoMock可以对类的成员函数打桩 C. GoMock可以对函数打桩 D. GoMock打桩后的依赖注入可以通过GoStub完成 参考答案:AD   【中级】关于接口,下面说法正确的是() A. 只要两个接口拥有相同的方法列表(次序不同不要紧),那么它们就是等价的,可以相互赋值 B. 如果接口A的方法列表是接口B的方法列表的子集,那么接口B可以赋值给接口A C. 接口查询是否成功,要在运行期才能够确定 D. 接口赋值是否可行,要在运行期才能够确定 参考答案:ABC   【初级】关于channel,下面语法正确的是() A. var ch chan int B. ch := make(chan int) C. <- ch D. ch <- 参考答案:ABC   【初级】关于同步锁,下面说法正确的是() A. 当一个goroutine获得了Mutex后,其他goroutine就只能乖乖的等待,除非该goroutine释放这个Mutex B. RWMutex在读锁占用的情况下,会阻止写,但不阻止读 C. RWMutex在写锁占用情况下,会阻止任何其他goroutine(无论读和写)进来,整个锁相当于由该goroutine独占 D. Lock()操作需要保证有Unlock()或RUnlock()调用与之对应 参考答案:ABC   【中级】 golang中大多数数据类型都可以转化为有效的JSON文本,下面几种类型除外() A. 指针 B. channel C. complex D. 函数 参考答案:BCD   【中级】关于go vendor,下面说法正确的是() A. 基本思路是将引用的外部包的源代码放在当前工程的vendor目录下面 B. 编译go代码会优先从vendor目录先寻找依赖包 C. 可以指定引用某个特定版本的外部包 D. 有了vendor目录后,打包当前的工程代码到其他机器的$GOPATH/src下都可以通过编译 参考答案:ABD   【初级】 flag是bool型变量,下面if表达式符合编码规范的是() A. if flag == 1 B. if flag C. if flag == false D. if !flag 参考答案:BD   【初级】 value是整型变量,下面if表达式符合编码规范的是() A. if value == 0 B. if value C. if value != 0 D. if !value 参考答案:AC   【中级】关于函数返回值的错误设计,下面说法正确的是() A. 如果失败原因只有一个,则返回bool B. 如果失败原因超过一个,则返回error C. 如果没有失败原因,则不返回bool或error D. 如果重试几次可以避免失败,则不要立即返回bool或error 参考答案:ABCD   【中级】关于异常设计,下面说法正确的是() A. 在程序开发阶段,坚持速错,让程序异常崩溃 B. 在程序部署后,应恢复异常避免程序终止 C. 一切皆错误,不用进行异常设计 D. 对于不应该出现的分支,使用异常处理 参考答案:ABD   【中级】关于slice或map操作,下面正确的是() A. var s []int s =append(s,1) B. var mmap[string]int m["one"]= 1 C. var s[]int s =make([]int, 0) s =append(s,1) D. var mmap[string]int m =make(map[string]int) m["one"]= 1 参考答案:ACD   【中级】关于channel的特性,下面说法正确的是() A. 给一个 nil channel 发送数据,造成永远阻塞 B. 从一个 nil channel 接收数据,造成永远阻塞 C. 给一个已经关闭的 channel 发送数据,引起 panic D. 从一个已经关闭的 channel 接收数据,如果缓冲区中为空,则返回一个零值 参考答案:ABCD   【中级】关于无缓冲和有冲突的channel,下面说法正确的是() A. 无缓冲的channel是默认的缓冲为1的channel B. 无缓冲的channel和有缓冲的channel都是同步的 C. 无缓冲的channel和有缓冲的channel都是非同步的 D. 无缓冲的channel是同步的,而有缓冲的channel是非同步的 参考答案:D   【中级】关于异常的触发,下面说法正确的是() A. 空指针解析 B. 下标越界 C. 除数为0 D. 调用panic函数 参考答案:ABCD   【中级】关于cap函数的适用类型,下面说法正确的是() A. array B. slice C. map D. channel 参考答案:ABD   【中级】关于beego框架,下面说法正确的是() A. beego是一个golang实现的轻量级HTTP框架 B. beego可以通过注释路由、正则路由等多种方式完成url路由注入 C. 可以使用bee new工具生成空工程,然后使用bee run命令自动热编译 D. beego框架只提供了对url路由的处理,而对于MVC架构中的数据库部分未提供框架支持 参考答案:ABC   【中级】关于goconvey,下面说法正确的是() A. goconvey是一个支持golang的单元测试框架 B. goconvey能够自动监控文件修改并启动测试,并可以将测试结果实时输出到web界面 C. goconvey提供了丰富的断言简化测试用例的编写 D. goconvey无法与go test集成 参考答案:ABC   【中级】关于go vet,下面说法正确的是() A. go vet是golang自带工具go tool vet的封装 B. 当执行go vet database时,可以对database所在目录下的所有子文件夹进行递归检测 C. go vet可以使用绝对路径、相对路径或相对GOPATH的路径指定待检测的包 D. go vet可以检测出死代码 参考答案:ACD   100.             【中级】关于map,下面说法正确的是() A. map反序列化时json.unmarshal的入参必须为map的地址 B. 在函数调用中传递map,则子函数中对map元素的增加不会导致父函数中map的修改 C. 在函数调用中传递map,则子函数中对map元素的修改不会导致父函数中map的修改 D. 不能使用内置函数delete删除map的元素 参考答案:A 101.             【中级】关于GoStub,下面说法正确的是() A. GoStub可以对全局变量打桩 B. GoStub可以对函数打桩 C. GoStub可以对类的成员方法打桩 D. GoStub可以打动态桩,比如对一个函数打桩后,多次调用该函数会有不同的行为 参考答案:ABD   102.             【初级】关于select机制,下面说法正确的是() A. select机制用来处理异步IO问题 B. select机制最大的一条限制就是每个case语句里必须是一个IO操作 C. golang在语言级别支持select关键字 D. select关键字的用法与switch语句非常类似,后面要带判断条件 参考答案:ABC   103.             【初级】关于内存泄露,下面说法正确的是() A. golang有自动垃圾回收,不存在内存泄露 B. golang中检测内存泄露主要依靠的是pprof包 C. 内存泄露可以在编译阶段发现 D. 应定期使用浏览器来查看系统的实时内存信息,及时发现内存泄露问题 参考答案:BD   ———————————————— 原文链接:https://blog.csdn.net/itcastcpp/article/details/80462619 ————————————————
剑曼红尘 2020-03-09 10:46:25 0 浏览量 回答数 0

回答

数据采集链接 检查数据 首先检查“ex1data1”文件中的数据。“txt”在“我的存储库”的“数据”目录中。首先导入一些库。 import os import numpy as np import pandas as pd import matplotlib.pyplot as plt %matplotlib inline 现在开始运行,使用Pandas把数据加载到数据帧里,并且使用“head”函数显示前几行。 path= os.getcwd()+ '\data\ex1data1.txt' data= pd.read_csv(path, header=None, names=['Population','Profit']) data.head() Population Profit 0 6.1101 17.5920 1 5.5277 9.1302 2 8.5186 13.6620 3 7.0032 11.8540 4 5.8598 6.8233 Pandas提供的另外一个有用的函数是”describe”函数,它能在数据集上计算一些基本统计数据,这有助于在项目的探索性分析阶段获得数据的“feel”。 data.describe() Population Profit count 97.000000 97.000000 mean 8.159800 5.839135 std 3.869884 5.510262 min 5.026900 -2.680700 25% 5.707700 1.986900 50% 6.589400 4.562300 75% 8.578100 7.046700 max 22.203000 24.147000 检查有相关的统计数据可能会有帮助,但有时需要找到方法使它可视化。这个数据集只有一个因变量,我们可以把它放到散点图中以便更好地了解它。我们可以使用pandas为它提供的“plot”函数,这实际上只是matplotlib的一个包装器。 data.plot(kind='scatter', x='Population', y='Profit', figsize=(12,8)) 我们可以清楚地看到,随着城市规模的增加,利润呈线性增长。现在让我们进入有趣的部分——从零开始实现python中的线性回归算法。 实现简单的线性回归 线性回归是建立因变量和一个或多个自变量之间关系的一种方法(如果只有一个自变量就是简单线性回归;如果是多个自变量就是多重线性回归)。我们试图使用参数theta创建数据X的线性模型,它描述了数据的方差,给出新的数据点,我们可以在不知道实际结果的情况下准确地预测。 在实现过程中,我们使用叫做梯度下降的优化技术寻找参数theta。如果你熟悉线性回归,你可能会意识到有另一种方法可以找到线性模型的最优参数,就是做“正态方程”,它可以用一系列矩阵运算来解决这个问题。然而,这种方法的问题就是在大数据集中不能很好地扩展,相比之下,我们可以使用梯度下降和其他优化方法的变体来扩展到无限大小的数据集,因此对于机器学习问题,梯度下降更实用。 理论知识已经足够了,下面我们写一些代码。我们首先要写的就是成本函数,成本函数通过计算模型参数和实际数据点之间的误差来计算模型预测的误差,从而评估模型的质量。例如,如果给定城市的人口数量是4,但是我们预测是7,我们的误差就是 (7-4)^2 = 3^2 = 9(假设为L2或“最小二乘法”损失函数)。我们为X中的每个数据点执行此操作,并对结果求和以获取成本。下面是函数: def computeCost(X, y, theta): inner= np.power(((X* theta.T)- y),2) return np.sum(inner)/ (2 * len(X)) 注意,这里没有循环。我们利用numpy的linear algrebra功能将结果计算为一系列矩阵运算。这比不优化的“for”循环的效率要高得多。 为了使这个成本函数与我们上面创建的pandas数据框架无缝对接,我们需要做一些操作。首先,在开始插入一列1s的数据帧使矩阵运算正常工作。然后把数据分离成自变量X和因变量y。 # append a ones column to the front of the data set data.insert(0,'Ones',1) # set X (training data) and y (target variable) cols= data.shape[1] X= data.iloc[:,0:cols-1] y= data.iloc[:,cols-1:cols] 最后把数据框架转换为numpy矩阵并实例化参数matirx。 # convert from data frames to numpy matrices X= np.matrix(X.values) y= np.matrix(y.values) theta= np.matrix(np.array([0,0])) 在调试矩阵运算时要查看正在处理的矩阵的形状。矩阵乘法看起来像(i x j)*(j x k)=(i x k),其中i、j和k是矩阵相对维度的形状。 X.shape, theta.shape, y.shape ((97L, 2L), (1L, 2L), (97L, 1L)) 调试一下成本函数。参数已经被初始化为0,所以解不是最优的,但是我们可以看看它是否有效。 computeCost(X, y, theta) 32.072733877455676 目前为止一切都很顺利。现在我们需要使用练习文本中定义的更新规则来定义一个函数,来对参数theta执行梯度下降。这是梯度下降的函数: def gradientDescent(X, y, theta, alpha, iters): temp= np.matrix(np.zeros(theta.shape)) parameters= int(theta.ravel().shape[1]) cost= np.zeros(iters) for iin range(iters): error= (X* theta.T)- y for jin range(parameters): term= np.multiply(error, X[:,j]) temp[0,j]= theta[0,j]- ((alpha/ len(X))* np.sum(term)) theta= temp cost[i]= computeCost(X, y, theta) return theta, cost 梯度下降的就是计算出每一个迭代的误差项的梯度,以找出适当的方向来移动参数向量。换句话说,就是计算对参数的修改以减少错误,从而使我们的解决方案更接近最佳解决方案。 我们再一次依赖于numpy和线性代数求解,你可能注意到我的实现不是100%的优化,事实上,有完全去除内循环和一次性更新所有参数的方法。我把它留给读者去完成。 现在我们已经有了一种评估解决方案的方法,并且找到一个好的解决方案,把它应用到我们的数据集中。 # initialize variables for learning rate and iterations alpha= 0.01 iters= 1000 # perform gradient descent to "fit" the model parameters g, cost= gradientDescent(X, y, theta, alpha, iters) g 矩阵x([[-3.24140214, 1.1272942 ]]) 注意我们已经初始化了一些新的变量。梯度下降函数中有叫做alpha和iters的参数。alpha是学习速率-它是参数更新规则中的一个因素,它帮助决定算法收敛到最优解的速度。iters是迭代次数。没有严格的规则去规定如何初始化这些参数,但是通常会涉及到试错法。 现在有一个参数向量描述数据集的最优线性模型,一个快速评估回归模型的方法就是观察数据集上的解决方案的总误差: computeCost(X, y, g) 4.5159555030789118 这要比32好很多。 查看结果 我们将使用matplotlib来可视化我们的解决方案。我们在数据的散点图上覆盖一条线表示我们的模型,看它是否合适。我们使用numpy的“linspace”函数在我们的数据范围内创建一系列均匀间隔的点,然后用我们的模型“评估”这些点,看预期的利润会是多少。我们把它变成线形图。 x= np.linspace(data.Population.min(), data.Population.max(),100) f= g[0,0]+ (g[0,1]* x) fig, ax= plt.subplots(figsize=(12,8)) ax.plot(x, f,'r', label='Prediction') ax.scatter(data.Population, data.Profit, label='Traning Data') ax.legend(loc=2) ax.set_xlabel('Population') ax.set_ylabel('Profit') ax.set_title('Predicted Profit vs. Population Size') 我们的解决方案看起来是数据集的最优线性模型。梯度体系函数会在每个训练迭代中输出一个成本向量,我们可以出绘制出线形图。 fig, ax = plt.subplots(figsize=(12,8)) ax.plot(np.arange(iters), cost, 'r') ax.set_xlabel('Iterations') ax.set_ylabel('Cost') ax.set_title('Error vs. Training Epoch') 成本一直在降低——这就是凸优化问题的一个示例。如果你要绘制问题的整个解决方案空间,它看起来会像一个碗的形状,“盆地”表示最优解。
珍宝珠 2019-12-02 03:22:32 0 浏览量 回答数 0

问题

Windows上的linux上的分段错误

该程序的目标是扫描由数字和空格填充的字符串,并将每个数字插入数组。然后,将数组中的每个数字发送到checkPowerOfTwo函数,该函数确定所发送的数字是否为2的幂并打印计算结果。 当我在Win...
祖安文状元 2020-01-08 15:23:40 3 浏览量 回答数 1

问题

MaxCompute百问集锦(持续更新20171011)

大数据计算服务(MaxCompute,原名 ODPS)是一种快速、完全托管的 GB/TB/PB 级数据仓库解决方案。MaxCompute 向用户提供了完善的数据导入方案以及多种经典的分布式计算模型,能够更快速的解决用户海量数据计算问题,有效...
隐林 2019-12-01 20:19:23 38430 浏览量 回答数 18

云产品推荐

上海奇点人才服务相关的云产品 小程序定制 上海微企信息技术相关的云产品 国内短信套餐包 ECS云服务器安全配置相关的云产品 开发者问答 阿里云建站 自然场景识别相关的云产品 万网 小程序开发制作 视频内容分析 视频集锦 代理记账服务 阿里云AIoT