小编ele*_*ora的帖子

考虑m乘n矩阵M,其所有条目都是0或1.对于给定的M,问题是是否存在非零向量v,其所有条目都是-1,0或1,其中Mv = 0.例如,

      [0 1 1 1]
M_1 = [1 0 1 1]
      [1 1 0 1]

在这个例子中,没有这样的向量v.

      [1 0 0 0]
M_2 = [0 1 0 0]
      [0 0 1 0]

在此示例中,向量(0,0,0,1)给出M_2v = 0.

给定m和n,我想找到是否存在这样的M,使得不存在非零v,使得Mv = 0.

如果m = 3和n = 4那么答案是肯定的,因为我们可以在上面看到.

我目前通过尝试所有不同的M和v来解决这个问题,这是非常昂贵的.

但是,是否可以将问题表达为整数编程问题或约束编程问题,因此我可以使用现有的软件包,例如SCIP,这可能更有效.

我的问题很简单:

"复杂浮动"和"浮动复杂"都是有效的C吗？

似乎两者都没有被gcc警告接受.

我有十亿个特征向量,我想把它们放到近似的簇中.以http://scikit-learn.org/stable/modules/clustering.html#clustering中的方法为例,我对它的运行时间如何与数据大小进行比较并不清楚(Affinity Propagation除外)显然太慢了).

哪些方法适合聚类这么大的数据集？我假设任何方法都必须在O(n)时间内运行.

在numpy中我想制作一个2d arrray(r,by 2**r),其中列都是可能的二进制列.

例如,如果列的高度为5,则列将为

[0,0,0,0,0],  [0,0,0,0,1], [0,0,0,1,0], [0,0,0,1,1], [0,0,1,0,0], ...

我的解决方案是

 np.array(list(itertools.product([0,1],repeat = c))).T

这看起来很难看.有更优雅的方式吗？

我有一个大的csv文件,其中的行看起来像

stringa,stringb
stringb,stringc
stringd,stringa

我需要转换它,以便id从0开始连续编号.在这种情况下,以下方法可行

0,1
1,2
3,0

我目前的代码如下:

import csv
names = {}
counter = 0
with open('foo.csv', 'rb') as csvfile:
     reader = csv.reader(csvfile)
     for row in reader:
         if row[0] in names:
             id1 =  row[0]
         else:
             names[row[0]] = counter
             id1 = counter
             counter += 1
         if row[1] in names:
             id2 = row[1]
         else:
             names[row[1]] = counter
             id2 = counter
             counter += 1
     print id1, id2

Python dicts遗憾地使用了大量内存,而且我的输入很大.

当输入太大而dict不适合内存时,我该怎么办？

如果有更好/更快的方法来解决这个问题,我也会感兴趣.

在scikit中,您可以计算二进制分类器的曲线下面积

roc_auc_score( Y, clf.predict_proba(X)[:,1] )

我只对假阳性率小于0.1的曲线部分感兴趣.

给定这样的阈值误报率,如何计算仅在曲线上升到阈值的部分的AUC？

以下是几个ROC曲线的示例,用于说明:

scikit learn docs展示了如何使用roc_curve

>>> import numpy as np
>>> from sklearn import metrics
>>> y = np.array([1, 1, 2, 2])
>>> scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> fpr, tpr, thresholds = metrics.roc_curve(y, scores, pos_label=2)
>>> fpr
array([ 0. ,  0.5,  0.5,  1. ])
>>> tpr
array([ 0.5,  0.5,  1. ,  1. ])
>>> thresholds
array([ 0.8 ,  0.4 ,  0.35,  0.1 ]

有没有一种简单的方法可以从这个到AUC？

似乎唯一的问题是如何计算fpr = 0.1时的tpr值,因为roc_curve并不一定能给你这个.

我想在pyspark中使用预训练的xgboost分类器,但是集群上的节点没有安装xgboost模块.我可以挑选我训练过的分类器并广播它但这还不够,因为我仍然需要在每个集群节点上加载模块.

我无法在群集节点上安装它,因为我没有root,也没有共享文件系统.

如何分发xgboost分类器以用于spark？

我有一个鸡蛋用于xgboost.可以像http://apache-spark-user-list.1001560.n3.nabble.com/Loading-Python-libraries-into-Spark-td7059.html或/sf/answers/1728069591/工作？

我有一个像

  ID_0 ID_1  ID_2
0    a    b     1
1    a    c     1
2    a    b     0
3    d    c     0
4    a    c     0
5    a    c     1

我想对 ['ID_0','ID_1'] 进行分组并生成一个新的数据帧，其中每个组的 ID_2 值的总和除以每个组中的行数。

grouped  = df.groupby(['ID_0', 'ID_1'])
print grouped.agg({'ID_2': np.sum}), "\n", grouped.size()

给

           ID_2
ID_0 ID_1
a    b        1
     c        2
d    c        0
ID_0  ID_1
a     b       2
      c       3
d     c       1
dtype: int64

如何获得 np.sum 值除以 size() 值的新数据框？

我想在我的C++代码中使用64位整数.我知道我可以#include <cstdint>然后声明uint64_t或使用unsigned long long(或等效的签名版本).

但是,似乎直到C++11并且我希望我的代码与没有完全C++ 11支持的编译器兼容,才会添加对此的支持.

在C++中支持64位整数的可移植方式是什么？

作为一个实验,我正在构建一个keras模型来逼近矩阵的行列式.然而,当我运行它时,损失在每个时代都会下降,并且验证损失会增加!例如:

8s - loss: 7573.9168 - val_loss: 21831.5428
Epoch 21/50
8s - loss: 7345.0197 - val_loss: 23594.8540
Epoch 22/50
13s - loss: 7087.7454 - val_loss: 24718.3967
Epoch 23/50
7s - loss: 6851.8714 - val_loss: 25624.8609
Epoch 24/50
6s - loss: 6637.8168 - val_loss: 26616.7835
Epoch 25/50
7s - loss: 6446.8898 - val_loss: 28856.9654
Epoch 26/50
7s - loss: 6255.7414 - val_loss: 30122.7924
Epoch 27/50
7s - loss: 6054.5280 - val_loss: 32458.5306
Epoch 28/50

这是完整的代码:

import numpy as np
import sys …