Question

假设我有一个10,000磅的矢量，我想拍摄一个只有100个对数间隔点的切片。我想要一个函数给我索引的整数值。这是一个简单的解决方案，只需使用+ logspace，然后摆脱重复。

def genLogSpace( array_size, num ):
    lspace = around(logspace(0,log10(array_size),num)).astype(uint64)
    return array(sorted(set(lspace.tolist())))-1

ls=genLogspace(1e4,100)

print ls.size
>>84
print ls
array([   0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,
         11,   13,   14,   15,   17,   19,   21,   23,   25,   27,   30,
         33,   37,   40,   44,   49,   54,   59,   65,   71,   78,   86,
         94,  104,  114,  125,  137,  151,  166,  182,  200,  220,  241,
        265,  291,  319,  350,  384,  422,  463,  508,  558,  613,  672,
        738,  810,  889,  976, 1071, 1176, 1291, 1416, 1555, 1706, 1873,
       2056, 2256, 2476, 2718, 2983, 3274, 3593, 3943, 4328, 4750, 5213,
       5721, 6279, 6892, 7564, 8301, 9111, 9999], dtype=uint64)

请注意，有16个重复，所以现在我只有84个点。

有没有人有一个能够有效确保输出样本数量为num的解决方案？对于此特定示例，num为121和122的输入值给出100个输出点。

Answer 1

这有点棘手。您不能总是得到对数间隔的数字。在您的示例中，第一部分是相当线性的。如果你对此感到满意，我有一个解决方案。但是对于解决方案，你应该理解为什么你有重复。

对数标度满足条件：

s[n+1]/s[n] = constant

让我们为r调用此常数ratio。对于范围n之间的1...size这些数字，您将获得：

1, r, r**2, r**3, ..., r**(n-1)=size

所以这会给你：

r = size ** (1/(n-1))

在您的情况下，n=100和size=10000，r将为~1.0974987654930561，这意味着，如果您从1开始，您的下一个号码将是1.0974987654930561然后再次四舍五入到1。因此你的重复。此问题适用于小数字。在足够大的数字之后，乘以比率将导致不同的舍入整数。

记住这一点，最好的办法是将连续的整数添加到某个点，这样这个乘以比率就不再是问题。然后，您可以继续使用对数缩放。以下功能可以做到：

import numpy as np

def gen_log_space(limit, n):
    result = [1]
    if n>1:  # just a check to avoid ZeroDivisionError
        ratio = (float(limit)/result[-1]) ** (1.0/(n-len(result)))
    while len(result)<n:
        next_value = result[-1]*ratio
        if next_value - result[-1] >= 1:
            # safe zone. next_value will be a different integer
            result.append(next_value)
        else:
            # problem! same integer. we need to find next_value by artificially incrementing previous value
            result.append(result[-1]+1)
            # recalculate the ratio so that the remaining values will scale correctly
            ratio = (float(limit)/result[-1]) ** (1.0/(n-len(result)))
    # round, re-adjust to 0 indexing (i.e. minus 1) and return np.uint64 array
    return np.array(list(map(lambda x: round(x)-1, result)), dtype=np.uint64)

Python 3更新：Python 2中的最后一行是 return np.array(map(lambda x: round(x)-1, result), dtype=np.uint64)

以下是使用它的一些示例：

In [157]: x = gen_log_space(10000, 100)

In [158]: x.size
Out[158]: 100

In [159]: len(set(x))
Out[159]: 100

In [160]: y = gen_log_space(2000, 50)

In [161]: y.size
Out[161]: 50

In [162]: len(set(y))
Out[162]: 50

In [163]: y
Out[163]:
array([   0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   11,
         13,   14,   17,   19,   22,   25,   29,   33,   38,   43,   49,
         56,   65,   74,   84,   96,  110,  125,  143,  164,  187,  213,
        243,  277,  316,  361,  412,  470,  536,  612,  698,  796,  908,
       1035, 1181, 1347, 1537, 1753, 1999], dtype=uint64)

为了向您展示结果是如何对数的，这里是x = gen_log_scale(10000, 100)的输出的半对数图（正如您所看到的，左边部分不是真正的对数）：

enter image description here

Answer 2

Avaris's answer中直接生成对数间隔点的方法绝对是可行的方法。但是我觉得如何选择合适的值来传递给logspace以获得你想要的东西会很有趣。

