小编alk*_*lko的帖子

我有一个数据集,其中类是不平衡的.类为'1'或'0',其中类'1':'0'的比例为5:1.你如何计算每个类的预测误差和相应的重新平衡权重在sklearn中随机森林,类似于以下链接:http: //www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm#平衡

我有一个DataFrame,其中一列包含每行的标签(除了每行的一些相关数据).我有一个字典,其键等于可能的标签和值,等于与该标签相关的2元组信息.我想在我的框架上添加两个新列,一个对应于每行标签的2元组的每个部分.

这是设置:

import pandas as pd
import numpy as np

np.random.seed(1)
n = 10

labels = list('abcdef')
colors = ['red', 'green', 'blue']
sizes = ['small', 'medium', 'large']

labeldict = {c: (np.random.choice(colors), np.random.choice(sizes)) for c in labels}

df = pd.DataFrame({'label': np.random.choice(labels, n), 
                   'somedata': np.random.randn(n)})

我可以通过运行得到我想要的东西:

df['color'], df['size'] = zip(*df['label'].map(labeldict))
print df

  label  somedata  color    size
0     b  0.196643    red  medium
1     c -1.545214  green   small
2     a -0.088104  green   small
3     c  0.852239  green   small
4     b  0.677234    red  medium
5 …

目前我正在做一个可能需要使用kNN算法来找到给定点的前k个最近邻居的项目,比如P. im使用python,sklearn包来完成这项工作,但是我们的预定义度量不是那些默认值指标.所以我必须使用用户定义的度量标准,来自sklearn的文档,可以在这里和这里找到.

似乎最新版本的sklearn kNN支持用户定义的度量标准,但我无法找到如何使用它:

import sklearn
from sklearn.neighbors import NearestNeighbors
import numpy as np
from sklearn.neighbors import DistanceMetric
from sklearn.neighbors.ball_tree import BallTree
BallTree.valid_metrics

我已经定义了一个名为mydist = max(xy)的度量,然后使用DistanceMetric.get_metric使其成为DistanceMetric对象:

dt=DistanceMetric.get_metric('pyfunc',func=mydist)

从文档中,该行应该如下所示

nbrs = NearestNeighbors(n_neighbors=4, algorithm='auto',metric='pyfunc').fit(A)
distances, indices = nbrs.kneighbors(A)

但我dt在哪里可以放入？谢谢

我发现像函数调用和循环这样的简单事情,甚至只是递增计数器的循环在Python和Ruby中花费的时间远远多于Chicken Scheme,Racket或SBCL.

为什么会这样？我经常听到有人说慢速是你为动态语言付出的代价,但是Lisps非常动态并且速度不是很慢(它们通常比C慢不到5倍; Ruby和Python可以达到两位数).此外,Lisp样式使用递归,并不总是尾递归,很多,堆栈是堆中的连续的链接列表等,这似乎应该使Lisp比命令式样式的Python和Ruby慢.

Racket和SBCL是JITted,但Chicken Scheme要么是静态编译的,要么使用非优化的解释器,这两种解释器都应该非常适合动态语言并且速度慢.即使使用了csiChicken Scheme 的天真解释器(甚至不进行字节码编译!),我的速度远远超出了Python和Ruby.

与类似的动态Lisps相比,为什么Python和Ruby的速度如此之慢？是因为它们是面向对象的,需要巨大的vtable和类型heirarchies？

示例:阶乘函数.蟒蛇:

def factorial(n):
    if n == 0:
        return 1
    else:
    return n*factorial(n-1)

for x in xrange(10000000):
    i = factorial(10)

球拍:

#lang racket

(define (factorial n)
  (cond
   [(zero? n) 1]
   [else (* n (factorial (sub1 n)))]))

(define q 0)

(for ([i 10000000])
  (set! q (factorial 10)))

时间结果:

ithisa@miyasa /scratch> time racket factorial.rkt
racket factorial.rkt  1.00s user 0.03s system 99% cpu 1.032 total
ithisa@miyasa /scratch> time python factorial.py
python …

我有python 2.6.1,因为它很旧我决定安装python 3.3.2但是,当我在我的mac中输入"python"它打印它是版本2.6.1并且当我输入python3时它显示这是3.3.2 .我安装了django 1.6但是当我检查时,了解它是为旧版本的python(python 2.6.1)安装的.我想为我的python 3.3.2安装它我该怎么办？任何卸载python 2.6.1的方法,当我在终端输入python时,它的版本是3.3.2吗？我有mac os 10.6.8

我正试图把这个csv读成大熊猫

HK,"[u'5328.1', u'5329.3', '2013-12-27 13:58:57.973614']"
HK,"[u'5328.1', u'5329.3', '2013-12-27 13:58:59.237387']"
HK,"[u'5328.1', u'5329.3', '2013-12-27 13:59:00.346325']"

