小编Jas*_*son的帖子

我正在学习支持向量机并试图想出一个简单的线性分类的简单python实现(我知道sklearn包,只是为了帮助理解更好的概念).这是我引用的主要材料.

我试图通过最小化来解决原始的SVM:

J wrt w的衍生物(根据上面的参考):

所以这是使用"铰链"损失,而C是惩罚参数.如果我理解正确,设置较大的C将强制SVM具有更大的边距.

以下是我的代码:

import numpy
from scipy import optimize

class SVM2C(object):
    def __init__(self,xdata,ydata,c=200.,learning_rate=0.01,
            n_iter=5000,method='GD'):

        self.values=numpy.unique(ydata)
        self.xdata=xdata
        self.ydata=numpy.where(ydata==self.values[-1],1,-1)
        self.c=c
        self.lr=learning_rate
        self.n_iter=n_iter
        self.method=method

        self.m=len(xdata)
        self.theta=numpy.random.random(xdata.shape[1])-0.5

    def costFunc(self,theta,x,y):
        zs=numpy.dot(x,theta)
        j=numpy.maximum(0.,1.-y*zs).mean()*self.c+0.5*numpy.sum(theta**2)
        return j

    def jac(self,theta,x,y):
        '''Derivative of cost function'''
        zs=numpy.dot(x,theta)
        ee=numpy.where(y*zs>=1.,0.,-y)[:,None]
        # multiply rows by ee
        dj=(ee*x).mean(axis=0)*self.c+theta
        return dj

    def train(self):

        #----------Optimize using scipy.optimize----------
        if self.method=='optimize':
            opt=optimize.minimize(self.costFunc,self.theta,args=(self.xdata,self.ydata),\
                    jac=self.jac,method='BFGS')
            self.theta=opt.x

        #---------Optimize using Gradient descent---------
        elif self.method=='GD':
            costs=[]
            lr=self.lr

            for ii in range(self.n_iter):
                dj=self.jac(self.theta,self.xdata,self.ydata)
                self.theta=self.theta-lr*dj
                cii=self.costFunc(self.theta,self.xdata,self.ydata)
                costs.append(cii)

            self.costs=numpy.array(costs)

        return self …

我在python doc中注意到有-c一面旗帜.这是python doc所说的:

在命令中执行Python代码.command可以是由换行符分隔的一个或多个语句,与正常的模块代码一样具有重要的前导空格.

文档中没有任何示例,我无法弄清楚如何使这项工作,以及在什么情况下它可能会有所帮助.

有人有任何线索吗？

我试图找到一个适合beta分布的正确方法.这不是一个现实世界的问题,我只是测试几种不同方法的效果,而这样做的事情令我感到困惑.

这是我正在研究的python代码,其中我测试了3种不同的方法:1>:使用时刻拟合(样本均值和方差).2>:通过最小化负对数似然来拟合(通过使用scipy.optimize.fmin()).3>:只需调用scipy.stats.beta.fit()

from scipy.optimize import fmin
from scipy.stats import beta
from scipy.special import gamma as gammaf
import matplotlib.pyplot as plt
import numpy


def betaNLL(param,*args):
    '''Negative log likelihood function for beta
    <param>: list for parameters to be fitted.
    <args>: 1-element array containing the sample data.

    Return <nll>: negative log-likelihood to be minimized.
    '''

    a,b=param
    data=args[0]
    pdf=beta.pdf(data,a,b,loc=0,scale=1)
    lg=numpy.log(pdf)
    #-----Replace -inf with 0s------
    lg=numpy.where(lg==-numpy.inf,0,lg)
    nll=-1*numpy.sum(lg)
    return nll

#-------------------Sample data-------------------
data=beta.rvs(5,2,loc=0,scale=1,size=500)

#----------------Normalize to [0,1]----------------
#data=(data-numpy.min(data))/(numpy.max(data)-numpy.min(data))

#----------------Fit using moments----------------
mean=numpy.mean(data)
var=numpy.var(data,ddof=1)
alpha1=mean**2*(1-mean)/var-mean
beta1=alpha1*(1-mean)/mean

#------------------Fit using …

我注意到在python中操作一些numpy数组之间x=x+a和x+=a操作之间的操作之间存在一些差异.

我试图做的只是将一些随机错误添加到整数列表,如下所示:

x=numpy.arange(12)
a=numpy.random.random(size=12)
x+=a

但打印输出x给出一个整数列表[0,1,2,3,4,5,6,7,8,9,10,11].

事实证明,如果我使用x=x+a它,它会按预期工作.

这是我们应该注意的事情,我的意思是它表现得如此不同.我曾经认为它在x+=a和之间是完全相同的,x=x+a并且我一直在互相使用它们,而不是一直关注它们.现在,我对迄今为止所做的所有计算都非常关注和焦虑.谁知道这个问题何时何地发生,我必须仔细检查所有内容.

这是numpy中的一个错误吗？我已经在numpy版本1.2.0和1.6.1中进行了测试,他们都做到了这一点.

我正在学习使用networkx python模块对二分图进行一些匹配。模块中有两个函数可以提供图形的最大基数匹配：

1. nx.maximal_matching()
2. nx.bipartite.maxmum_matching()

请注意，尽管其名称为maximal_matching，但其文档确实声明“在图中找到最大基数匹配”。

由于我的图是二分图，因此我假设这2个图将给出相同的结果，至少两个都具有相同的边数。但是，我的代码似乎暗示nx.maximal_matching()给出了错误的答案：正如所nx.bipartite.maxmum_matching()暗示的，可能还有一个优势。

下面是我的工作代码：

import networkx as nx
from networkx import bipartite    

def plotGraph(graph,ax,title):    
    pos=[(ii[1],ii[0]) for ii in graph.nodes()]
    pos_dict=dict(zip(graph.nodes(),pos))
    nx.draw(graph,pos=pos_dict,ax=ax,with_labels=True)
    ax.set_title(title)
    return   

if __name__=='__main__':    
    #---------------Construct the graph---------------
    g=nx.Graph()
    edges=[
            [(1,0), (0,0)],
            [(1,0), (0,1)],
            [(1,0), (0,2)],
            [(1,1), (0,0)],
            [(1,2), (0,2)],
            [(1,2), (0,5)],
            [(1,3), (0,2)],
            [(1,3), (0,3)],
            [(1,4), (0,3)],
            [(1,5), (0,2)],
            [(1,5), (0,4)],
            [(1,5), (0,6)],
            [(1,6), (0,1)],
            [(1,6), (0,4)],
            [(1,6), (0,6)]
            ]

    for ii in edges:
        g.add_node(ii[0],bipartite=0)
        g.add_node(ii[1],bipartite=1)

    g.add_edges_from(edges)

    #---------------Use maximal_matching--------------- …

我正在学习如何从这款笔记本上加速GPU上的py​​thon计算,其中一行令我困惑:

mandel_kernel[griddim, blockdim](-2.0, 1.0, -1.0, 1.0, d_image, 20)

在此,mandel_kernel是一个装饰(通过cuda.jit)的功能,griddim和blockdim是长度为2的元组:griddim=(32,16),blockdim=(32,8).

这个方括号是在python语法的函数名和参数列表部分之间,还是特定于cuda.jit装饰的东西？

我正在尝试创建一个TableView具有排序功能的。如果我将TableViewobj 设置为我的自定义HeaderView，则单击标题将不会排序，即使我的自定义HeaderView没有重新实现任何内容。如果我使用 的TableViewheader ( hh=tv.horizontalHeader()) 来代替，它就会排序。我究竟做错了什么？

代码如下：

import sys
import operator
from PyQt5 import QtWidgets
from PyQt5.QtCore import QAbstractTableModel, Qt, QVariant

class TableModel(QAbstractTableModel):
    def __init__(self, parent, datain, headerdata):
        super(TableModel,self).__init__(parent)

        self.arraydata=datain
        self.headerdata=headerdata

    def rowCount(self,p):
        return len(self.arraydata)

    def columnCount(self,p):
        if len(self.arraydata)>0:
            return len(self.arraydata[0])
        return 0

    def data(self, index, role):
        if not index.isValid():
            return QVariant()
        elif role != Qt.DisplayRole:
            return QVariant()
        return QVariant(self.arraydata[index.row()][index.column()])

    def headerData(self, col, orientation, role):
        if orientation==Qt.Horizontal and role==Qt.DisplayRole: …

我想用给定的值（例如）替换给A定索引（例如0）沿给定轴（例如-2）的给定 numpy 数组（）中的值0，等效地：

A[:,:,0,:]=0

问题是输入数组A可能以 3D 或 4D 或其他形状出现，因此对于 3D 数据，我需要

A[:,0,:]=0

如果是 5D： A[:,:,:,0,:]=0

目前我正在使用 anexec()来完成这项工作：

slicestr=[':']*numpy.ndim(var)
slicestr[-2]=str(0)
slicestr=','.join(slicestr)
cmd='A[%s]=0' %slicestr
exec(cmd)
return A

我有点担心 的使用exec()可能不是一个很好的方法。我知道这numpy.take()可以为我提供沿特定轴的特定索引处的列，但要替换值，我仍然需要构建动态的切片/索引字符串。所以我想知道是否有任何原生的 numpy 方法来实现这一目标？

谢谢。

我发现这个 scipy 函数scipy.signal.peak_prominences可以找到一维序列中指定局部最大值的地形突出。

但是我的应用程序需要在 2D 阵列中定位重要的峰。我知道一些峰值查找方法，例如进行最大过滤，scipy 和 skimage 都有它们的实现。还有 skimage 的h_maxima()允许过滤具有最小相对高度的局部峰值。但是这些只给出了山峰的坐标，而不是它们的突出度。

那么如何计算二维数组上的峰值突出度？任何帮助，将不胜感激。