小编Div*_*kar的帖子

例如,我有排序的向量:[9 9 9 10 13 13 14 15]我想给每个元素它的顺序(并保持相同的元素).即我希望答案是:[1 1 1 2 3 3 4 5]

有任何想法吗？谢谢!

注意:我的真实矢量要大得多(大约50,000个元素)所以我不能手动完成...

smooth默认情况下,Matlab的功能使用5点移动平均值来平滑数据.在python中做同样的事情的最佳方法是什么？例如,如果这是我的数据

0
0.823529411764706
0.852941176470588
0.705882352941177
0.705882352941177
0.676470588235294
0.676470588235294
0.500000000000000
0.558823529411765
0.647058823529412
0.705882352941177
0.705882352941177
0.617647058823529
0.705882352941177
0.735294117647059
0.735294117647059
0.588235294117647
0.588235294117647
1
0.647058823529412
0.705882352941177
0.764705882352941
0.823529411764706
0.647058823529412
0.735294117647059
0.794117647058824
0.794117647058824
0.705882352941177
0.676470588235294
0.794117647058824
0.852941176470588
0.735294117647059
0.647058823529412
0.647058823529412
0.676470588235294
0.676470588235294
0.529411764705882
0.676470588235294
0.794117647058824
0.882352941176471
0.735294117647059
0.852941176470588
0.823529411764706
0.764705882352941
0.558823529411765
0.588235294117647
0.617647058823529
0.647058823529412
0.588235294117647
0.617647058823529
0.647058823529412
0.794117647058824
0.823529411764706
0.647058823529412
0.617647058823529
0.647058823529412
0.676470588235294
0.764705882352941
0.676470588235294
0.647058823529412
0.705882352941177
0.764705882352941
0.705882352941177
0.500000000000000
0.529411764705882
0.529411764705882
0.647058823529412
0.676470588235294
0.588235294117647
0.735294117647059
0.794117647058824
0.852941176470588
0.764705882352941

平滑的数据应该是

0
0.558823529411765
0.617647058823530
0.752941176470588 …

我有两个数组,我想根据另一个的值选择其中一个数组的一部分.我知道如何在几行中做到这一点,但我想知道在一行中是否有更简洁的方法来做到这一点.这就是我做的那种漫长而丑陋的事情.

lower = some_value; upper = another_value
a = [some numpy array]; b = [another numpy array]
b_select = []
for i in range(len(a)):
    if a[i] < lower or a[i] > upper:
        b_select.append(b[i])

所以基本上我的问题是,我可以在一行中获得b_select,而不是最后4行吗？

任何建议将不胜感激.有关信息,我在Python 2.7中这样做.

给定一个数组,我想将其标准化,使每行总和为1.

我目前有以下代码:

import numpy
w = numpy.array([[0, 1, 0, 1, 0, 0], 
                 [1, 0, 0, 0, 0, 1], 
                 [0, 0, 0, 0, 0, 1], 
                 [1, 0, 0, 0, 1, 0], 
                 [0, 0, 0, 1, 0, 1], 
                 [0, 1, 1, 0, 1, 0]], dtype = float)


def rownormalize(array):
    i = 0
    for row in array:
        array[i,:] = array[i,:]/sum(row)
        i += 1

我有两个问题:

1)代码有效,但我想知道是否有更优雅的方式.

2)如果它是int,我如何将数据类型转换为float？我试过了

if array.dtype == int:
    array.dtype = float

但它不起作用.

我有一个数组A和一个参考数组B.尺寸A至少和B.一样大.例如

A = [2,100,300,793,1300,1500,1810,2400]
B = [4,305,789,1234,1890]

B实际上是指定时间信号中峰值的位置,并且A包含稍后峰值的位置.但是某些元素A实际上是不是我想要的(可能是由于噪声等)的山峰,我想找到"真正的"一个A基础B.在"真实的"元件A应接近那些B,和在上面给出的例子中,在"真实"的人A应A'=[2,300,793,1300,1810].在这个例子中应该很明显,这100,1500,2400不是我们想要的,因为它们与B中的任何元素相距甚远.如何在python/matlab中以最有效/准确的方式编写代码？

我有一个包含4个班级的庞大训练数据集.这些类是非连续标记的.为了能够应用顺序神经网络,必须重新标记类,以便类中的唯一值是连续的.此外,在脚本结束时,我必须将它们重新标记回旧值.

