小编ele*_*ora的帖子

考虑这个简单的循环:

float f(float x[]) {
  float p = 1.0;
  for (int i = 0; i < 959; i++)
    p += 1;
  return p;
}

如果您使用gcc 7(快照)或clang(主干)进行编译,-march=core-avx2 -Ofast则会得到与之非常相似的内容.

.LCPI0_0:
        .long   1148190720              # float 960
f:                                      # @f
        vmovss  xmm0, dword ptr [rip + .LCPI0_0] # xmm0 = mem[0],zero,zero,zero
        ret

换句话说,它只是将答案设置为960而不进行循环.

但是,如果您将代码更改为:

float f(float x[]) {
  float p = 1.0;
  for (int i = 0; i < 960; i++)
    p += 1;
  return p;
}

生成的程序集实际执行循环求和？例如clang给出:

.LCPI0_0:
        .long   1065353216              # …

我按排序顺序有一百万个整数,我想找到连续对之间差异相等的最长子序列.例如

1, 4, 5, 7, 8, 12

有一个子序列

   4,       8, 12

我天真的方法是贪婪的,只是检查你可以从每个点扩展一个子序列的距离.这O(n²)看起来每点需要时间.

有没有更快的方法来解决这个问题？

更新.我会尽快测试答案中给出的代码(谢谢).但是很明显,使用n ^ 2内存将无法正常工作.到目前为止,没有代码以输入结束[random.randint(0,100000) for r in xrange(200000)].

计时. 我在32位系统上测试了以下输入数据.

a= [random.randint(0,10000) for r in xrange(20000)] 
a.sort()

• ZelluX的动态编程方法使用1.6G的RAM,需要2分14秒.使用pypy只需9秒!但是,它在大输入时因内存错误而崩溃.
• Armin的O(nd)时间方法用pypy花了9秒,但只有20MB的RAM.当然,如果范围更大,情况会更糟.低内存使用率意味着我也可以用一个= [random.randint(0,100000)来测试它,对于x inrange(200000)中的r,但是在我用pypy给它的几分钟内它没有完成.

为了能够测试Kluev的方法,我重申了

a= [random.randint(0,40000) for r in xrange(28000)] 
a = list(set(a))
a.sort()

粗略地列出一个长度列表20000.与pypy的所有时间

• ZelluX,9秒
• Kluev,20秒
• 阿明,52秒

似乎如果ZelluX方法可以成为线性空间,它将是明显的赢家.

我的代码是遵循谷歌的机器学习类.两个代码是相同的.我不知道为什么它显示错误.可能是变量的类型是错误.但谷歌的代码对我来说是相同的.谁有过这个问题？

这是错误的

[0 1 2]
[0 1 2]
Traceback (most recent call last):
  File "/media/joyce/oreo/python/machine_learn/VisualizingADecisionTree.py", line 34, in <module>
    graph.write_pdf("iris.pdf")
AttributeError: 'list' object has no attribute 'write_pdf'
[Finished in 0.4s with exit code 1]
[shell_cmd: python -u "/media/joyce/oreo/python/machine_learn/VisualizingADecisionTree.py"]
[dir: /media/joyce/oreo/python/machine_learn]
[path: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games]

这是代码

import numpy as np
from sklearn.datasets import load_iris
from sklearn import tree

iris = load_iris()
test_idx = [0, 50, 100]

# training data
train_target = np.delete(iris.target, test_idx)
train_data = np.delete(iris.data, test_idx, axis=0)

# testing data
test_target = …

几周前,Lembik 提出以下问题:

p字符串的句点w是任何正整数p,以便w[i]=w[i+p] 每当定义该等式的两侧时.让我们来per(w)表示最小周期的大小w.我们说字符串w是周期性的iff per(w) <= |w|/2.

因此,非正式地,周期性字符串只是一个字符串,由至少重复一次的另一个字符串组成.唯一的复杂因素是,在字符串的末尾,我们不需要重复字符串的完整副本,只要它至少重复一次即可.

例如,考虑字符串x = abcab.per(abcab) = 3as x[1] = x[1+3] = a,x[2]=x[2+3] = b并没有更小的时期.abcab因此,字符串不是周期性的.但是,字符串ababa是周期性的per(ababa) = 2.

随着越来越多的例子abcabca,ababababa并且abcabcabc也是周期性的.

对于那些喜欢正则表达式的人,这个检测字符串是否是周期性的:

\b(\w*)(\w+\1)\2+\b

任务是在较长的字符串中查找所有最大周期性子串.这些有时被称为文献中的运行.

子串w[i,j]的w是一个极大的周期性子(运行),如果它是周期性的,并且既不w[i-1] = w[i-1+p]也不w[j+1] = w[j+1-p].非正式地,"运行"不能包含在具有相同周期的较大"运行"中.

因为两个运行可以表示在整个字符串中的不同位置出现的相同字符串,所以我们将按间隔表示运行.以下是以间隔重复的上述定义.

在字符串中运行(或最大周期性子串)T是时间间隔 [i...j] …

我想编写快速的simd代码来计算复杂数组的乘法减少.在标准C中,这是:

#include <complex.h>
complex float f(complex float x[], int n ) {
   complex float p = 1.0;
   for (int i = 0; i < n; i++)
      p *= x[i];
   return p;
}

n 将最多50.

Gcc不能自动矢量化复数乘法但是,因为我很乐意假设gcc编译器,如果我知道我想要定位sse3,我可以按照如何在gcc中启用sse3自动向量化并写入:

typedef float v4sf __attribute__ ((vector_size (16)));
typedef union {
  v4sf v;
  float e[4];
} float4
typedef struct {
  float4 x;
  float4 y;
} complex4;
static complex4 complex4_mul(complex4 a, complex4 b) {
  return (complex4){a.x.v*b.x.v -a.y.v*b.y.v, a.y.v*b.x.v + a.x.v*b.y.v};
}
complex4 f4(complex4 x[], int n) …

我正在尝试编写代码来检测矩阵是否是Hankel矩阵的排列,但除了非常慢的暴力之外我无法想到有效的解决方案.这是规格.

输入: n×n矩阵M,其条目为1或0.

输入格式:空格分隔的行.每行一行.例如

0 1 1 1
0 1 0 1
0 1 0 0
1 0 1 1

输出: M的行和列的排列,如果可能,则M是Hankel矩阵.Hankel矩阵具有恒定的倾斜对角线(正倾斜对角线).

当我说排列时,我的意思是我们可以将一个排列应用于行的顺序,并将一个可能不同的排列应用于列.

我会非常感谢任何想法.

我有一些简单的代码,可以执行以下操作.

它F使用+ -1条目迭代所有可能的长度n列表.对于每一个,它使用+ -1条目迭代所有可能的长度2n列表S,其中$ S $的前半部分只是下半部分的副本.代码计算F每个S长度子列表的内积n.对于每个F,S,它计算在第一个非零内积之前为零的内积.

这是代码.

#!/usr/bin/python

from __future__ import division
import itertools
import operator
import math

n=14
m=n+1
def innerproduct(A, B):
    assert (len(A) == len(B))
    s = 0 
    for k in xrange(0,n):
        s+=A[k]*B[k]
    return s

leadingzerocounts = [0]*m
for S in itertools.product([-1,1], repeat = n):
    S1 = S + S
    for F in itertools.product([-1,1], repeat = n):
        i = 0
        while (i<m):
            ip = innerproduct(F, S1[i:i+n]) …

我有4个类的数据,我正在尝试构建一个分类器.我有一个类的〜1000个向量,另一个有~10 ^ 4,第三个为~10 ^ 5,第四个为~10 ^ 6.我希望使用交叉验证,所以我查看了scikit-learn文档.

我的第一次尝试是使用StratifiedShuffleSplit但是这给了每个类相同的百分比,使得类仍然严重失衡.

有没有办法进行交叉验证,但是在训练和测试集中平衡了类？

作为旁注,我无法弄清楚StratifiedShuffleSplit和StratifiedKFold之间的区别.描述与我非常相似.

考虑这个简单的代码:

#include <complex.h>
complex float f(complex float x) {
  return x*x;
}

如果-O3 -march=core-avx2 -fp-model strict使用英特尔编译器进行编译,则可以获得:

f:
        vmovsldup xmm1, xmm0                                    #3.12
        vmovshdup xmm2, xmm0                                    #3.12
        vshufps   xmm3, xmm0, xmm0, 177                         #3.12
        vmulps    xmm4, xmm1, xmm0                              #3.12
        vmulps    xmm5, xmm2, xmm3                              #3.12
        vaddsubps xmm0, xmm4, xmm5                              #3.12
        ret 

这比从两者中获得的代码简单得多gcc,clang而且比在线复制数字的代码简单得多.例如,它没有明确地用于处理复杂的NaN或无穷大.

这个组件是否符合C99复数乘法的规范？

我使用以下代码在3d中绘制通过原点的随机平面.

from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

#Number of hyperplanes
n = 20
#Dimension of space
d = 3

plt3d = plt.figure().gca(projection='3d')
for i in xrange(n):
    #Create random point on unit sphere
    v = np.random.normal(size = d)
    v = v/np.sqrt(np.sum(v**2))
    # create x,y
    xx, yy = np.meshgrid(range(-5,5), range(-5,5))
    z = (-v[0] * xx - v[1] * yy)/v[2]
    # plot the surface
    plt3d.plot_surface(xx, yy, z, alpha = 0.5)
plt.show()

但看看图片我不相信他们是统一选择的.我究竟做错了什么？