1. 特征的来源

你可能还喜欢下面这些文章

一、any容器是什么？1、any“不是”模板类，any是一种很特殊的容器。2、any只能容纳一个元素，但这个元素可以是任意的类型，可以是基本数据类型（int、double、string、标准容器或者任何自定义类型）。3、一种动态（类型检查只发生在运行时）语言特性的数据结构。4、C++17引入，需要RIIT支持，VS默认是没有支持C++17的，需要自己修改设置，如果不能使用any，请修改标准。二、any类摘要class any{public: any(); //默认构造 any(const any& _That); //拷贝构造 template<class _ValueType&

一个将网页里面的(图片，链接地址)相对路径转化为绝对路径的php实现方法

shell中的if语法是最让我头疼的语法之一，它的判断就向使用USB插头一样——拿起来插入不行，翻转再插入还不行，再翻转插入行了！为了搞清楚这部分语言，我收集了一些文章关于if条件判断的用法，希望对你也有些帮助。一、基本语法if [ command ]; then 符合该条件执行的语句fiif [ command ];then 符合该条件执行的语句elif [ command ];then 符合该条件执行的语句else 符合该条件执行的语句fi语法说明bash shell会按顺序执行if语句，如果command执行后且它的返回状态是0，则会执行符合该条件执行的语

c语言的位操作

一、基本位操作|或&与~取反^异或<<左移>>右移二、位操作的常见用法1.获取某位的值#define BitGet(Number,pos) ((Number)|= 1<<(pos)) //把某位置1#define BitGet(Number,pos) ((Number) &= ~(1<<(pos)) //把某位置0#define BitGet(Number,pos) ((Number) >> (pos)&1)) //用宏得到某数的某位#define BitGet(Number,pos) ((Number) ^=

基于信息熵原理分词的php实现

基于信息熵原理分词这个概念很早了，用php实现了个，一气呵成，代码自然是，反正我也没有二次检查，呵呵。不过耗费内存是真的，真的很消耗内存！写这个的好处就是我明白了很多东西…代码如下<?php/** * 基于信息熵的无词典分词*/class partword{ /** * 词语最大长度 */ public $maxwordlen = 5; /** * 需要进行分词的文字 */ public $text; /** * 字符串长度 */ private $len; /** * 切分的单个文字

抓取网页的时候有时候会需要下载里面的图片或者其他附件，但有的网页里面用的是相对路径，这时候就要转化为绝对路径。 /*** url补全，相对url转化为绝对url* 作用是补全url*/function url2abs($srcurl,$baseurl){ $srcinfo = parse_url($srcurl); //print_r($srcinfo); if(isset($srcinfo[‘scheme’])) { return $srcurl; } $baseinfo = parse_url($baseurl); $url = $baseinfo[‘sc

GDB入门：使用bt查看程序出core的调用栈

当程序崩溃的时候，会产生一个core文件。我们可以称它为进程死亡现场。排查进程死亡就和破案一样，找到案发现场，仔细排查每个细节，抽丝剥茧，最终定位原因。

很幸运我们有一个强大的工具调查现场信息。这个工具就是GDB。

下面我们就来看看如何用GDB排查问题。

首先以一个越界访问数组的程序为例，如下：

#include 
#include 

void core() {
    std::vector<int> a;
    std::cout << a[0];
}
int main() {
    core();
    return 0;
}

执行上面的代码将会产生一个core文件。（更多…）

你可能还喜欢下面这些文章

std::endl为什么导致程序变慢

最近在写hadoop的streaming任务，在输出的时候用了std::endl，就像下面这样：os << “content” << std::endl运行后发现程序跑的比python还慢，令人费解。我入门C++的时候，输出hello world也是这样写的，有什么问题？于是查了一下std::endl，发现问题挺大。std::endl解释如下：Inserts a new-line character and flushes the stream.Its behavior is equivalent to calling os.put(‘\n’) (or os.put(o

C++入门：三、函数

这是我学习C++的第三篇笔记，函数。我的学习路径是1. 变量和数据类型2. 流程控制3. 函数4. 面向对象5. 标准库现在学习的是函数的声明、定义、调用等相关知识。函数声明和定义函数的声明包含返回类型，函数名字，0个或者多个形参，无函数体，通常在头文件中对函数进行声明。返回类型函数名称(参数类型1 参数1, 参数类型2 参数2);// 例如声明一个求阶乘的函数int fact(int val);函数的定义包含返回类型，函数名字，0个或多个形参，以及函数体。返回类型函数名称(参数类型1 参数1, 参数类型2 参数2) { 函数体}比如写一个求阶乘的函数，可以写成下面这样int fac

记一次进程异常退出的问题排查

机器搬家之后，之前一直稳定的PHP多进程程序子进程突然异常退出，但是退出的不是很频繁，查看进程日志并也没有发现有什么导致退出的，问题比较诡异。于是开启了一段问题排查之路。首先查看内核日志，使用dmesg，拉到最后发现有一些这样的错误，看来确实是崩溃了。[4791991.998535] php[16776]: segfault at 7f6443ee18c8 ip 00007f6443ee18c8 sp 00007fff4d4ba818 error 15 in libc-2.17.so[7f6443ee1000+2000][4792165.192628] php[609]: segfault a

如何选择特征

特征工程是数据分析中最耗时间和精力的一部分工作，它不像算法和模型那样是确定的步骤，更多是工程上的经验和权衡。因此没有统一的方法。这里只是对一些常用的方法做一个总结。本文关注于特征选择部分。后面还有两篇会关注于特征表达和特征预处理。

1. 特征的来源

在做数据分析的时候，特征的来源一般有两块，一块是业务已经整理好各种特征数据，我们需要去找出适合我们问题需要的特征；另一块是我们从业务特征中自己去寻找高级数据特征。我们就针对这两部分来分别讨论。

2. 选择合适的特征

我们首先看当业务已经整理好各种特征数据时，我们如何去找出适合我们问题需要的特征，此时特征数可能成百上千，哪些才是我们需要的呢？

第一步是找到该领域懂业务的专家，让他们给一些建议。比如我们需要解决一个药品疗效的分类问题，那么先找到领域专家，向他们咨询哪些因素（特征）会对该药品的疗效产生影响，较大影响的和较小影响的都要。这些特征就是我们的特征的第一候选集。

这个特征集合有时候也可能很大，在尝试降维之前，我们有必要用特征工程的方法去选择出较重要的特征结合，这些方法不会用到领域知识，而仅仅是统计学的方法。

最简单的方法就是方差筛选。方差越大的特征，那么我们可以认为它是比较有用的。如果方差较小，比如小于1，那么这个特征可能对我们的算法作用没有那么大。最极端的，如果某个特征方差为0，即所有的样本该特征的取值都是一样的，那么它对我们的模型训练没有任何作用，可以直接舍弃。在实际应用中，我们会指定一个方差的阈值，当方差小于这个阈值的特征会被我们筛掉。sklearn中的VarianceThreshold类可以很方便的完成这个工作。

特征选择方法有很多，一般分为三类：第一类过滤法比较简单，它按照特征的发散性或者相关性指标对各个特征进行评分，设定评分阈值或者待选择阈值的个数，选择合适特征。上面我们提到的方差筛选就是过滤法的一种。第二类是包装法，根据目标函数，通常是预测效果评分，每次选择部分特征，或者排除部分特征。第三类嵌入法则稍微复杂一点，它先使用某些机器学习的算法和模型进行训练，得到各个特征的权值系数，根据权值系数从大到小来选择特征。类似于过滤法，但是它是通过机器学习训练来确定特征的优劣，而不是直接从特征的一些统计学指标来确定特征的优劣。下面我们分别来看看3类方法。

2.1 过滤法选择特征

上面我们已经讲到了使用特征方差来过滤选择特征的过程。除了特征的方差这第一种方法，还有其他一些统计学指标可以使用。

第二个可以使用的是相关系数。这个主要用于输出连续值的监督学习算法中。我们分别计算所有训练集中各个特征与输出值之间的相关系数，设定一个阈值，选择相关系数较大的部分特征。

第三个可以使用的是假设检验，比如卡方检验。卡方检验可以检验某个特征分布和输出值分布之间的相关性。个人觉得它比比粗暴的方差法好用。如果大家对卡方检验不熟悉，可以参看这篇卡方检验原理及应用，这里就不展开了。在sklearn中，可以使用chi2这个类来做卡方检验得到所有特征的卡方值与显著性水平P临界值，我们可以给定卡方值阈值，选择卡方值较大的部分特征。

除了卡方检验，我们还可以使用F检验和t检验，它们都是使用假设检验的方法，只是使用的统计分布不是卡方分布，而是F分布和t分布而已。在sklearn中，有F检验的函数f_classif和f_regression，分别在分类和回归特征选择时使用。

第四个是互信息，即从信息熵的角度分析各个特征和输出值之间的关系评分。在决策树算法中我们讲到过互信息（信息增益）。互信息值越大，说明该特征和输出值之间的相关性越大，越需要保留。在sklearn中，可以使用mutual_info_classif(分类)和mutual_info_regression(回归)来计算各个输入特征和输出值之间的互信息。

以上就是过滤法的主要方法，个人经验是，在没有什么思路的时候，可以优先使用卡方检验和互信息来做特征选择

2.2 包装法选择特征

包装法的解决思路没有过滤法这么直接，它会选择一个目标函数来一步步的筛选特征。

最常用的包装法是递归消除特征法(recursive feature elimination,以下简称RFE)。递归消除特征法使用一个机器学习模型来进行多轮训练，每轮训练后，消除若干权值系数的对应的特征，再基于新的特征集进行下一轮训练。在sklearn中，可以使用RFE函数来选择特征。

我们下面以经典的SVM-RFE算法来讨论这个特征选择的思路。这个算法以支持向量机来做RFE的机器学习模型选择特征。它在第一轮训练的时候，会选择所有的特征来训练，得到了分类的超平面$w \dot x+b=0$后，如果有n个特征，那么RFE-SVM会选择出$w$中分量的平方值$w_i^2$最小的那个序号i对应的特征，将其排除，在第二类的时候，特征数就剩下n-1个了，我们继续用这n-1个特征和输出值来训练SVM，同样的，去掉$w_i^2$最小的那个序号i对应的特征。以此类推，直到剩下的特征数满足我们的需求为止。

2.3 嵌入法选择特征

嵌入法也是用机器学习的方法来选择特征，但是它和RFE的区别是它不是通过不停的筛掉特征来进行训练，而是使用的都是特征全集。在sklearn中，使用SelectFromModel函数来选择特征。

最常用的是使用L1正则化和L2正则化来选择特征。在之前讲到的用scikit-learn和pandas学习Ridge回归第6节中，我们讲到正则化惩罚项越大，那么模型的系数就会越小。当正则化惩罚项大到一定的程度的时候，部分特征系数会变成0，当正则化惩罚项继续增大到一定程度时，所有的特征系数都会趋于0. 但是我们会发现一部分特征系数会更容易先变成0，这部分系数就是可以筛掉的。也就是说，我们选择特征系数较大的特征。常用的L1正则化和L2正则化来选择特征的基学习器是逻辑回归。

此外也可以使用决策树或者GBDT。那么是不是所有的机器学习方法都可以作为嵌入法的基学习器呢？也不是，一般来说，可以得到特征系数coef或者可以得到特征重要度(feature importances)的算法才可以做为嵌入法的基学习器。

3. 寻找高级特征

在我们拿到已有的特征后，我们还可以根据需要寻找到更多的高级特征。比如有车的路程特征和时间间隔特征，我们就可以得到车的平均速度这个二级特征。根据车的速度特征，我们就可以得到车的加速度这个三级特征，根据车的加速度特征，我们就可以得到车的加加速度这个四级特征。。。也就是说，高级特征可以一直寻找下去。

在Kaggle之类的算法竞赛中，高分团队主要使用的方法除了集成学习算法，剩下的主要就是在高级特征上面做文章。所以寻找高级特征是模型优化的必要步骤之一。当然，在第一次建立模型的时候，我们可以先不寻找高级特征，得到以后基准模型后，再寻找高级特征进行优化。

寻找高级特征最常用的方法有：

若干项特征加和：我们假设你希望根据每日销售额得到一周销售额的特征。你可以将最近的7天的销售额相加得到。
若干项特征之差：假设你已经拥有每周销售额以及每月销售额两项特征，可以求一周前一月内的销售额。
若干项特征乘积：假设你有商品价格和商品销量的特征，那么就可以得到销售额的特征。
若干项特征除商：假设你有每个用户的销售额和购买的商品件数，那么就是得到该用户平均每件商品的销售额。

当然，寻找高级特征的方法远不止于此，它需要你根据你的业务和模型需要而得，而不是随便的两两组合形成高级特征，这样容易导致特征爆炸，反而没有办法得到较好的模型。个人经验是，聚类的时候高级特征尽量少一点，分类回归的时候高级特征适度的多一点。

4. 特征选择小结

特征选择是特征工程的第一步，它关系到我们机器学习算法的上限。因此原则是尽量不错过一个可能有用的特征，但是也不滥用太多的特征。

不错的文章，原文地址：https://www.cnblogs.com/pinard/p/9032759.html

并发任务分配问题

这是在工作中遇到的实际问题和解决过程。问题已经被抽象成并发任务的分配问题。

问题

如果有 n 组数据均分给 m 个处理器处理，那么每个处理器分到的数据是 $\lceil \frac{n}{m} \rceil$ 。如果n组数据的类型有差异，其中有a组是一类数据，剩余 n-a 组是另一类数据。只有同类数据才能被一次性处理，那么该如何分配？

这个问题在现实中是存在的。比如HTTP并发请求处理一些数据。数据被批量送来，但类型不一样。为了节省耗时，我们希望并发处理这些不同的数据。并发数是确定好的。现在需要计算每个请求处理的数量，以便我们能给每一个请求打包数据。

求解

n 组数据交给 m 个处理器处理，每个处理器最多分到 $\lceil \frac{n}{m} \rceil$ 组数据，这是毫无疑问的。如果 n 组数据中有a组是一类数据，n-a组是另一类数据。同类数据必须分配到同一个处理器。那么a类数据得到的处理器的数量是 $\lceil \frac {a} {\lceil \frac{n}{m} \rceil} \rceil $，b类得到的处理器的数量是 $\lceil \frac {n-a} {\lceil \frac{n}{m} \rceil} \rceil $。我们现在其实需要考虑它们总共需要的处理器数量和m的关系。原有的m个处理器是否满足这种需求？如果不满足，需要多少个处理器才能满足？

即，求 $( \lceil \frac {a}{\lceil \frac{n}{m} \rceil} \rceil +\lceil \frac {n-a} {\lceil \frac{n}{m} \rceil} \rceil ) $ 和 m的关系。

对于上面的问题，我们的存在一些已知的前提条件：

m, m 为正整数
$n \leq m$

根据上面已知的条件，我们可以得出一些引理：

$\lceil \frac {n}{m} \rceil \geq \frac {n}{m} $
$ \lceil \frac {n}{m} \rceil \leq \frac {n}{m} + \frac {m-1}{m} $

因此，容易得出$( \lceil \frac {a}{\lceil \frac{n}{m} \rceil} \rceil +\lceil \frac {n-a} {\lceil \frac{n}{m} \rceil} \rceil ) \geq \lceil \frac {n}{\lceil \frac {n}{m} \rceil} \rceil \geq m $

即数据类型分成两种的时候所需要的处理器数量是大于等于m的，原先的处理器个数可能不够用了。那么多少才够用？这是现在需要考虑的问题。

容易得出，$ ( \lceil \frac {a}{\lceil \frac{n}{m} \rceil} \rceil +\lceil \frac {n-a} {\lceil \frac{n}{m} \rceil} \rceil ) \leq \lceil \frac {am}{n}\rceil + \lceil \frac {(n-a)m} {n} \rceil $

根据上面的引理可以得出 $ \lceil \frac {am}{n}\rceil + \lceil \frac {(n-a)m} {n} \rceil \leq \frac {am}{n} + \frac {n-1}{n} + \frac {(n-a)m} {n} + \frac {n-1}{n} = n+2-\frac{2}{n} $

由已知条件可以知道，$ ( \lceil \frac {a}{\lceil \frac{n}{m} \rceil} \rceil +\lceil \frac {n-a} {\lceil \frac{n}{m} \rceil} \rceil )$ 是正整数，因此可以将 $ n+2-\frac{2}{n} $向下取整为$n+1$。

即需要n+1个处理器才能满足要求。

因此遇到这种问题的时候，要么增加一个处理器，要么计算每个处理器能处理的数量的时候在原先处理器数量减一的基础上计算。

为什么C++模板不支持分离式编译

前言

最近编译C++代码时出现链接失败信息，类似下图：

初见这个错误有些令人费解，不过经过一番分析，发现原因还是清晰的，和大家一起分享一下。

图一中使用的tpl.h代码如下：

#pragma once

template <typename T>
int compare(const T& a, const T& b);

tpl.cpp代码如下：

#include "tpl.h"
#include <iostream>

template <typename T>
int compare(const T& a, const T& b) {
    if (a == b) {
        return 0;
    }
    return (a > b) ? 1 : -1;
}

main.cpp代码如下：

#include <iostream>
#include "tpl.h"

int main() {
    int res = compare<int> (1, 2);
    std::cout << res << std::endl;
}

我一直习惯把模板实现写在头文件中，因此从未遇见这种错误。这次偶然将模板声明和实现分离，出现了链接错误。这引发了我一些思考，为什么模板不支持分离式编译？

模板的编译

为了搞清楚模板是怎么编译的，这里以上述tpl.cpp中的compare模板函数为例。tpl.h中声明了一个模板函数并且在tpl.cpp中实现这个模板函数。现在我们编译tpl.cpp，生成的汇编代码如下：

可以看出，一个模板如果没有被调用的时候，编译器不会对这部分代码做任何处理，一行指令都没有。实际上编译器也不知道要怎么处理这个模板。在没有调用之前，模板的参数类型是不确定的。

假如我们在tpl.cpp中增加调用compare的函数的test函数，如下：

int test() {
    int res = compare<int> (1, 2);
    std::cout << res << std::endl;
    return res;
}

再编译tpl.cpp就会发现，生成的汇编文件里面已经有了以int为参数的compare函数了，如下图：

链接错误问题分析

那么图一中的链接错误是怎么发生的？我们执行了g++ tpl.cpp main.cpp这个命令，大致会经过下面这三个步骤：

编译并且汇编tpl.cpp，生成tpl.o目标文件。
编译并且汇编main.cpp，生成main.o目标文件。
链接tpl.o和main.o生成可执行文件。

编译tpl.cpp已经分析过了，由于没有调用模板函数，因此编译器不会对模板做任何处理。实际上编译器根本不知道要怎么处理，因为模板里面的类型是不确定的。只有在调用的时候才会确定下来，这个时候编译器才知道这个函数长什么样，才会执行编译操作。

编译main.cpp的时候，由于模板compare已经声明但未实现，因此这里也不会生成具体代码，只会生成一个call指令。很显然这个call指令中的函数地址现在肯定是错误的，头文件tpl.h并没有去实现这个函数，需要依赖链接器将这个地址修改成正确的地址。

问题就出在编译tpl.cpp的时候模板没有实例化，编译器并没有编译这个函数，因此找在符号表中找不到这个函数的地址，链接器不知道要怎么处理，因此会出现链接错误。

如何改正

比较好的方式是在头文件中定义模板而不仅仅只是声明。

比如上面的tpl.h代码改成这样

#pragma once

template <typename T>
int compare(const T& a, const T& b) {
    if (a == b) {
        return 0;
    }
    return (a > b) ? 1 : -1;
}

就不会有链接问题了。

你可能还喜欢下面这些文章

GDB入门：使用bt查看程序出core的调用栈

当程序崩溃的时候，会产生一个core文件。我们可以称它为进程死亡现场。排查进程死亡就和破案一样，找到案发现场，仔细排查每个细节，抽丝剥茧，最终定位原因。很幸运我们有一个强大的工具调查现场信息。这个工具就是GDB。下面我们就来看看如何用GDB排查问题。首先以一个越界访问数组的程序为例，如下：#include #include void core() { std::vector<int> a; std::cout << a[0];}int main() { core(); return 0;}执行上面的代码将会产生一个core文件。假设我们的core

std::endl为什么导致程序变慢

c语言的位操作

std::endl为什么导致程序变慢

最近在写hadoop的streaming任务，在输出的时候用了std::endl，就像下面这样：

os << "content" << std::endl

运行后发现程序跑的比python还慢，令人费解。我入门C++的时候，输出hello world也是这样写的，有什么问题？

于是查了一下std::endl，发现问题挺大。std::endl解释如下：

Inserts a new-line character and flushes the stream.
Its behavior is equivalent to calling os.put('\n') (or os.put(os.widen('\n')) for character types other than char), and then os.flush().

也就是说每次执行到std::endl的时候都会将缓冲区的内容写入到输出的对象中，这样一来速度慢也就不足为奇。

性能测试

#include "timer.h"
#include <fstream>
#include <iostream>

int main() {
    {
        Timer timer;
        fstream fs("./with_endl.txt", std::fstream::out);
        for (int i = 0; i<100000; i++) {
            fs << "test" << std::endl;
        }
        std::cout << "with endl:" << timer.elapsed() << "ms \n";
    }

    {
        Timer timer;
        fstream fs("./without_endl.txt", std::fstream::out);
        for (int i = 0; i<100000; i++) {
            fs << "test" << "\n";
        }
        std::cout << "without endl:" <<timer.elapsed() << "ms \n";
    }

}

with endl:397ms 
without endl:18ms

不加std::endl性能高出20倍。如果程序的逻辑十分简单，那么输出字符串的时候最好用”\n”代替加std::endl

你可能还喜欢下面这些文章

GDB入门：使用bt查看程序出core的调用栈

如何用火焰图分析程序性能瓶颈

一个经验非常丰富的程序员可能可以静态分析程序的性能瓶颈，但大多数人做不到这些。这个时候我们往往需要借助一些辅助工具来分析程序的性能瓶颈，火焰图就是其中之一。

一张典型的火焰图长这样

本文主要介绍如何生成和分析火焰图。

C++中zlib的crc32和python zlib.crc32结果不一致的解决方案

背景

python和c++的代码中均有使用crc32分流的操作，需要保证分流得到的结果一致，那么两个crc32的方法得到的结果需要一致才行。然而实际测试中发现python2中zlib.crc32和c++的zlib中crc32得到的结果却不一致。

问题复现

python版crc32

import zlib
print zlib.crc32("helloworld")

结果为 -102031187。

如下：

C++ 版zlib crc32

#include <zlib.h>
#include <iostream>

int main() {
    std::string str = "helloworld";
    std::cout << crc32(0, reinterpret_cast<unsigned const char*>(&str[0]), str.size()) << std::endl;
    return 0;
}

运行结果为：4192936109

python版得出的结果是-102031187，而C++版本得出的结果是4192936109。

你可能还喜欢下面这些文章

c语言的位操作

使用php curl 的并发能力可以做什么

在php中，没有多线程让编程变得简单。但在一些需要并发提升性能的场景下，显得有些无能为力，比如发起一些http请求。但好在curl扩展可以让我们“并发”去请求网络资源。利用这个特点，我们能做很多有趣的事情。最基础的，并发请求网络资源，提升处理速度。并发访问代码<?phpclass ConcurrencyHTTP { private $_requests; private $_callbacks; private $_currentIndex = 0; public function get($url, $header = array(), $timeout = 3

股市涨跌的秘密

娱乐之作，大家见笑。^ – ^

本文利用神经网络对股市的预测结果作为分析的对象，打开神经网络的黑箱，找到股市中涨跌的秘密。

量价特征

想要预测股市涨跌，就需要了解在股票上涨和下跌的时候，前一天发生了什么。就好像我们想要预测明天天气的时候，总会想尽办法找到过去几十年甚至几百年下雨的前一段时间都有哪些征兆。预测股票也一样，我们需要想尽一切办法找到某只股票过去几年里面价格上涨的前一天都有哪些特征，越全面越好。

找特征不是一件简单的事情，有效的特征可以为我们增加预测的精准度，而无效的特征会对训练造成干扰。首先从最简单的量价特征开始，即今天的股票的价格变化和交易量变化。

为什么是这两个特征？我的理论依据是市场所有的信息最终都会体现在今天的交易价格和交易量上。这两个特征一定是有效的特征。

为了让预测更加准确，我们加上一个五日均价变化，体现股票最近一段时间的价格变化趋势。

为了尽可能减少可能存在的人为操控股市的影响，我选择了沪深300指数作为分析对象，沪深300整体交易量大，波动小，比较适合分析。

构建一个单层一个节点的网络，如下图，这样训练得到的结果得出来的参数我们会有一个直观的印象。

假设R是股票明日的最终涨跌情况，涨为1、跌为0，那么这个网络想要表示的就是价格变化，量变化，五日均价变化分别和未来的涨跌到底是正相关还是负相关。