由logspace(0, k, n)生成的数组中的值是数字10 ^{ik /（ n -1）}0≤ i ＆lt; 名词：

>>> numpy.logspace(0, 2, 10)
array([   1.        ,    1.66810054,    2.7825594 ,    4.64158883,
          7.74263683,   12.91549665,   21.5443469 ,   35.93813664,
         59.94842503,  100.        ])
>>> [10 ** (i * 2 / 9.0) for i in xrange(10)]
[1.0, 1.6681005372000588, 2.7825594022071245, 4.641588833612778,
 7.742636826811269, 12.91549665014884, 21.544346900318832,
 35.938136638046274, 59.94842503189409, 100.0]

这个序列由一个初始段组成，其中值比单位间隔更接近（因此当它们四舍五入到最接近的整数时可能会有重复），然后是一个段，其中值比单位间隔更宽并且没有重复。

>>> ' '.join('{:.2f}'.format(10 ** (i * 2 / 19.0)) for i in xrange(20))
'1.00 1.27 1.62 2.07 2.64 3.36 4.28 5.46 6.95 8.86 11.29 14.38 18.33 23.36
 29.76 37.93 48.33 61.58 78.48 100.00'
>>> [int(0.5 + 10 ** (i * 2 / 19.0)) for i in xrange(20)]
[1, 1, 2, 2, 3, 3, 4, 5, 7, 9, 11, 14, 18, 23, 30, 38, 48, 62, 78, 100]

值之间的间距 s （ i ）= 10 ^iK - 10 ^{（< em> i -1） K}，其中 K = k /（ n - 1）。设 m 为最小值，使 s （ m ）≥1。（示例中 m = 7）以上。）然后当删除重复时，恰好有⌊½+ 10 ^{（ m -1） K}⌋+ n < / em> - m 剩余数字。

一些代数发现：

m =⌈ - log（1 - 10 ^{- K}）/ K log10⌉

让我们检查一下。

from math import ceil, floor, log def logspace_size(k, n): """ Return the number of distinct integers we'll get if we round `numpy.logspace(0, k, n)` to the nearest integers and remove duplicates. >>> logspace_size(4, 100) 84 >>> logspace_size(4, 121) 100 >>> from numpy import around, logspace >>> all(logspace_size(k, n) == len(set(around(logspace(0, k, n)))) ... for k in xrange(1,10) for n in xrange(2,100)) True """ K = float(k) / (n - 1) m = int(ceil(- log(1 - 10 ** -K) / (K * log(10)))) if m < n: return int(0.5 + 10 ** ((m - 1) * K)) + n - m else: return int(0.5 + 10 ** ((n - 1) * K))

doctests通过，所以这对我来说很好。所以您需要做的就是找n logspace_size(4, n) == 100。您可以通过二进制方法或scipy.optimize方法之一来完成此操作：

>>> f = lambda x, k, n:(logspace_size(k, x) - n)**2 >>> int(round(scipy.optimize.fmin(f, 100, args=(4,100), xtol=0.5, ftol=0.5)[0])) Optimization terminated successfully. Current function value: 0.015625 Iterations: 8 Function evaluations: 17 122

Answer 3

我在这里搜索一个简单的方法，在python中得到对数间隔的系列（基数为10）（省略numpy的使用）。但是，对于我的超简单需求，您的解决方案很复杂。

def logarithmic_decade(numbers_per_decade, offset=10):
    for n in xrange(numbers_per_decade):
        yield offset * 10.0 ** (n / float(numbers_per_decade))

因为它是生成器以获得列表所以你必须：

numbers = list(logarithmic_decade(5))
print numbers
[10.0, 15.848931924611136, 25.118864315095802, 39.81071705534972, 63.095734448019336]

for p, n in zip(numbers, numbers[1:] + [100]):
    print 'prev = {p:.2f}, next = {n:.2f}, next/prev = {rt:.4f}'.format(p=p, n=n, rt=n / p)

提供以下输出：

prev = 10.00, next = 15.85, next/prev = 1.5849
prev = 15.85, next = 25.12, next/prev = 1.5849
prev = 25.12, next = 39.81, next/prev = 1.5849
prev = 39.81, next = 63.10, next/prev = 1.5849
prev = 63.10, next = 100.00, next/prev = 1.5849

Answer 4

1到1e4之间的单行解决方案：

y = [(lambda x:int(x))(tmp) for tmp in np.logspace(0,4, 10)]

对数间隔的整数

4 个答案: