有没有办法使用属性((对齐))强制STL容器对齐到特定字节？目标编译器不是Microsoft Visual C++.
哪些库(如果有的话)提供具有特定显式向量化的STL算法的专用模板,例如SSE.我感兴趣的编译器是g ++,Intel和IBM XL.
我在一组42000张图像上实现了一个称为TF-IDF的加权系统,每个图像包含784个像素.这基本上是42000乘784矩阵.
我尝试的第一种方法是使用显式循环并花费了超过2个小时.
def tfidf(color,img_pix,img_total):
if img_pix==0:
return 0
else:
return color * np.log(img_total/img_pix)
...
result = np.array([])
for img_vec in data_matrix:
double_vec = zip(img_vec,img_pix_vec)
result_row = np.array([tfidf(x[0],x[1],img_total) for x in double_vec])
try:
result = np.vstack((result,result_row))
# first row will throw a ValueError since vstack accepts rows of same len
except ValueError:
result = result_row
我试图使用numpy矩阵的第二种方法花了不到5分钟.请注意,data_matrix,img_pix_mat都是42000 x 784矩阵,而img_total是标量.
result = data_matrix * np.log(np.divide(img_total,img_pix_mat))
我希望有人能解释速度上的巨大差异.
题为"NumPy数组:高效数值计算结构"(http://arxiv.org/pdf/1102.1523.pdf)的以下论文的作者在第4页的最上面指出,他们观察到500倍的速度提升由于矢量化计算.我假设我看到的速度增加很多是由于这个原因.但是,我想更进一步,问为什么numpy矢量化计算比标准python循环快得多？
另外,也许你们可能知道为什么第一种方法很慢的其他原因.尝试/除结构有高开销吗？或者为每个循环形成一个新的np.array需要很长时间？
谢谢.
我有这个代码用于逻辑回归的成本,在matlab中:
function [J, grad] = costFunction(theta, X, y)
m = length(y); % number of training examples
thetas = size(theta,1);
features = size(X,2);
steps = 100;
alpha = 0.1;
J = 0;
grad = zeros(size(theta));
sums = [];
result = 0;
for i=1:m
% sums = [sums; (y(i))*log10(sigmoid(X(i,:)*theta))+(1-y(i))*log10(1-sigmoid(X(i,:)*theta))]
sums = [sums; -y(i)*log(sigmoid(theta'*X(i,:)'))-(1-y(i))*log(1-sigmoid(theta'*X(i,:)'))];
%use log simple not log10, mistake
end
result = sum(sums);
J = (1/m)* result;
%gradient one step
tempo = [];
thetas_update = 0;
temp_thetas = [];
grad = temp_thetas; …以下是执行相同操作的自由函数,但在第一种情况下,循环不是矢量化的,但在其他情况下它是.这是为什么？
#include <vector>
typedef std::vector<double> Vec;
void update(Vec& a, const Vec& b, double gamma) {
const size_t K = a.size();
for (size_t i = 0; i < K; ++i) { // not vectorized
a[i] = b[i] * gamma - a[i];
}
}
void update2(Vec& a, const Vec& b, double gamma) {
for (size_t i = 0; i < a.size(); ++i) { // vectorized
a[i] = b[i] * gamma - a[i];
}
}
void update3(Vec& a, size_t K, const Vec& b, …在R中给出这样的数据帧:
+---+---+
| X | Y |
+---+---+
| 1 | 2 |
| 2 | 4 |
| 4 | 5 |
+---+---+
如果对此数据帧执行矢量化操作,如下所示:
data$Z <- data$X * data$Y
这会利用处理器的单指令多数据(SIMD)功能来优化性能吗？这似乎是一个完美的案例,但我找不到任何证实我的预感的东西.
我有一个排名函数,我应用于数百万行的大量列,需要几分钟才能运行.通过删除准备数据以应用该.rank(方法的所有逻辑,即通过这样做:
ranked = df[['period_id', 'sector_name'] + to_rank].groupby(['period_id', 'sector_name']).transform(lambda x: (x.rank(ascending = True) - 1)*100/len(x))
我设法把它降到了几秒钟.但是,我需要保留我的逻辑,并且正在努力重构我的代码:最终,最大的瓶颈是我对lambda x:的双重使用,但显然其他方面正在减慢速度(见下文).我提供了一个示例数据框,以及下面的排名函数,即MCVE.从广义上讲,我认为我的问题归结为:
(i)如何.apply(lambda x用快速的矢量化等价替换代码中的用法？(ii)如何循环多索引,分组,数据帧并应用函数？就我而言,对于date_id和category列的每个唯一组合.
(iii)我还能做些什么来加快我的排名逻辑？主要的开销似乎是在.value_counts().这与上面的(i)重叠; 也许在发送排名之前,可以通过构建临时列来在df上完成大部分逻辑操作.同样,可以在一次调用中对子数据帧进行排名吗？
(iv)为什么要使用pd.qcut()而不是df.rank()？后者是cython化的,似乎有更灵活的关系处理,但我看不出两者之间的比较,pd.qcut()似乎最广泛使用.
样本输入数据如下:
import pandas as pd
import numpy as np
import random
to_rank = ['var_1', 'var_2', 'var_3']
df = pd.DataFrame({'var_1' : np.random.randn(1000), 'var_2' : np.random.randn(1000), 'var_3' : np.random.randn(1000)})
df['date_id'] = np.random.choice(range(2001, 2012), df.shape[0])
df['category'] = ','.join(chr(random.randrange(97, 97 + 4 + 1)).upper() for x in range(1,df.shape[0]+1)).split(',')
这两个排名功能是:
def rank_fun(df, …是否有任何pythonic方法删除for循环和if/else在下面的代码中.
此代码迭代NumPy数组并检查条件并根据条件更改值.
>>> import numpy as np
>>> x=np.random.randint(100, size=(10,5))
>>> x
array([[79, 50, 18, 55, 35],
[46, 71, 46, 95, 52],
[97, 37, 71, 2, 79],
[80, 96, 60, 85, 72],
[ 6, 52, 63, 86, 38],
[35, 50, 13, 93, 54],
[69, 21, 4, 40, 53],
[83, 7, 30, 16, 78],
[18, 34, 91, 67, 89],
[82, 16, 16, 24, 80]])
>>> for i in range(x.shape[0]):
for j in range(x.shape[1]):
if x[i,j]>50:
x[i,j]=0
elif x[i,j]<50:
x[i,j]=1
>>> x …考虑以下数据框
x y z
1 0 0 0
2 1 0 0
3 0 1 0
4 1 1 0
5 0 0 1
6 1 0 1
7 0 1 1
8 1 1 1
-------
x 4 2 1 <--- vector to multiply by
我想将每一列乘以一个单独的值，例如 c(4,2,1)。给予：
x y z
1 0 0 0
2 4 0 0
3 0 2 0
4 4 2 0
5 0 0 1
6 4 0 1
7 0 2 1
8 …我在这做错了什么？我试图用透明的灰色遮蔽每天24小时交替的矩形.但只有for循环中的最后一个矩形被绘制(？!？)如果我手动而不是for-循环,它可以正常工作.
有没有办法对此进行矢量化以避免for循环？(可以用qplot来完成吗？)我是ggplot2的新手,是的,我通读了Hadley的网站,书籍和例子.
第二个问题:美学上的阿尔法设置并不能阻止矩形遮挡背景.如何获得透明度？
dat <- data.frame(my_x_series=1:192, my_y_series=5.0*runif(192))
# (ymin, ymax are computed for this series using min/max(na.rm==TRUE))
ymax <- 5.0
ymin <- 0.0
p <- ggplot(dat, aes(x=my_x_series,alpha=0.9))
alternate_daily_bars_xmin <- c(4,52,100,148)
for (shade_xmin in alternate_daily_bars_xmin) {
shade_xmax <- min(shade_xmin+24, 192) # clamp at end of x-range
p <- p + geom_rect(aes(alpha=0.5,xmin=shade_xmin,xmax=shade_xmax,ymin=ymin,ymax=ymax), fill='gray80')
}
p <- p + geom_point(aes(y=my_y_series))
p
numpy.random.choice 允许从矢量加权选择,即
arr = numpy.array([1, 2, 3])
weights = numpy.array([0.2, 0.5, 0.3])
choice = numpy.random.choice(arr, p=weights)
选择1概率为0.2,2选择概率为0.5,3选择概率为0.3.
如果我们想以矢量化的方式快速完成2D阵列(矩阵),每个行都是概率矢量,该怎么办？也就是说,我们想要一个随机矩阵的选择向量？这是超级慢的方式:
import numpy as np
m = 10
n = 100 # Or some very large number
items = np.arange(m)
prob_weights = np.random.rand(m, n)
prob_matrix = prob_weights / prob_weights.sum(axis=0, keepdims=True)
choices = np.zeros((n,))
# This is slow, because of the loop in Python
for i in range(n):
choices[i] = np.random.choice(items, p=prob_matrix[:,i])
print(choices):
array([ 4., 7., 8., 1., 0., 4., 3., 7., 1., …