小编rob*_*anf的帖子

我有一维数字,想要计算所有成对的欧氏距离.我有一个方法(感谢SO)用广播这样做,但它效率低,因为它计算每个距离两次.并且它不能很好地扩展.

这是一个例子,通过1000个数字的数组给出了我想要的东西.

import numpy as np
import random
r = np.array([random.randrange(1, 1000) for _ in range(0, 1000)])
dists = np.abs(r - r[:, None])

什么是scipy/numpy/scikit中最快的实现 - 我可以用来做这个,因为它必须扩展到1D数组具有> 10k值的情况.

注意:矩阵是对称的,所以我猜测通过解决它可以获得至少2倍的加速,我只是不知道如何.

我有一个R脚本,它接受一个文件作为输入,我想要一个通用的方法来知道输入是一个存在的文件,而不是一个目录.

在Python中,您可以这样做:如何使用Python检查文件是否存在？,但我很难在R中找到类似的东西.

假设file.txt实际存在,我想要的是下面的内容:

input.good = "~/directory/file.txt"
input.bad = "~/directory/"

is.file(input.good) # should return TRUE
is.file(input.bad) #should return FALSE

R有一个叫做file.exists()的东西,但这并不区分文件和目录.

我试图找到在Python中执行以下成对距离计算的最快方法.我想使用距离来排列a list_of_objects的相似性.

其中的每个项目的list_of_objects特征在于四个测量a,b,c,d,它们是在非常不同的尺度上制作的,例如:

object_1 = [0.2, 4.5, 198, 0.003]
object_2 = [0.3, 2.0, 999, 0.001]
object_3 = [0.1, 9.2, 321, 0.023]
list_of_objects = [object_1, object_2, object_3]

目的是获得物体的成对距离矩阵list_of_objects.但是,我希望能够通过每个测量一个权重的权重向量来指定距离计算中每个度量的"相对重要性",例如:

weights = [1, 1, 1, 1]

表示所有测量值均等加权.在这种情况下,无论测量范围如何,我都希望每个测量对物体之间的距离做出相同的贡献.或者:

weights = [1, 1, 1, 10]

表明我希望测量d比其他测量值对物体之间的距离贡献10倍.

我当前的算法如下所示:

1. 计算每次测量的成对距离矩阵
2. 标准化每个距离矩阵,使最大值为1
3. 将每个距离矩阵乘以适当的权重 weights
4. 对距离矩阵求和以生成单个成对矩阵
5. 使用4中的矩阵提供对象对的排序列表 list_of_objects

这很好,并给我一个加权版本的对象之间的城市块距离.

我有两个问题:

1. 在不改变算法的情况下,SciPy,NumPy或SciKit-Learn中执行初始距离矩阵计算的最快实现是什么.

2. 是否存在一种现有的多维距离方法,可以为我完成所有这些工作？

对于问题2,我看过,但找不到任何内置步骤,以我想要的方式做出"相对重要性".

欢迎其他建议.很高兴澄清我是否错过了细节.

我一直致力于为生物学问题生成所有可能的子模型.我有一个工作递归,用于生成我想要的所有子模型的大列表.但是,列表的速度非常快(N = 12只能在下面的示例中使用,N> 12使用太多内存).所以我想用yield来转换为生成器函数,但是我被卡住了.

我的工作递归函数如下所示:

def submodel_list(result, pat, current, maxn):
    ''' result is a list to append to
        pat is the current pattern (starts as empty list)
        current is the current number of the pattern
        maxn is the number of items in the pattern
    '''
    if pat:
        curmax = max(pat)
    else: 
        curmax = 0
    for i in range(current):
        if i-1 <= curmax:
            newpat = pat[:]
            newpat.append(i)
            if current == maxn:
                result.append(newpat)
            else:
                submodel_generator(result, newpat, current+1, maxn)

