小编Cor*_*rey的帖子

我想了解Spark的OneHotEncoder默认情况下放弃最后一个类别的理性.

例如:

>>> fd = spark.createDataFrame( [(1.0, "a"), (1.5, "a"), (10.0, "b"), (3.2, "c")], ["x","c"])
>>> ss = StringIndexer(inputCol="c",outputCol="c_idx")
>>> ff = ss.fit(fd).transform(fd)
>>> ff.show()
+----+---+-----+
|   x|  c|c_idx|
+----+---+-----+
| 1.0|  a|  0.0|
| 1.5|  a|  0.0|
|10.0|  b|  1.0|
| 3.2|  c|  2.0|
+----+---+-----+

默认情况下,OneHotEncoder将删除最后一个类别:

>>> oe = OneHotEncoder(inputCol="c_idx",outputCol="c_idx_vec")
>>> fe = oe.transform(ff)
>>> fe.show()
+----+---+-----+-------------+
|   x|  c|c_idx|    c_idx_vec|
+----+---+-----+-------------+
| 1.0|  a|  0.0|(2,[0],[1.0])|
| 1.5|  a|  0.0|(2,[0],[1.0])|
|10.0|  b|  1.0|(2,[1],[1.0])|
| 3.2|  c|  2.0|    (2,[],[])|
+----+---+-----+-------------+ …

我有一个有效的谷歌邮件IMAP客户端,但它最近停止工作.我认为问题是gmail不再允许TTL用户名/密码登录,但现在需要OAuth2.0.

我想知道改变下面示例的最佳方法,以便我的扭曲IMAP客户端使用OAuth2.0进行身份验证.(如果可能的话,没有Google API包就这样做.)

使用用户名/密码登录的示例(不再有效)

class AriSBDGmailImap4Client(imap4.IMAP4Client):
    '''
    client to fetch and process SBD emails from gmail. the messages
    contained in the emails are sent to the AriSBDStationProtocol for
    this sbd modem.
    '''

    def __init__(self, contextFactory=None):
        imap4.IMAP4Client.__init__(self, contextFactory)

    @defer.inlineCallbacks
    def serverGreeting(self, caps):
        # log in
        try:
            # the line below no longer works for gmail
            yield self.login(mailuser, mailpass)
            try:
                yield self.uponAuthentication()
            except Exception as e:
                uponFail(e, "uponAuthentication")
        except Exception as e:
            uponFail(e, "logging in")

        # done. log out
        try:
            yield self.logout() …

我在C++中有一个继承自的缓冲区对象std::vector<char>.我想将此缓冲区转换为Python字符串,以便我可以通过Twisted的protocol.transport.write通过网络将其发送出去.

我想到的两种方法是:(1)创建一个字符串并用char填充它:

def scpychar(buf, n):
    s = ''
    for i in xrange(0, n):
        s += buf[i]
    return s

(2)制作一个char数组(因为我知道缓冲区有多大),填充它并将其转换为字符串

def scpyarr(buf, n):
    a = array.array('c','0'*n)
    for i in xrange(0, n):
        a[i] = buf[i]
    return a.tostring()

我原以为(1)每次s += buf[i]调用时都必须创建一个新的字符串对象,并复制旧字符串的内容.所以我期待(2)比(1)更快.但是,如果我使用timeit测试它,我发现(1)实际上大约是(2)的两倍.

我想知道是否有人可以解释为什么(1)更快？

奖励指向更有效的方式从a std::vector<char>字符串转换为Python字符串.

我惊讶地发现boost::multi_array似乎其初始元素的分配方式与std::vector. 它似乎没有用唯一的元素填充每个元素（使用其默认值或默认构造函数）。我无法找到有关此的更多信息。

有没有办法multi_array在每个元素上使用唯一的对象来填充本身？

例如，请考虑以下情况：

static int num = 0;

struct A {
   int n;
   A() : n((::num)++) {
      std::cout << "A()" << std::endl;
   }
   virtual ~A() {}

   void print() {
      std::cout << "n=" << n << std::endl;
   }
};

int main() {
   std::cout << "vector:" << std::endl;
   std::vector<A> v(3);
   for (auto x : v) {
      x.print();
   }

   std::cout << "multi:" << std::endl;
   boost::multi_array<A, 2> m(boost::extents[2][2]);
   for (auto x : m) {
      for (auto y …

这是我能想到的最简单的DataFrame.我正在使用PySpark 1.6.1.

# one row of data
rows = [ (1,   2) ]
cols = [ "a", "b" ]
df   = sqlContext.createDataFrame(rows, cols)

所以数据框完全适合内存,没有对任何文件的引用,对我来说看起来很微不足道.

然而,当我收集数据时,它使用2000个执行程序:

df.collect()

在收集期间,使用2000执行者:

[Stage 2:===================================================>(1985 + 15) / 2000]

然后是预期的输出:

[Row(a=1, b=2)]

为什么会这样？DataFrame不应该完全在驱动程序的内存中吗？

在sklearn.linear_model.LogisticRegression用于拟合训练数据集之后,我想获得训练数据集的成本函数的值和交叉验证数据集.

是否可以sklearn简单地给我最小化函数的值(在最小值)？

该函数在http://scikit-learn.org/stable/modules/linear_model.html#logistic-regression的文档中说明(取决于所选择的正则化).但我找不到如何sklearn给我这个功能的价值.

我原以为这会是什么LogisticRegression.score,但这只会返回准确性(其预测正确分类的数据点的比例).

我发现sklearn.metrics.log_loss,但当然这不是最小化的实际功能.

我有两个包含x,y值的数组,y = f(x).我想提供一个函数,它找到x的值,该值对应于y的最小或最大采样值.

在循环遍历数组中的值之前,选择适当的比较运算符的有效方法是什么？

例如,我想做类似以下的事情:

double FindExtremum(const double* x, const double* y,
                    const unsigned int n, const bool isMin) {
   static std::less<double>    lt;
   static std::greater<double> gt;
   std::binary_function<double,double,bool>& IsBeyond = isMin ? lt : gt;
   double xm(*x), ym(*y);
   for (unsigned int i=0; i<n; ++i, ++x, ++y) {
      if (IsBeyond()(*y,ym)) {
         ym = *y;
         xm = *x;
     }
   }
}

不幸的是,基类std::binary_function没有定义虚拟运算符().

像g ++ 4.8这样的编译器能够优化最直接的实现吗？

double FindExtremum(const double* x, const double* y,
                    const unsigned int n, const bool isMin) {
   double …