我知道如何用循环重新标记它们:

def relabel(old_classes, new_classes):
    indexes=[np.where(old_classes ==np.unique(old_classes)[i]) for i in range(len(new_classes))]
    for i in range(len(new_classes )):
        old_classes [indexes[i]]=new_classes[i]
    return old_classes

>>> old_classes = np.array([0,1,2,6,6,2,6,1,1,0])
>>> new_classes = np.arange(len(np.unique(old_classes)))
>>> relabel(old_classes,new_classes)
array([0, 1, 2, 3, 3, 2, 3, 1, 1, 0])

但这不是很好的编码,需要花费很多时间.

知道如何对这种重新贴图进行矢量化吗？

为了清楚起见,我还希望能够将它们重新标记为旧值:

>>> relabeled_classes=np.array([0, 1, 2, 3, 3, 2, 3, 1, 1, 0])
>>> old_classes = np.array([0,1,2,6])
>>> relabel(relabeled_classes,old_classes )
array([0,1,2,6,6,2,6,1,1,0])

我正在尝试完成斯坦福 cs244n 课程的作业 1。问题 1b 强烈推荐对 Softmax 函数进行优化。我设法得到了 N 维向量的 Softmax。我还得到了 MxN 维矩阵的 Softmax，但在列中使用了 for 循环。我有以下代码：

def softmax(x):
    orig_shape = x.shape

    # Matrix
    if len(x.shape) > 1:
        softmax = np.zeros(orig_shape)
        for i,col in enumerate(x):
            softmax[i] = np.exp(col - np.max(col))/np.sum(np.exp(col - np.max(col)))
    # Vector
    else:
        softmax = np.exp(x - np.max(x))/np.sum(np.exp(x - np.max(x)))
    return softmax

我可以实现更优化的 Matrix 实现吗？

我有以下X numpy数组.我想用X [i]创建一个数组,其中包含数组的三个最小X [i] [3]值.

array([[  2, 356,   1, 0.7],
       [  3, 356,   1, 5],
       [  3, 357,   1, 3],
       [  4, 355,   1, 0.1],
       [  4, 356,   1, 16],
       [  4, 357,   1, 2]])

结果应如下所示:

array([[  2, 356,   1, 0.7],
       [  4, 355,   1, 0.1],
       [  4, 357,   1, 2]])

我正在尝试从Web上获取JPEG图像资源，将其转换为NumPy数组图像表示形式，类似于由返回的数组scipy.misc.imread。而不是将映像保存到磁盘，如以下示例所示：

import requests
from scipy import misc
def load_image(url):
    res = requests.get(url) 
    if res == 200 and 'jpeg' in res.headers['content-type']: 
        with open('image.jpg', 'wb') as fp: 
            for chunk in res: 
                fp.write(chunk)
        img_arr = misc.imread('image.jpg') 
        return img_arr
    else: 
        return None

我想将图像直接加载到内存中。有办法吗？

我有一个数据帧与> 2.7mm的坐标,和一个单独的列表中〜2000坐标.我试图返回的坐标之间的最小距离每个单排相比,列表中的每个坐标.以下代码适用于小规模(具有200行的数据帧),但是当计算超过2.7MM的行时,它似乎永远运行.

from haversine import haversine

df
Latitude   Longitude
39.989    -89.980
39.923    -89.901
39.990    -89.987
39.884    -89.943
39.030    -89.931

end_coords_list = [(41.342,-90.423),(40.349,-91.394),(38.928,-89.323)]

for row in df.itertuples():
    def min_distance(row):
        beg_coord = (row.Latitude, row.Longitude)
        return min(haversine(beg_coord, end_coord) for end_coord in end_coords_list)
    df['Min_Distance'] = df.apply(min_distance, axis=1)

我知道问题在于发生的大量计算(5.7MM*2,000 = ~11.4BN),并且运行这么多循环的事实非常低效.

根据我的研究,似乎矢量化NumPy函数可能是更好的方法,但我是Python和NumPy的新手,所以我不太确定如何在这种特殊情况下实现它.

理想输出:

df
Latitude   Longitude  Min_Distance
39.989    -89.980     3.7
39.923    -89.901     4.1
39.990    -89.987     4.2
39.884    -89.943     5.9
39.030    -89.931     3.1

提前致谢!