result = []
submodel_list(result, …

我有一长串的整数,我想把它变成MD5哈希.最快的方法是什么？我尝试了两个选项,两者都相似.只是想知道我是否错过了一种明显更快的方法.

import random
import hashlib
import cPickle as pickle

r = [random.randrange(1, 1000) for _ in range(0, 1000000)]

def method1(r):
    p = pickle.dumps(r, -1)
    return hashlib.md5(p).hexdigest()

def method2(r):
    p = str(r)
    return hashlib.md5(p).hexdigest()

def method3(r):
    p = ','.join(map(str, r))
    return hashlib.md5(p).hexdigest()

然后在iPython中计时:

timeit method1(r)
timeit method2(r)
timeit method3(r)

给我这个:

In [8]: timeit method1(r)
10 loops, best of 3: 68.7 ms per loop

In [9]: timeit method2(r)
10 loops, best of 3: 176 ms per loop

In [10]: timeit method3(r)
1 …

我有一个关于在R中匹配两个矩阵以执行非常简单的计算的问题.我有工作代码(下面),但我觉得必须有一个更高效和'R-like'的方式来做到这一点.任何线索都非常受欢迎.

问题

我有两个相关信息的矩阵.m1包含一堆引用.m2包含那些引用的数据(零或一).我想知道当你从m2中查找数据时,第一列中m1的哪些行为'0'而第二列中的哪一行为'1'.这是一个玩具示例:

> m1 <- matrix(data = c(51,52,53,51,54,55,56,57), nrow = 4, ncol = 2)
> m1
     [,1] [,2]
[1,]   51   54
[2,]   52   55
[3,]   53   56
[4,]   51   57

> m2 <- matrix(data = c(0,0,1,0,0,1,1), nrow = 7, ncol = 1)
> rownames(m2) <- c(51,52,53,54,55,56,57)
> m2
   [,1]
51    0
52    0
53    1
54    0
55    0
56    1
57    1

一般属性是我已经可以保证m1中的每个条目都有一个相应的行名称,并且我需要在更大的矩阵上进行数百万次,因此速度很有用.

我想要做的是使用m2来确定哪一行m1在第一列中为零,在第二列中为1.在这种情况下,只有m1的最后一行具有该属性.

我的解决方案

我有一个相对好的解决方案,它使用apply()并且不是太糟糕:

> is.zero.one <- function(line, m2){
+    start = m2[as.character(line[1]),]
+    end   = …

我有一个大型的对称二维距离数组。我想获得最接近的 N 对观察结果。

该数组存储为一个 numpy 压缩数组，并且具有 1 亿个观测值的数量级。

这是一个在较小阵列上获得 100 个最近距离的示例（~500k 观察），但它比我想要的要慢得多。

import numpy as np
import random
import sklearn.metrics.pairwise
import scipy.spatial.distance

N = 100
r = np.array([random.randrange(1, 1000) for _ in range(0, 1000)])
c = r[:, None]

dists = scipy.spatial.distance.pdist(c, 'cityblock')

# these are the indices of the closest N observations
closest = dists.argsort()[:N]

# but it's really slow to get out the pairs of observations
def condensed_to_square_index(n, c):
    # converts an index in a condensed array to the …

我试图找出一种方法来获取一个 numpy 整数数组，然后更改条目以使最小的为 0，第二小的为 1，等等。

例如

从这个开始

In [13]: a = numpy.array([[1, 2, 10],[1, 2, 99]])

In [14]: a
Out[14]: 
array([[ 1,  2, 10],
       [ 1,  2, 99]])

得到这个：

array([[ 0,  1, 2],
       [ 0,  1, 3]])

我可以开始看到 numpy.unique() 的方法，例如

In [19]: range(len(b))
Out[19]: [0, 1, 2, 3]

In [20]: b = numpy.unique(a)

In [21]: b
Out[21]: array([ 1,  2, 10, 99])

In [22]: c = range(len(b))

In [23]: c
Out[23]: [0, 1, 2, 3]

似乎我现在应该能够使用 b 和 c 从一个数组转换到另一个数组。但最好（也是最快）的方法是什么？

我有一个for循环,在100个不同的输入文件夹上运行一个Python脚本~100次.python脚本在2个内核上最有效,我有50个内核可用.所以我想使用GNU parallel一次在25个文件夹上运行脚本.

这是我的for循环(工作正常,但当然是顺序的),python脚本需要一堆输入变量,包括-p 2在两个核心上运行它:

for folder in $(find /home/rob/PartitionFinder/ -maxdepth 2 -type d); do
        python script.py --raxml --quick --no-ml-tree $folder --force -p 2
done

这是我尝试并行化它,这是行不通的:

folders=$(find /home/rob/PartitionFinder/ -maxdepth 2 -type d)

echo $folders | parallel -P 25 python script.py --raxml --quick --no-ml-tree {} --force -p 2

我遇到的问题(也许它只是众多的第一个)是我的folders变量不是一个列表,所以它实际上只是传递一个长100个文件夹的字符串作为{}脚本.

感谢所有提示.

我有一个2d numpy矩阵,想要计算以下测试统计.

我有蛮力代码来做这件事,但似乎应该有一个更通用的numpy解决方案适用于任何2D矩阵,使用类似的东西np.diag().我无法弄明白.

def bruteforce(m):
    s = 0.0
    for (i,j) in itertools.product(range(0,m.shape[0]),range(0,m.shape[0])):
        if i<j:
            n = (m[i,j]-m[j,i])**2
            d = m[i,j]+m[j,i]
            if float(d) != 0.:
                s = s+(float(n)/float(d)) 
            else:
                return('NA')
    return(s)

在这种情况下,m是整数的N×N矩阵.有没有办法在numpy中进行矢量化,避免像这样的暴力循环？