正如您所看到的,只有2列,第二列是列表,当使用带有参数的pd.read_csv()时,有没有办法正确解释它(意味着将列表中的值读取为列)？

谢谢

更新:我已经修改了Optimize,Eigen和Solve方法来反映变化.所有现在都返回"相同"向量,允许机器精度. 我仍然对Eigen方法感到困惑.具体如何/为什么我选择特征向量切片没有意义.这只是试验和错误,直到正常情况与其他解决方案相匹配.如果有人能够纠正/解释我真正应该做的事情,或者为什么我做了什么工作我会很感激..

感谢 亚历山大克莱默解释为什么我采取切片,只能选择一个正确的答案

我有一个深度图像.我想计算深度图像中像素的粗糙表面法线.我考虑周围像素,在最简单的情况下是3x3矩阵,并将平面拟合到这些点,并计算该平面的法向单位矢量.

听起来很简单,但最好先考虑平面拟合算法.搜索SO和其他各种网站,我看到使用最小二乘法,单值分解,特征向量/值等的方法.

虽然我不完全理解数学,但我已经能够使各种片段/示例起作用.我遇到的问题是,我对每种方法都有不同的答案.我期待各种答案是相似的(不完全),但它们似乎有很大的不同.也许有些方法不适合我的数据,但不确定为什么我会得到不同的结果.有什么想法吗？

这是代码的更新输出:

LTSQ:   [ -8.10792259e-17   7.07106781e-01  -7.07106781e-01]
SVD:    [ 0.                0.70710678      -0.70710678]
Eigen:  [ 0.                0.70710678      -0.70710678]
Solve:  [ 0.                0.70710678       0.70710678]
Optim:  [ -1.56069661e-09   7.07106781e-01   7.07106782e-01]

以下代码实现了五种不同的方法来计算平面的曲面法线.算法/代码来自互联网上的各种论坛.

import numpy as np
import scipy.optimize

def fitPLaneLTSQ(XYZ):
    # Fits a plane to a point cloud, 
    # Where Z = aX + bY + c        ----Eqn #1
    # Rearanging Eqn1: aX + bY -Z +c =0
    # Gives normal (a,b,-1)
    # …

我想从我的hadoop流媒体作业中的文件中读取一个列表.这是我简单的mapper.py:

#!/usr/bin/env python

import sys
import json

def read_file():
    id_list = []
    #read ids from a file
    f = open('../user_ids','r')
    for line in f:
        line = line.strip()
        id_list.append(line)
    return id_list

if __name__ == '__main__':
    id_list = set(read_file())
    # input comes from STDIN (standard input)
    for line in sys.stdin:
        # remove leading and trailing whitespace
        line = line.strip()
        line = json.loads(line)
        user_id = line['user']['id']
        if str(user_id) in id_list:
            print '%s\t%s' % (user_id, line)

这是我的reducer.py

#!/usr/bin/env python

from operator import itemgetter
import …

我从DPGMM得到的结果不是我所期望的.例如:

>>> import sklearn.mixture
>>> sklearn.__version__
'0.12-git'
>>> data = [[1.1],[0.9],[1.0],[1.2],[1.0], [6.0],[6.1],[6.1]]
>>> m = sklearn.mixture.DPGMM(n_components=5, n_iter=1000, alpha=1)
>>> m.fit(data)
DPGMM(alpha=1, covariance_type='diag', init_params='wmc', min_covar=None,
   n_components=5, n_iter=1000, params='wmc',
   random_state=<mtrand.RandomState object at 0x108a3f168>, thresh=0.01,
   verbose=False)
>>> m.converged_
True
>>> m.weights_
array([ 0.2,  0.2,  0.2,  0.2,  0.2])
>>> m.means_
array([[ 0.62019109],
       [ 1.16867356],
       [ 0.55713292],
       [ 0.36860511],
       [ 0.17886128]])

我预计结果会更像香草GMM; 也就是说,两个高斯(大约是1和6),具有不均匀的权重(如[0.625,0.375]).我预计"未使用过的"高斯人的重量接近于零.

我错误地使用了模型吗？

我也尝试过改变阿尔法而没有任何运气.

说我有一个清单:

a = [3, 5, 1, 1, 3, 2, 4, 1, 6, 4, 8]

和一个子列表:

b = [5, 2, 6, 8]

我想获取bin pd.qcut(a,2)并计算列表b的每个bin中的值的数量.那是

In[84]: pd.qcut(a,2)
Out[84]: 
Categorical: 
[[1, 3], (3, 8], [1, 3], [1, 3], [1, 3], [1, 3], (3, 8], [1, 3], (3, 8], (3, 8], (3, 8]]
Levels (2): Index(['[1, 3]', '(3, 8]'], dtype=object)

现在我知道箱子是:[1,3]和(3,8),我想知道列表"b"的每个箱子中有多少值.当箱子的数量为时,我可以手动完成很小,但是当垃圾箱数量很大时,最好的方法是什么？