最简单的画直方图的方法是调用matplotlib.pyplot中的hist函数。如果你的数组是s，想要画有10个组的直方图，下面的代码可以达到这样的目的

import matplotlib.pyplot as plt
plt.hist(s, bins=10)

pandas模块里提供现成的求移动平均值的函数。如果是个list，需要先转换为pandas.Series。如果已经是pandas.Sereis类型的数据了，可以直接调用。

import pandas as pd
s = [1,2,3,5,6,10,12,14,12,30]
moving_mean = pd.Series(s).rolling(window=3).mean()

如果s已经是个pandas.Series类型的了，就直接调用

moving_mean = pd.Series(s).rolling(window=3).mean()

上面的window=3的意思是每次取三个数的平均，移动窗口的长度。

>>import sklearn
>>print('Your version is {}'.format(sklearn.__version__))
Your version is 0.18.01

这个方法也能够查其他模块的版本。

如果是想删掉某个变量x

>>>del x

如果是要删掉所有变量

>>>%reset -f

del完之后最好再gc.collect()一下，释放出空间

del my_var
import gc
gc.collect()

还有一种是numpy.corrcoef。这个可以可以求多个数组的相关系数。

比如要求a,b,c,d两两之间的相关系数。 

import numpy as np
np.corrcoef([a,b,c,d])

得到一个4乘4的对称矩阵，矩阵元素就是相关系数。

>>> import scipy.stats as stats
>>> a = [1.2, 1.5, 1.9]; b = [2.2, 2.5, 3.1]
>>> stats.pearsonr(a,b)
(0.99419162560192009, 0.068648785502029797)

返回的第一个数0.99419就是a和b的相关系数。第二个数0.0686是以a和b不同为零假设下的p值。

如果数据在pandas的DataFrame里的话，可以直接调用df.corr()，这个应该是最方便的了

>>> import pandas as pd
>>> df = pd.DataFrame()
>>> df['a'] = [1, 3, 2, 4]
>>> df['b'] = [1, 2, 3, 5]
>>> df.corr()
         a	            b
a	1.000000	    0.831522
b	0.831522	    1.000000

对于一个DataFrame A，A.loc[k]是读取A中index为k的那一行。A.iloc[k]是读取A中的第k行。

假设下面的DataFrame叫A    

A
      Name    Age

1     Tom      20

3     Tony    19

4     Jim      22

>>> A.loc[3]

Tony    19

>>>A.iloc[0]

Tom    20

>>>A.iloc[1]

Tony    19

A.loc[0]和A.loc[2]被抱错，没有index里没有0和2。同样，A.iloc[3]也会抱错，因为这里只有3行，iloc只能取到0，1，2.

绝大部分机器学习的算法都可以在sklearn这个包里面找到，也包括你说到的决策树(DecisionTree)。代码很简单，如下：

>>> from sklearn import tree
>>> clf = tree.DecisionTreeClassifier(criterion='gini')
>>> clf.fit(X,y)
>>> y_test = clf.predict(X_test)

上面的criterion='gini'表示这个决策树是根据“Gini不纯性”准则建立的；如果criterion='entropy'，意思说这个决策树是根据“熵增益准则”来构建的。

fit是训练拟合这个决策树的过程，X是训练集样本（注意：不含真实标签的那一列），y是训练样本的标签。

predict是用fit出来的树来进行预测。y_test是测试集X_test中每个样本的预测结果。这个结果是0，1两元的。

如果想要得到预测为0或者为1的概率，那么最后一句话要改成

>>> y_test = clf.predict_proba(X_test)

python的ttest_1samp同时返回T-statistic和p value。利用T检验的对称性，我们可以把双侧假设检验结果转化为单侧的。

如果T-statistic > 0，单侧pvalue = 1 - 双侧pvalue／2

如果T-statistic < 0，单侧pvalue = 双侧pvalue／2

可以根据上面的等式，自己定义个函数

def ttest_onesided(s):
    from spicy.stats import ttest_1samp
    (t, p) = ttest_1samp(s, 0)
    if t > 0:
        onesided_p = 1 - p / 2
    else:
        onesided_p = p / 2
    return onesided_p

也许你记错了？你说的像是Boosted Trees。随机森林是会有放回地随机选取样本的，但是会选择出和原样本一样数量的样本。

举个栗子，比如你的训练集有5000行20列，我们从这5000行里进行有放回的抽样，抽出5000行，这个就是你的随机样本

scoring设置错了，sklearn上的documentation写的也不是清楚，应该是这样

>clf = LogisticRegressionCV(scoring='roc_auc')

在sklearn.linear_model.LogisticRegressionCV中，C是正则惩罚项的系数倒数，C越小，惩罚越重。

对于L1惩罚(LASSO)，式子如下

对于L2惩罚(Ridge)，式子如下

LogisticRegressionCV中的C是根据你输入的Cs产生的。

如果Cs=10，那么先产生[-4. , -3.11, -2.22, -1.33, -0.44, 0.44, 1.33, 2.22, 3.11, 4.]，然后根据这10个等距点，产生相应的10个C，[10^(-4), 10^(-3.11), ..., 10^4]。LogisticRegressionCV会自动进行交叉验证，从上面10个C里面挑出最佳的C。

【注】感谢@熊猫儿 的提醒，之前的答案不准确，现在已经更正。（2019-01-18）

fit, fit_transform, transform这三个方法用数学公式表达起来可能更直白。

假设需要被PCA的原始矩阵是$X$，$n$行$p$列，PCA的参数$n\_component = k \ll p$.

按照PCA的原理,

$$X\approx M N,$$

其中矩阵$M$是$n$行$k$列，$N$是$k$行$p$列。因为$NN^T$约等于单位矩阵，

$$M \approx XN^T,$$

$M$就是降维之后的数据，只剩下了$k$个特征。

>>> pca = sklearn.decomposition.PCA(n_components=k)

>>> pca.fit(X)

# fit就相当于求$N$的过程。

>>> M = pca.transform(X)

# transform就相当于用矩阵$N$左乘$X$，从而得到$M$。

当然这两步也可以合成一步来完成

>>> pca = sklearn.decomposition.PCA(n_components=k)

>>> M = pca.fit_transform(X)

如果你想用$X$降维的方式对另外一个数据集$S$进行降维（比如先对训练集降维，然后对测试集用一样的方式进行降维），

$$H \approx SN^T$$

那么fit和transform两个步骤就不能合并了。

>>> pca = sklearn.decomposition.PCA(n_components=k)

>>> pca.fit(X)

>>> H = pca.transform(S)

sklearn.tree.DecisionTreeClassifier基本上使用的是CART，稍稍有区别的是它对CART的计算性能进行了优化。

你是不可以指定它使用其他算法的。但是你可以设置sklearn.tree.DecisionTreeClassifier中criterion参数为"entropy"，也就是信息增益，这样就几乎是ID3了。但是C4.5是基于信息增益率的，所以sklearn.tree.DecisionTreeClassifier做不到C4.5算法。

无法做到指定ID3和C4.5的。

sklean里的decision tree模型，不管是回归还是分类，都限制为二叉树。

而ID3和C4.5，不一定是二叉树。CART必须是二叉树。从这个角度来看，sklearn的决策树是无法完全实现C4.5和ID3的。

还有一点就是batmanX提到的splitting cirterion的问题了。

numpy里有现成的生成服从某个概率分布的随机变量，而且可以自己设置参数和随机数的数量。

numpy.random.beta(a, b[, size])                  Beta分布随机变量

numpy.random.binomial(n, p[, size])            二项分布随机变量

numpy.random.chisquare(df[, size])            卡方分布随机变量

numpy.random.dirichlet(alpha[, size])           狄利克雷分布随机变量

numpy.random.exponential([scale, size])     指数分布随机变量

numpy.random.geometric(p[, size])               几何分布随机变量

numpy.random.normal([loc, scale, size])        正态分布随机变量

numpy.random.poisson([lam, size])                泊松分布随机变量

numpy.random.uniform([low, high, size])        均匀分布随机变量

numpy.random.wald(mean, scale[, size])        Wald分布随机变量

可以查看numpy的官方文档numpy.random文档

假如你的pd.DataFrame是df，你想按照col_1中的数值对df重新排列

降序排列（从大到小）

df.reindex(df['col_1'].abs().sort_values(ascending=False).index)

升序排列（从小到大）

df.reindex(df['col_1'].abs().sort_values(ascending=True).index)

例

>>> df
   col_1  col_2
0      2      1
1      4      3
2     -3      5
3     -5      7

>>> df.reindex(df['col_1'].abs().sort_values(ascending=False).index)
   col_1  col_2
3     -5      7
1      4      3
2     -3      5
0      2      1

有现成的package

>>> from statsmodels.tsa.stattools import adfuller

>>> adfuller(x)

这样可以判断x是否稳定

pip install opencv-python

安装好之后

import cv2

可以用pandas的get_dummies

df[feature] = df['country'].astype('category')
df = pandas.get_dummies(df, columns=['country'])

对于字符类型，你需要先做LabelEncoder，把它转成整数类型，然后再用OneHotEncoder

具体代码可以参考我在这个问题里的回答：sklearn onehotencoder的具体用法是什么

假如你的pd.DataFrame的名字是df，提取最后10行

>>> df.tail(10)

提取最后k行

>>> df.tail(k)

df.iloc[-k:]

sklearn.metric.roc_auc_score才是计算ROC AUC的。

>>> y_actual, y_pred = [0, 0, 1], [0.2, 0.1, 0.9]

>> sklearn.metric.roc_auc_score(y_actual, y_pred)

1

你所用的sklearn.metrics.auc(x,y)是计算折线与x轴之间的面积，x是折线上点的横坐标，y是折线上点的纵坐标。

>>> x = [0, 1]

>>> y = [1, 1]

>>> sklearn.metrics.auc(x, y)

1

df = df.drop(['c', 'e'], axis=1)

或者

df.drop(['c', 'e'], axis=1, inplace=True)

你说的是cosine distance还是cosine similarity.

distance.cosine(a,b)是计算余弦距离的

1 - distance.cosine(a,b)是计算余弦相似的。

>>> from scipy.spatial import distance
>>> a = [-1, -2, 3]
>>> b = [2, 1, -2]
>>> 1 - distance.cosine(a,b)
 -0.890870806374747

更推荐len(df)

len(df)比df.shape[0]快20%到50%。虽然它们都已经非常快了。

如果你的Pandas.DataFrame叫做df

求行数

>>> df.shape[0]

求列数

>>> df.shape[1]

对于一个array对象a，也一样

>>> a.shape[0]

pandas的DataFrame和graphlab的SFrame，我个人觉得pandas更常用一些。但是它们虽然都是提供了dataframe这种数据结构，但是本质上还是有很多不同的地方的。

1. 存储方式。pandas.DataFrame必须存储在内存当中；而SFrame可以选择存在内存或者硬盘空间上。所以SFrame可以放下更大的数据，其实S就是指的scability，可延展性。

2. DataFrame是可变的，SFrame却不是。换句话说，当我们建立好一个SFrame之后，其中的数值就不能被修改了。

3. SFrame只支持64位CPU，只支持python2.7。而DataFrame没有这些限制。

4. 用法不完全一样。具体可以参考这里。

你们都是土豪么？

最大的区别难道不是GraphLab SFrame是付费的，Pandas是免费的么？

pandas.DataFrame放在内存里，读取也快。

SFrame更适合大数据，比如1T以上的那种，可以放在磁盘空间上，所以读取也相对较慢。

>>> df
       val          date
0      3          20170401
1      1          20170402
2      4          20170403
3      5          20170404
4      0          20170405
>>> df['date'] = df['date'].apply(pd.to_datetime)

你的设置是cv=12, n_jobs=3，也就是用三个处理器（记为CPU_A, CPU_B, CPU_C），进行12次cross validation（记为CV_1, CV_2, CV_3, ..., CV_12）。pre_dispatch是预派遣的意思，就是提前先把任务派遣给各个处理器。

如果我们没有设置cross_val_score中的参数pre_dispatch，当我们开始执行cross_val_score，程序会一次性把全部12个CV都派遣出去，每个处理器领到4个CV。要特别注意了，这里的派遣并不是口头的安排任务，而是把任务和任务对应的数据(划重点)也发送给处理器。比如说，CPU_A领到了CV_1, CV_4, CV_7, CV_10，那么CPU_A就领到了四份训练数据集、四份测试集存放在内存里（又是重点），然后CPU_A开始依次完成CV_1, CV_4, CV_7, CV_10。

如果我们设置pre_dispatch=‘2*n_jobs’，当我们开始执行cross_val_score，程序会派遣6个CV出去，每个处理器领到2个CV。所以一开始每个处理器只需要存两份训练集、测试集（划重点）。比如说CPU_A领到了CV_1和CV_4，CPU_B领到了CV_2和CV_5，CPU_C领到了CV_3和CV_6，如果CPU_B率先完成了CV_2，那么系统会自动把CV_7派遣给CPU_B，节奏CPU_A完成了CV_1，系统再把任务CV_8放在CPU_A的任务队列里。pre_dispatch=‘2*n_jobs’的意思就是保持每个CPU都有两个任务在身（一个在做，一个在排队），除非所有任务都被派遣出去了。

如果我们设置pre_dispatch=‘1*n_jobs’，这样占用的内存最低，因为只有当当前的任务完成之后，才会有新任务（数据）派遣到闲置处理器，而非将数据放在队列中等待。

matplotlib.pyplot模块中的scatter

>>> import matplotlib.pyplot as plt

>>> import numpy as np

>>> x = range(20)

>>> y = np.sqrt(x)

>>> z = np.random.uniform(30, 200, 20)

>>> plt.scatter(x, y, s=z, c='r', alpha=0.4, lw=0)

x是散点的横坐标

y是散点的纵坐标，我输入的是根号x

s是表示每个点的大小，这里我输入了一个随机产生的大小

c表示颜色，我设置为红色

alpha表示透明度，1是不透明，0是全透明

lw表示每个点边界线的宽度，我设置为0

最后得到了如下散点图

这个和在string里插入变量是一样的，在标题里用%s代替变量，具体可以看下面的例子

import numpy as np

import matplotlib.pyplot as plt

k = 2

x = np.array([1, 2, 3, 4, 5])

y = k * x

plt.figure()

plt.plot(x, y)

plt.title("The slope of the line is %s and the max of y is %s"%(k, max(y)))

sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_split=1e-07, class_weight=None, presort=False)

这个是sklearn.tree.DecisionTreeClassifier的全部参数，其中有一项是random_state，如果你没有特地设定这个数值的话，决策树是有随机性的。

-------------------------来个分界线--------------------------

在sklearn的记录文档里是这么写的，考虑到数值特征的存在，训练一个最优的决策树是NP-complete。因此比较实际的做法是努力去找一个比较优的，而不是最优的。比如用贪婪算法，随机地从一些特征开始建立次优化的决策树，再从这些树中选择最好的，这样的树能达到较优。

n_iter其实是epoch的意思。

比如你的训练集样本数量是10000，那么你实际的训练次数是10000 * n_iter，而不是n_iter。所以如果你设置n_iter=100000的话，就需要很久很久才能跑完了。

这个n_iter和训练神经网络时的epoch是一个意思

# 显示df每列的名称
>>> df.columns.values

# 将第三列的列名改为'new name'
>>> df.rename(columns={ df.columns[2]: "new name" }, inplace=True)

# 假如df一共有三列，你想把所有列名依次改为'col_1', 'col_2', 'col_3'
>>> df.columns = ['col_1', 'col_2', 'col_3']

假设你的df里有一列叫做'col_1'，如果你想把这列的名字改成'col_a'，那么可以这样

df = df.rename(columns={'col_1': 'col_a'})

选取第k行的代码为

df.iloc[k, :]

注意pandas的排序是从0开始的，也就是说首行是第0行。

这样返回的是一个Series，如果想要list，可以train.iloc[k].tolist()

df.loc[k]

一行代码就可以完成

df['flag'] = my_array

df.insert(idx, col_name, value)

比如说想把flag插在最前面一列

>>> df.insert(0, 'flag', my_array)

比如说想把flag插在第三列的位置上

>>> df.insert(2, 'flag', my_array)

learning rate，学习率，顾名思义就是模型学习训练集的速度，或者说模型被训练的速度。

learning rate越大，训练得越快；反之，越慢。

learning rate通常是针对于基于梯度下降的机器学习模型，具体说来这个学习率就是梯度下降的步长。对于凸优化，一般说来步长越小收敛越慢；对于非凸问题，learning rate就不是那么直截了当的了。选太小了，训练太慢，影响这个模型的进度，选太大了，可能一步跨过去，错过了最优点。

现在有很多模型能够根据数据的特点自动选择学习率。如果你要手动设置的话，根据我个人的经验0.00001到0.1的范围比较常见，有时候你甚至需要通过交叉验证来最后确定学习率。

就是梯度下降里的步长

仅此而已

使用sklearn.metrics.average_precision_score

>>> import numpy as np
>>> from sklearn.metrics import average_precision_score
>>> y_true = np.array([0, 0, 1, 1])
>>> y_predict = np.array([0.1, 0.4, 0.35, 0.8])
>>> average_precision_score(y_true, y_predict)  
0.791666666

>>> df_combine = pd.concat([df1, df1], ignore_index=True)

sklearn中用的是欧几里得距离($L_2$范数)，而且也不能设置为其他距离。

SpectralPython里的KMeans模块可以用欧几里得距离或者曼哈顿距离($L_1$范数)。

这个不是map的问题，是你的lambda语句出错了。

在lambda语句中，如果使用if，那必须要给出else。

a = map(lambda x: 0 if x in target else x, a)

predict_proba返回的是一个n行k列的数组，第i行第j列上的数值是模型预测第i个预测样本的标签为j的概率。所以每一行的和应该等于1.

举个例子

>>> from sklearn.linear_model import LogisticRegression
>>> import numpy as np
>>> x_train = np.array([[1,2,3],
                        [1,3,4],
                        [2,1,2],
                        [4,5,6],
                        [3,5,3],
                        [1,7,2]])
>>> y_train = np.array([0, 0, 0, 1, 1, 1])
>>> x_test = np.array([[2,2,2],
                       [3,2,6],
                       [1,7,4]])
>>> clf = LogisticRegression()
>>> clf.fit(x_train, y_train)
# 返回预测标签
>>> clf.predict(x_test)
array([1, 0, 1])
# 返回预测属于某标签的概率
>>> clf.predict_proba(x_test)
array([[ 0.43348191, 0.56651809],
       [ 0.84401838, 0.15598162],
       [ 0.13147498, 0.86852502]])

预测[2,2,2]的标签是0的概率为0.43348191，1的概率为0.56651809

预测[3,2,6]的标签是0的概率为0.84401838，1的概率为0.15598162

预测[1,7,4]的标签是0的概率为0.13147498，1的概率为0.86852502

对于一个k元分类

probas = clf.predict_proba(test)

probas是一个k列的array

probas[:, j]这一列是每个test样本为j的概率。

probas[i, j]是预测第i个样本的标签为j的概率。

万能的sklearn里有TSNE函数。

用法和sklearn.decomposition.PCA是一样的。

>>> from sklearn.manifold import TSNE

>>> model = TSNE(n_components=2, random_state=0)

>>> data_reduaced =  model.fit_transform(data) 

n_components = p 的意思就是说把数据降到只有p维。

pandas里有fillna

df['my_col'].fillna(0, inplace=True)

返回每行缺失值的总数

df.isnull().sum(axis=1)

返回每列缺失值的总数

df.isnull().sum(axis=0)

>>> df.count()               #按照列来数非缺失值的个数
>>> df.count(axis=1)     #按照行来数非缺失值的个数

例子：

>>> df
       a           c          b
0      1          3          NaN
1      2          5          0
2      3         NaN      NaN
3      4         NaN      0

# 每列缺失值的个数

>>> df.shape[0] - df.count()
a    0
b    2
c    2

# 每行缺失值的个数

>>> df.shape[1] - df.count(axis=1)
0      1
1      0
2      2
3      1

numpy.average(x, weights=y)可以算加权平均

根据你的变量，就是

>>> import numpy as np

>>> np.average(value, weights=weights)

重新赋值pandas.DataFrame.index即可。

df1.index = range(len(df1))

>>> df1.reset_index(drop=True, inplace=True)

最方便的是用pandas.read_table

>>>import pandas as pd


# 如果数据是空格分隔的
>>>data = pd.read_table("file.txt", spe=" ")

# 如果数据是逗号分隔的
>>>data = pd.read_table("file.txt", spe=",")

# 如果数据是制表符分隔的
>>>data = pd.read_table("file.txt", spe="\t")

>>> import matplotlib.pyplot as plt
>>> plt.figure(); plt.plot(x,y); 

plt.xlabel('this is x-axis'); plt.ylabel('thi is y-axis'); plt.show()

cross_val_score是无法做到一次交叉验证，同时返回多个不同的loss的。sklearn也许以后会增加这种功能，但是目前看来，下一版本还不会。

目前可行的方案，是使用sklearn.model_selection.cross_val_predict。

y_cv = cross_val_predict(clf, X, y)

roc_auc = metrics.roc_auc_score(y, y_cv)

logloss = metrics.log_loss(y, y_cv)

pr_auc = metrics.average_precision_score(y, y_cv)

... ...

这样的话，只需要做一次交叉训练，节约了时间。缺点就是无法知道每个fold的loss的数值。

写个循环就搞定了

for my_score in [score1, score2, score3, score4]:

        print cross_val_score(clf, X, y, my_score)

import numpy as np

import matplotlib.pyplot as plt

x = np.arange(0, 10, 0.1)

y1 = x ** 2

y2 = - x ** 3

fig, ax1 = plt.subplots()

ax2 = ax1.twinx()

ax1.plot(x, y1, 'r-')

ax2.plot(x, y2, 'b-')

ax1.set_xlabel('X data')

ax1.set_ylabel('square of x', color='r')

ax2.set_ylabel('negative cube of x', color='b')

plt.title('double y-axes example')

plt.show()

遇到了这个问题，我的loss值最开始是在比较大的值上一直无法收敛，查看网络权值梯度，最开始的梯度返回已经是e-3级别了，因此网络基本没调整。

目前知道的方法有：

初始化不对，查看每层网络的输入方差，如果方差越来越小，可以判定为初始化不对，而你的初始化也是采用的基本的高斯函数，有很大可能是初始化的问题；

采用BN（批量标准化），可以稍微降低初始化对网络的影响；

如果你有更好的办法，求告知。

好长好长的code。我没有逐行看，但是有几个可能性：

1、你的预测输出标签，而不是概率。如果你的数据是非常倾斜，1:20什么的，基本上不管怎么预测，预测标签都会是0。

2、你的bias项一直都是0，tf.Variable(tf.constant(0.0, shape=[self.num_hidden]))。这也许是一个可能。

3、你的模型层数比较多，激活函数都是一样的。可以试试两层、三层的，效果如何。也可以换个激活函数试试。

这可能是没有对数据进行正则化导致的，在很简单的模型上能重现类似的问题。

classification_report(y,answer,target_names=['up','down'])中y必须是整数型，answer也必须是整数型，估计你里面有小数。

你可以这样试试

>>> y = list(map(lambda x: int(x), y))
>>> answer = list(map(lambda x: int(x), answer))
>>> print(classification_report(y,answer,target_names=['up','down']))

Pandas似乎更喜欢loc，而非iloc。对于pandas.Series有可以得到loc的方法(get_loc)，但是没有iloc的方法；对于pandas.DataFrame似乎更没有了。

我的建议就是直接写循环吧。

for i in range(df.shape[0]):
    for j in range(df.shape[1]):
        if df.iat[i, j] == '你好':
            print (i, j)
            break

.iat比iloc大概快两倍，但是缺点是不能multi-indexing，不过这个问题中不影响。这里推荐用.iat。

tf.placeholder在声明的时候不需要初始化的数值，只需要声明类型和维数，例如

x = tf.placeholder(tf.float32, shape=(None, 1024))

tf.placeholder是为了方便定义神经网络结构，所以可以看作是符号变量。tf.placeholder通常是在训练session开始后，存放输入样本的。

tf.Variable在声明的时候必须要有初始的数值。例如

weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")

tf.Variable通常是存放weight和bias，然后会不停地被更新，所以说是variable。

万能的pandas里有数据透视表的，叫做pandas.pivot_table.

可以参考statsmodels模块中的QuantReg。

使用方法和R里面的lm差不多，用y ~ x1 + x2这种方式表示输入变量。

链接里有具体的例子。

有两个办法：

其一、你自己用C++写一个。你需要把tensorflow的源代码下载下来，然后自己用C++写一个函数。可参考Adding an op。

其二、你把你自己定义的损失函数用tensorflow中的标准函数表示出来。比如你需要MSE（虽然这个已经有了），可以写成

loss = tf.reduce_mean(tf.square(tf.sub(y_real, y_pred)))

比如说你有一个function: f(x1,x2) = exp(x1)/(exp(x1)+exp(x2)) 或者可以写成 f(x1,x2) = 1/(1+exp(x2-x1)).

你可以这么定义：

x = np.float32(np.repeat(0.5,2).reshape(2)) 

varX = tf.Variable(x, name='varX', dtype=tf.float32)

varX1 = tf.slice(varX,begin=[0],size=[1])

varX2 = tf.slice(varX,begin=[1],size=[1])

f = -1./(1+tf.exp(varX2-varX1))

opt = tf.train.GradientDescentOptimizer(your_learning_rate)

train = opt.minimize(f)

我自己搞明白了

import sys
print(sys.getsizeof(df) / 1024.)

这个的结果就是df占了多少kb

试试

df.info()

最后一行会返回df的大小

或者试试

print(df.memory_usage().sum() / (1024 ** 2), "MB")

得到的是dataframe所占的空间有多少mb

import matplotlib
from numpy.random import randn
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter
# 把y轴转化为百分比。
def to_percent(y, position):
    return str(100 * y) + '%'
# 直方图的数据集
x = randn(500)
# 设置直方图分组数量bins=60.
plt.hist(x, bins=60, weights= [1./ len(x)] * len(x))
formatter = FuncFormatter(to_percent)
plt.gca().yaxis.set_major_formatter(formatter)
plt.show()

>>> import numpy as np
>>> a + (b - a) * np.random.rand(m, n)

长话短说，是的，numpy里的matrix的确比较鸡肋。

一句话，尽量只用array，不用matrix。

理由主要是两个：一、matrix是array的子类，也就是说它们是非常相似的；matrix是限于2维，array则可以是2维，也可以是更高维。二、很多函数、或者其他库里的函数，返回的形式也常常是array而不是matrix。

df = df.drop_duplicates()

你试试reg = XGBRegressor(seed=99)

版本问题，老版本里只有seed，新版本里random_state和seed都有。但是本质上它们都是在设置随机种子。

pandas自带的replace。（文档）

>> df.replace(to_replace=-1, value=0, inplace=True)

或者

>> new_df = df.replace(to_replace=-1, value=0)

我一般是先decode再encode

>>> string = '机器学习'
>>> list_string = map(lambda x: x.encode('utf-8'), string.decode('utf-8'))
>>> for i in list_string:
            print i
机
器
学
习

python3还是很方便的

a = '吃火锅'

print(list(a))

['吃', '火', '锅']

>>> df[df['col_1'] == 3].index.tolist()

[1]

或者

>>> df[df['col_1'] == 3].index.tolist()[0]

1

df.index.name = None

或者

del df.index.name

我记得设置的时候是index.col=字符串，换成none或者false试试

stats是scipy的子模块，所以应该是

>>> from scipy import stats

>>> import pandas as pd

>>> data = pd.read_csv('yourfile.tsv', sep='\t')

或者

>>> data = pd.read_table('yourfile.tsv', sep='\t')

想知道.tsv文件是一种什么文件格式？跟csv有什么差别？

Python有一个叫csv的包，里面有一个reader() 函数可以处理这个问题。 

假设我有这样一个csv文件，可以看到第一列第二行数据出了问题

如果用csv这个包的话，问题可以很容易得到解决

在读取出文件以后，楼主可以根据自己的实际情况将列表转换成需要的格式。

这样DataFrame可以显示1000行

pd.set_option("display.max_rows", 1000)

如果要恢复默认设置

pd.reset_option("display.max_rows")

import pandas as pd

pd.options.display.max_rows = 300

显示所有行

pd.set_option('display.max_rows', None)

显示所有列

pd.set_option('display.max_columns', None)

这是一个非常危险的操作，一旦行列数过多，jupyter有非常大的可能会卡死

pytorch的官网(www.pytorch.org)上就有安装方法的介绍，如果用conda的话，在命令行(terminal)中输入下面这行代码就能实现安装。

conda install pytorch torchvision -c soumith

在terminal里用pip也可以

pip install http://download.pytorch.org/whl/torch-0.2.0.post3-cp27-none-macosx_10_7_x86_64.whl

pip install torchvision 

萝卜青菜各有所爱吧，你要你的林志玲，他要他的许晴。

plt.style.use('ggplot')

plt.style.use('bmh')

plt.style.use('fivethirtyeight')

plt.style.use('seaborn-whitegrid')

plt.style.use('dark_background')

plt.style.use('grayscale')

品种众多，供君选择。

plt.style.use('ggplot')

用plt.style.use('ggplot')就可以设置画图的风格。其中‘ggplot'就是matplotlib提供的一种画图风格。

使用 print(plt.style.available) 就可以看到所以可以使用的画图风格。

总的来说，这些可设置的画图风格都比matplotlib默认的会显得更好看更专业一些。

下面两幅图分别是使用了ggplot的风格和matplotlib默认的风格的柱状图的对比。

可以使用dataframe的reindex方法。

使用reindex方法可以对行的顺序进行任意的调换，只需要把该方法的columns参数改成index。

注意reindex和df.index=['AU', 'UK', 'US', 'FR'] 的区别。后者是直接对该dataframe的列名进行修改，表格中的数据并不会随之变动。

我以前遇到过这个。是shape的问题，当输入一个只有一个特征的数据集的时候，sklearn会以为是一个有很多特征的单条数据。

reg.fit(train[['x_1']], train['y'])

或者

reg.fit(train['x_1'].reshape(-1, 1), train['y'])

应该就可以了。

sns.plt.show()似乎不可以，也许是版本的问题。不过下面的code应该是可以的。

import seaborn as sns

import matplotlib.pyplot as plt



sns.barplot([1, 2, 3], [2, 3, 4])

plt.show()

我自己查到了

sns.plt.show()就可以了

设置参量usecols=['id', 'age', 'gender']

d = pd.read_csv('your_file_name.csv', usecols=['id', 'age', 'gender'])

同样适用于pd.read_table

d = pd.read_csv('your_file_name.csv')
d = d[['id', 'age', 'gender']]

(counts, bins, patch) = plt.hist(data, bins=5)

counts 返回 每个bin里元素的数量

bins 返回 每个bin的分界线

patch不用管它

设置nrows=10, 读取前10行

d = pd.read_csv('data.csv', nrows=10)

ggplot2有python的移植：ggplot|home

import matplotlib.pyplot as plt

plt.style.use('ggplot')

这个能达到类似的效果

#保存

from sklearn.externals import joblib

joblib.dump(model, 'path/to/my_model.pkl')

#读取

model = joblib.load('path/to/my_model.pkl') 

参阅： Model persistence

也可以直接用pickle将模型保存到本地

import pickle
with open('filename.pkl', 'wb') as f:
    pickle.dump(clf, f)

读取

with open('filename.pkl', 'rb') as f:
    clf = pickle.load(f)

import numpy as np
np.cov(a, b)

返回一个2 x 2的矩阵

左上角的数值是a的方差，右上角是a和b的协方差

左下角是b和a的协方差，右下角是b的方差

因为对于线性回归来说，stack是没有意义的，这里的gblinear的意思实际上就是用sgd的迭代方法来训练一个LASSO线性模型。此时基于gblinear的xgboost就没有真正的‘boost’，只是一个用sgd求解的普通线性模型。

也可以参考xgb的作者陈天骐在这个问题里二楼的回应。

该回答是错误的。请看abuu同学的解答。

原帖内容：

—————————————————————————

boosting不是一种具体算法，而是一种通过加权来结合弱分类器，实现强分类的一种思想。xgboost是对其中boosting家族中gradient boosting算法的优秀实现。线性回归模型当然可以作为gradient boosting的一种弱分类器。

stats里现成的从Z-score到概率分布的函数。

>>> import scipy.stats
>>> scipy.stats.norm.ppf(0.95)
1.6448536269514722
>>> scipy.stats.norm.cdf(1.64)
0.94949741652589625

至于转换成p-value就看你自己的假设检验是单侧的还是双侧的了。可以根据上面的代码，自己转换试试。

最简单的方法是list(df)

df.columns.tolist()

如果需要重命名所有的列，可以重新给df.columns 赋值。df.columns = ['new_col_1', 'new_col_1', ..., 'new_col_n'].

如果只需要改变某一列或几列的列名，则可以使用rename函数。df = df.rename(columns={'old_col_1': 'new_col_1'})。

以上两种方法也适用于index的修改，只需把columns改成index即可。

pandas.DataFrame更改列名

也可以参考这个。

1. 浮点数(float)降低精度或者转成整数(int)。

浮点数转整数这很好理解。

以numpy为例，浮点数有以下几种精度，float16, float32, float64, 并且默认的精度是float64。但是通常情况下float32，甚至float16的精度就已经足够了，所以可以用array的astype函数将float64转成float16或32.

2. 将字符串的类别变量转换成整数。

字符串占的内存比数字要大很多，所以要尽量用整数来替换字符串。比如我有一个叫“country“的列，它的值有'China', 'USA', 'Italy', 那么我可以用一个map把这三个值分别映射到1，2，3。这样也可以节省内存。

转换数据的类型，比如int64到int32甚至int8，float64到float32。例如：

>>> df.head()    

    a   b   c

0   0   -0.730132   0.193487

1   1   -0.050981   1.186009

2   2   0.392594    -0.690333

3   3   -1.351106   1.381132

4   4   0.361649    0.724137



>>> df.info()

RangeIndex: 100000 entries, 0 to 99999

Data columns (total 3 columns):

a    100000 non-null int64

b    100000 non-null float64

c    100000 non-null float64

dtypes: float64(2), int64(1)

memory usage: 2.3 MB

原始数据2.3MB

>>> df['a'] = df['a'].astype(np.int32)

>>> df.info()

RangeIndex: 100000 entries, 0 to 99999

Data columns (total 3 columns):

a    100000 non-null int32

b    100000 non-null float64

c    100000 non-null float64

dtypes: float64(2), int32(1)

memory usage: 1.9 MB

把a列从int64到int32，数据大小变为1.9MB

>>> df['b'] = df['b'].astype(np.float32)

>>> df['c'] = df['c'].astype(np.float32)

>>> data.info()

RangeIndex: 100000 entries, 0 to 99999

Data columns (total 3 columns):

a    100000 non-null int32

b    100000 non-null float32

c    100000 non-null float32

dtypes: float32(2), int32(1)

memory usage: 1.1 MB

把b，c列从float64到float32，数据大小变为1.1MB

没这个功能吧，随机森林的性质本来就是每棵决策树等权重的。

如果权重不等，那就成boosting了。

随机森林是等权重的投票算法，所以题主需要的功能是无法达成的。

用graphviz可以直接把树在jupyter notebook里显示出来

import graphviz

from sklearn import tree

model = tree.DecisionTreeRegressor(max_depth=2)

model.fit(X, y)

dot_data = tree.export_graphviz(model, 

                                out_file=None, 

                                feature_names=X.columns,

                                filled=True, 

                                rounded=True,  

                                special_characters=True)  

graph = graphviz.Source(dot_data)

graph

需要通过调用tree.export_graphviz这个方法。

以sklearn自带的数据集iris为例

from sklearn.datasets import load_iris
from sklearn import tree

clf = tree.DecisionTreeClassifier()
iris = load_iris()
clf = clf.fit(iris.data, iris.target)
tree.export_graphviz(clf, out_file='trees.txt')

输出的trees.txt文件里有保存了你的决策树的判断规则。

如果你想把这个规则画出来的话，可以借用这个网站http://webgraphviz.com/，把上面的txt文件里的内容，复制过去就行了，可以得到类似下面的图。

应该是字符encoding的问题

试试

dataset.to_csv('data_set.csv', encoding='utf-8)

可以试试filterpy或者pykalman。

我用过filterpy。

filterpy不错

对应的还有一本很长的教程https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python

我没读完，楼主有兴趣可以看看

>> data['date'].dt.dayofweek

0    6

1    0

2    1

Name: date, dtype: int64

从0开始计数，0代表礼拜一，6是礼拜天。

直接用pandas内置的也可以

test['date'].dt.weekday

我一般用这个

data['date'].apply(lambda x: x.weekday())

from sklearn.metrics import confusion_matrix

confusion_matrix(y_true, y_pred)

可以用statsmodel.api模块。比如说逻辑回归

>>> import statsmodels.api as sm

>>> log_reg = sm.Logit(df['y'], df[['a', 'b', 'c']])

>>> clf = log_reg.fit()

Optimization terminated successfully.

         Current function value: 0.692762

         Iterations 3

如果要查看系数的p value，调用clf.summary()就可以了，这个方法对OLS回归也是一样的。

>>> clf.summary()

Logit Regression Results

Dep. Variable:  y   No. Observations:   1000

Model:  Logit   Df Residuals:   997

Method: MLE Df Model:   2

Date:   Tue, 17 Oct 2017    Pseudo R-squ.:  -0.1341

Time:   10:19:37    Log-Likelihood: -692.76

converged:  True    LL-Null:    -610.86

                LLR p-value:    1.000

     coef    std err z   P>|z|   [95.0% Conf. Int.]

a   0.1240  0.219   0.565   0.572   -0.306 0.554

b   -1.9466 6.245   -0.312  0.755   -14.186 10.293

c   3.7477  6.230   0.602   0.547   -8.463 15.958

sklearn不支持查看系数的p-value，可以参考statsmodels模块。

from sklearn.metrics import log_loss

print log_loss(y_true, y_pred)

比如

log_loss([1, 0, 1, 1],[0.6, 0.2, 0.7, 0.4])

0.50173371272327194

目前还没有。

不过。

在山的那边，海的那边，有一群勤劳的程序员，他们正在讨论在新版本的sklearn里增加post-prune。

链接在此

https://github.com/scikit-learn/scikit-learn/issues/6557

sklearn目前没有具体实现剪枝的功能。

现在能做的是预剪枝，就是设置Classifier或者Regression里的参数max_depth, min_samples_split, min_samples_leaf。

后剪枝的确是在sklearn中做不到的。

----------补充-----------

什么是预剪枝，后剪枝？

当然有，这个是针对sklearn的决策树进行剪枝的完整代码和解析

https://blog.csdn.net/appleyuchi/article/details/83692381

对于二元分类，阈值是0.5

对于多元分类，predict是返回概率最大的那个标签

0.5

可以用spicy.stats里的ks_2samp来实现两样本KS test。

#引用模块

from scipy.stats import ks_2samp



#产生两组不同的正态数据集

import numpy as np

x = np.random.normal(0, 1, 1000)

y = np.random.normal(0.1, 1, 1000)



#进行KS test

ks_2samp(x, y)



#返回值

#Ks_2sampResult(statistic=0.091000000000000025, pvalue=0.00046168121046219593)

numpy的array有flatten()方法

>>> a.flatten()

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

如果想要按列展开，可以设置参数为'F'

>>> a.flatten('F')

array([ 1,  4,  7, 10,  2,  5,  8, 11,  3,  6,  9, 12])

参阅https://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.ndarray.flatten.html

可以使用flatten与ravel两个函数，区别可以看看下面代码，根据你的需求进行选取

>>> x = np.array([[1, 2], [3, 4]])
>>> y = x.flatten()
>>> y
array([1, 2, 3, 4])
>>> y[0] = 9
>>> y
array([9, 2, 3, 4])
>>> x
array([[1, 2],
       [3, 4]])
>>> z = x.ravel()
>>> z
array([1, 2, 3, 4])
>>> z[0] = 8
>>> z
array([8, 2, 3, 4])
>>> x
array([[8, 2],
       [3, 4]])

a.reshape(1, -1)[0]

sklearn.metric.f1_score中有多种不同的多元分类的F1 score

from sklearn.metrics import f1_score

# micro

f1_score(y_true, y_pred, average='micro')

# macro

f1_score(y_true, y_pred, average='macro')

# weighted

f1_score(y_true, y_pred, average='weighted')

在第一次训练时，fit和partial_fit训练模型的原理其实本质上是一样的。

但是对于partial_fit的模型来说，当我们有了新数据，我们可以用新的数据在旧的模型基础上训练、更新模型，而不必重新训练。也就是另一位答友提到的，线上算法的特点。

以SGDClassifer为例，partial_fit的具体用法如下

from sklearn.linear_model import SGDClassifier
clf = SGDClassifier(loss='log')

#用数据集训练
clf.partial_fit(X, y)

#当我们有了新数据之后，可以在原基础上更新模型
clf.partial_fit(X_new, y_new)

#partial_fit的模型使用方法也是和正常模型一样的，直接用predict或者predict_proba
y_pred = clf.predict_proba(X_test)

fit就是一次性把模型训练完毕

partial_fit可以在原来的基础继续训练模型，所以partial_fit只针对对onlin的算法。这里SGD就是online的。

那除了sgd以外，还有什么可以使用`partial_fit`这个方法吗

pandas的dataframe有自带的sample功能，当设参数frac=1的时候，就相当于对行做shuffle

df = df.sample(frac=1)

如果重新排列之后希望index还是从0开始排序的话，可以这样操作

df = df.sample(frac=1).reset_indedx(drop=True)

用np.random.permutation构建一个随机序列，作为index来对df进行shuffle处理 

from np.random import permutation
idx = permutation(len(df))
df[idx]

随机重排的属于叫做shuffle，也就是“洗牌”。

sklearn里有洗牌的函数。

from sklearn.utils import shuffle

df = shuffle(df)

当然可以的。

from xgboost import XGBClassifier

from sklearn.model_selection import GridSearchCV

xgb_model = XGBClassifier(n_estimators=1)

parameters = {'learning_rate': [0.01, 0.02, 0.03], 'max_depth': [4, 5, 6]}

clf = GridSearchCV(xgb_model, parameters, scoring='roc_auc')

clf.fit(data, target)

上面这个例子就是对learning rate和max depth做grid search cv。

可以用GridSearchCV，前提是必须要用xgboost的sklearn api。

如果用xgb booster的话，就不能用了。

numpy实现了很多类似matlab的功能，也包括linspace

import numpy as np
np.linspace(0, 2, 5)

可以得到 array([ 0. , 0.5, 1. , 1.5, 2. ])

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linspace.html

fill_between可以实现颜色填充。

给个栗子

x = np.linspace(0, 10, 100)
y = 10 * x - x ** 2
plt.plot(x, y)
plt.fill_between(x, y, interpolate=True, color='green', alpha=0.5)
plt.show()

GridSearchCV是一个调参的过程，最后会告诉你最好的参数配置。

refit=True的意思就是GridSearchCV会按照最佳的参数配置重新训练模型。

clf = GridSearchCV(model, parameters, scoring='roc_auc', refit=True)
clf.predict(x_test)

在refit=True的时候，得到的clf是一个真正的模型，具有predict或者predict_proba的方法。

如果refit=False

clf = GridSearchCV(model, parameters, scoring='roc_auc', refit=False)

那么得到的clf并不是个真正的模型，不能进行predict。

你需要安装geopy这个包，然后就直接调用

北京上海为例

北京 纬度 39.9 经度 116.4

上海 纬度 31.2 经度 121.5

from geopy.distance import vincenty



beijing = [39.9, 116.4]

shanghai = [31.2, 121.5]

dist = vincenty(beijing, shanghai).km

print(dist)

得到结果1069.81945078

根据Jaccard的定义，用python很容易实现

def jaccard_sim(a, b):

    unions = len(set(a).union(set(b)))

    intersections = len(set(a).intersection(set(b)))

    return 1. * intersections / union

使用

a = ['x', 'y']

b = ['x', 'z', 'v']

print(jaccard_sim(a, b))

得到0.25

sklearn里也有jaccard

文档见这里

但是要求数据进行过encode处理，而且两个数组的长度也必须一样。

这个我知道，的确有点小奇葩。。。

你需要确保workers=1，两个模型有一样seed的模型才会完全一样。不然的话，会因为并行计算的问题，两个就又乱了。

取整的方法有很多，比如另外一个答案里的astype(int)。此外还有截取np.trunc，向上取整np.ceil，向下取整np.floor，四舍五入取整np.rint。

>>> x
array([[ 1. ,  2.3],
       [ 1.3,  2.9]])
>>> a = np.trunc(x)
>>> a
array([[ 1.,  2.],
       [ 1.,  2.]])
>>> b = np.ceil(x)
>>> b
array([[ 1.,  3.],
       [ 2.,  3.]])
>>> c = np.floor(x)
>>> c
array([[ 1.,  2.],
       [ 1.,  2.]])
>>> d = np.rint(x)
>>> d
array([[ 1.,  2.],
       [ 1.,  3.]])

s = s.astype(np.int)

可以用seaborn和matplotlib一起

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns



N = 100

genders= ['Female', 'Male']

df = pd.DataFrame({

    'Height': np.random.uniform(low=130, high=200, size=N),

    'Weight': np.random.uniform(low=40, high=100, size=N),

    'Gender': np.random.choice(genders, size=N)

})



fg = sns.FacetGrid(data=df, hue='Gender', hue_order=genders)

fg.map(plt.scatter, 'Weight', 'Height').add_legend()

plt.show()

import matplotlib.pyplot as plt

plt.style.use('ggplot')

import pandas as pd

import numpy as np



#随机生成两个dataframe

d1 = pd.DataFrame(columns=['x', 'y'])

d1['x'] = np.random.normal(0, 1, 100)

d1['y'] = np.random.normal(0, 1, 100)

d2 = pd.DataFrame(columns=['x', 'y'])

d2['x'] = np.random.normal(2, 1, 100)

d2['y'] = np.random.normal(2, 1, 100)



#分别画出scatter图，但是设置不同的颜色

plt.scatter(d1['x'], d1['y'], color='blue', label='d1 points')

plt.scatter(d2['x'], d2['y'], color='green', label='d2 points')



#设置图例

plt.legend(loc=(1, 0))



#显示图片

plt.show()

s = '余悲之 且曰 若毒之乎'

print s.count(' ')

my_str = '余悲之 且曰 若毒之乎'

[k for k in range(len(my_str)) if my_str.find(' ', k) == k]

得到[9, 16]，这个是空格的位置

len([k for k in range(len(my_str)) if my_str.find(' ', k) == k])

上面的命令返回2，也就是空格的个数。

for 循环，==空格，自增1

感觉open，close，high，low的顺序不对。

正确的顺序应该是

matplotlib.finance.candlestick2_ochl(ax, opens, closes, highs, lows,

colorup='k', colordown='r')

所以你产生data_list的代码应该是

datas = (t, open, close, high, low)



data_list.append(datas)

random_state就是随机seed，随机种子。因为sklearn中很多算法都含有随机的因素，为了进行可重复的训练，我需要固定一个random_state。

调参的时候是不需要调random_state，相反的是，我们应该先固定random_state，然后再对模型进行调参。

很多模型都需要一个随机的设定（比如迭代的初始值等等）。random_state的作用就是固定这个随机设定。

调参的时候，这个random_state通常是固定好不变的。

df.loc['CH'] = ['中国', '2']

这几个都是naive bayes的模型，区别主要在于特征的分布。

如果特征是数值的，最好是正态分布的数值的，那么用

sklearn.naive_bayes.GaussianNB

如果特征是binary的，那么用

sklearn.naive_bayes.BernoulliNB

如果特征是categorical的，那么用

sklearn.naive_bayes.MultinomialNB

看你的特征的条件概率符合哪种分布，正态分布还是二项分布。

如下可以得到data中25百分位数，50百分位数和75百分位数

import numpy as np

np.percentile(data, [25, 50, 75])

用scipy也可以

>> from scipy.stats import scoreatpercentile

>> scoreatpercentile(range(200), per=[90, 10])

[ 179.1   19.9]

参数per就是你想得到的百分位，返回的是对应的百分位数。

sklearn里应该没有MAPE。

我用numpy自己写一个给你，求点赞，谢谢！

import numpy as np

def MAPE(true, pred):

    diff = np.abs(np.array(true) - np.array(pred))

    return np.mean(diff / true)

当然可以啊，决策树能做回归

随机森林自然就可以做回归

然后，boosting也就可以做回归

那么，xgboost当然可以做回归

可以。不仅可以，而且效果也很牛

参考xgboost回归模型-SofaSofa数据竞赛

这个面试的考点就是中心极限定理和均匀分布吧。一组随机变量的均值符合正态分布。

np.random.uniform()生成的是(0, 1)之间均匀分布的随机数， 2 * np.random.uniform() - 1生成的是(-1, 1)之间均匀分布的随机数。

一个常识是(a, b)的随机均匀分布变量的方差是(a - b)^2 / 12。含有n个样本的样本均值的方差是(a - b)^2 / 12 / n。

import numpy as np
normal_rv = 30 * np.mean(2 * np.random.uniform(size=300) - 1)

上面得到的normal_rv就是一个标准正态分布随机变量。

具体步骤是先产生300个(-1, 1)随机变量，它们的均值的标准差是1 / 30，要得到标准正态分布，所以最前面要乘以30.

让我来静静地装个X，题目要求是近似的正态，其实完全可以精确的正态。Box–Muller变换就能做到这一点。

假设$i.i.d.~X_1, X_2\sim U(0,1)$，也就是服从(0, 1)均匀分布，那么

$$Z=\sqrt{-2\text{ln}(X_1)}\cos(2\pi X_2)$$

就是服从$N(0,1)$标准正态分布的随机变量。上面那个式子就是Box-Muller变换。

iid = (np.mean(np.random.uniform(0,1,n))-0.5)*np.sqrt(12*n)

如果是要检验是否为标准正态分布

import statsmodels.api as sm

import pylab

sm.qqplot(data, line='45')

pylab.show()

如果是检验是否为正态分布（不一定是标准正态分布）

import statsmodels.api as sm

import pylab

sm.qqplot(data, line='s')

pylab.show()

画出来的图差不多是如下

用plt.bar就可以了

import matplotlib.pyplot as plt

plt.bar([2010, 2011, 2012], [10, 15, 20], align='center', alpha=0.5)

plt.show()

如果有兴趣，也可以读一下这个https://pythonspot.com/en/matplotlib-bar-chart/

试试下面这个

import re

print(re.sub("[\s+\.\!\/_,$%^*(+\"\']+|[+——！，。？、~@#￥%……&*（）：]+".decode("utf8"), "".decode("utf8"), s.decode("utf8")))

可以直接用正则表达式

import re



s = ' 文本聚类：使用聚类方法，对词汇，片段，段落或文件进行分组和归类。'

print(re.sub('\W', '', s))

可以用python的正则表达

不知道你整个代码，但是也许是你的目标值的tensor type的问题吧

你试试把你的tensor转成longtensor的类型，比如

my_target = Variable(torch.LongTensor([1]))

比如这样

model = Sequential()

model.add(Dense(512, 512, activation='linear'))

model.add(LeakyReLU(alpha=.001))

from keras import layers

...

model.add(layers.LeakyReLU(alpha=0.1))

F test的原理非常简单，所以不妨自己写

先求出两个样本的方差的比值，再写出两个样本的自由度，然后就去查F分布的概率累计函数，就可以得到p value了。

from scipy.stats import f
F = np.var(a) / np.var(b)
df1 = len(a) - 1
df2 = len(b) - 1
p_value = 1 - 2 * abs(0.5 - f.cdf(F, df1, df2))

我写了个函数

def drop_col(df, col_name, cutoff=0.5):

    n = len(df)

    cnt = df[col_name].count()

    if (float(cnt) / n) < cutoff:

        df.drop(col_name, axis=1, inplace=1)

用的时候，比如说你有一个pandas的dataframe叫df，其中有一列是'col_1'，如果这一列中有50%以上的缺失值，那么就从df中删除这一列

drop_col(df, 'col_1', cutoff=0.5)

如果这一列中有80%以上的缺失值，那么就从df中删除这一列

drop_col(df, 'col_1', cutoff=0.2)

它是指生成一个子节点所需要的最少样本权重。

如果新生成的子节点上的样本权重小于你指定的数，那么这个子节点就不会生长出来。

如果每个样本的权重都是相等的（=1），那么min_child_weight其实就相当于random forest或者decision tree里的min_samples_leaf，也就是产生一个新的子节点所需要的样本数量。

min_child_weight可以看作是一种样本数量的加权和。

可以参考numpy.polyfit

下面就是个用polyfit做三次多项式回归的例子

>>> x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])

>>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])

>>> coef = np.polyfit(x, y, 3)

>>> coef

array([ 0.08703704, -0.81349206,  1.69312169, -0.03968254])

coef是回归系数，按照幂次先高后低排列。

sklearn里没有多项式回归，只能靠自己造轮子了。你需要人工生成那些高次项，比如说你要做一个像

$$Y= a_0 + a_1x + a_2x^2 + a_3x^3$$

的三次多项式回归。那么你就需要人工制造出$x^2$和$x^3$这两个特征，然后再做sklearn里的回归。

可以参考如下

from sklearn.linear_model import LinearRegression

X_new = pd.DataFrame()

X_new['x'] = x

X_new['x2'] = X_new['x'] ** 2

X_new['x2'] = X_new['x'] ** 3

reg = LinearRegression()

reg.fit(X_new, y)

这个问题不是编程的问题，而是统计学中的本质问题，在统计理论中，对非线性回归模型，比如多项式、logsitic回归、对数回归等等，都可以转化为线性回归模型来求解的

所以，这个不是现有程序的问题，而是基本思想的问题

numpy.array可以用来构造任意维度的tensor，而不是局限于矩阵，完全取决于你用了多少括号

>> import numpy as np

>> m = np.array([[[1, 2, 3], [1, 2, 3]], [[1, 2, 5], [1, 2, 5]]])

>> m.shape

(2, 2, 3)

>> m

array([[[1, 2, 3],

        [1, 2, 3]],



       [[1, 2, 5],

        [1, 2, 5]]])

df.sort_values(by=['a' ,'b'], ascending=True, inplace=True)

sklearn里神经网络的方法较少，目前是多层感知机MLP模型，可以参考http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier

在title里设置fontsize参数

plt.plot(x, y)

plt.title('my plot', fontsize=30)

plt.show()

同样fontsize也可以设置在legend，xlabel, ylabel里。

df.to_csv('your_file.csv', mode='a', header=False)

a是append的意思，就是追加在原文件的后面

其实也不一定非要用plt.scatter。

不知道你的数据格式是怎么样的，所以我就用numpy.array做个例子

下面是我自己用plt.plot写了一段

import matplotlib.pyplot as plt; plt.style.use('ggplot')
a = np.random.normal(4, 1, 10)
b = np.random.normal(4, 1, 10)
center = [4, 4]
for point in zip(a, b):
    plt.plot([center[0], point[0]], [center[1], point[1]], marker='o', markersize=15, color='g', alpha=0.4)
plt.show()

效果如下

a = np.random.normal(0, 1, 10)
b = np.random.normal(0, 1, 10)
center = [0, 0]
for point in zip(a, b):
    plt.plot([center[0], point[0]], [center[1], point[1]], marker='o', markersize=15, color='g', alpha=0.4)
a = np.random.normal(4, 1, 10)
b = np.random.normal(4, 1, 10)

center = [4, 4]
for point in zip(a, b):
    plt.plot([center[0], point[0]], [center[1], point[1]], marker='o', markersize=15, color='r', alpha=0.4)
plt.show()

效果如下

希望对你有帮助！

当然有的！sklearn.ensemble.AdaBoostClassifier

参考链接：sklearn文档

调用方法

from sklearn.ensemble import AdaBoostClassifier

clf = AdaBoostClassifier()

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

是drop里的inplace的方式用错了，要么

df.drop('SPID', axis=1, inplace=True)

或者

df = df.drop('SPID', axis=1)

估计是port被占用了，不知道是不是前面的进程出了问题，试试把threads数量调小点，然后读个小数据试试。

sklearn里有sklearn.linear_model.HuberRegressor，想法和sklearn.linear_model.LinearRegression一样的。

至于huberloss的定义，可以查看huber loss是什么？什么时候用？

补充一个来自python自带的模块itertools的accumulate函数，与numpy的cumsum不同的是它会默认返回一个迭代器。而且当传入一个函数时，可以支持求和以外的其它操作：

from itertools import accumulate
>>> list(accumulate([4,2,3]))
[4, 6, 9]
>>> list(accumulate([4,2,3], max))
[4, 4, 4]

numpy里有cumsum，就是累加和的意思

>>> import numpy as np

>>> np.cumsum([1, 2, 1])

array([1, 3, 4])

sklearn官方文档的解释是“The support is the number of occurrences of each class in y_true.”

class I的suppport是k，意思就是说该测试集中有k个样本的真实分类为class i.

所以你上面的表格里class 0 support = 1就是说，测试集里有1个样本的真实标签是class 0.

class 1 support = 1就是说，测试集里有1个样本的真实标签是class 1.

class 2 support = 3就是说，测试集里有3个样本的真实标签是class 2.

sklearn里可以直接计算混淆矩阵sklearn.metrics.confusion_matrix 

from sklearn.metrics import confusion_matrix

confusion_matrix(y_true, y_pred)

也可以通过confusion_matrix函数直接得到TN, FP, FN, TP

tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()

confusion matrix本质上就是列联表，pandas里的crosstab可以得到列联表。参考下面的代码

>> results = pd.DataFrame()

>> results['True'] = [1, 1, 1, 1, 1, 0, 0, 0]

>> results['Pred'] = [1, 1, 0, 0, 1, 1, 0, 0]



# 用pd.crosstab可以得到confusion matrix

>> pd.crosstab(results['True'], results['Pred'])



Pred	0	1

True		

0	2	1

1	2	3

需要用到python的matplotlib包，如下：

# -*- coding:utf-8 -*-  

import numpy as np  

import matplotlib.mlab as mlab  

import matplotlib.pyplot as plt  

  

mu = 100  # 正态分布的均值  

sigma = 15  # 标准差  

x = mu + sigma * np.random.randn(10000)#在均值周围产生符合正态分布的x值  

  

num_bins = 50  

n, bins, patches = plt.hist(x, num_bins, normed=1, facecolor='green', alpha=0.5)  

#直方图函数，x为x轴的值，normed=1表示为概率密度，即和为一，绿色方块，色深参数0.5.返回n个概率，直方块左边线的x值，及各个方块对象  

y = mlab.normpdf(bins, mu, sigma)#画一条逼近的曲线  

plt.plot(bins, y, 'r--')  

plt.xlabel('Smarts')  

plt.ylabel('Probability')  

plt.title(r'Histogram of IQ: $\mu=100$, $\sigma=15$')#中文标题 u'xxx'  

  

plt.subplots_adjust(left=0.15)#左边距  

plt.show()  

得到图形为：

用sns.displot是最简单，最方便的

import seaborn as sns

import numpy as np

import matplotlib.pyplot as plt



sns.distplot(np.random.normal(0, 1, 1000), bins=30)

plt.show()

前几天在折腾贝叶斯网络的时候刚好发现一个包pomegranate（http://pomegranate.readthedocs.io/en/latest/HiddenMarkovModel.html#hiddenmarkovmodel），好像支持隐马尔可夫模型的拟合还有预测的样子，楼主看看是不是你想要的。

试试hmmlearn和pymc

off一下就关掉了

plt.plot(a, b)

plt.axis('off')

plt.show()

df = DataFrame(cnts.items(), columns=['key', 'cnt'])

df = pd.DataFrame.from_dict(cnts, orient='index').reset_index()
df.columns = ['key', 'cnts']

y_true = [0, 0, 0, 1, 1, 1, 1, 1]
y_pred = [0.1, 0.3, 0.6, 0.2, 0.4, 0.8, 0.5, 0.9]

fpr, tpr, _ = sklearn.metrics.roc_curve(y_true,  y_pred)
plt.figure(figsize=(6, 6))
plt.axis([0, 1, 0, 1])
plt.plot(fpr, tpr)
plt.show()

numpy.random.choice

import numpy as np

>> a = [1, 3, 5]

>> np.random.choice(a, size=10, replace=True)

array([3, 3, 5, 5, 5, 1, 3, 3, 1, 5])

>>> from random import choices

>>> colors = ["R", "G", "B"]

>>> choices(colors, k=4)

['G', 'R', 'G', 'B']

要在with tf.Session()里才能查看tensor里的数值

a = tf.random_normal([2, 3])

with tf.Session():

    print(a.eval())

如果你对原先的dataframe先进行slicing或者indexing，然后赋值，都会出现SettingWithCopyWarning。

情形一

d[d['col_1'] == 0]['col_2'] = 1

会出现警告

SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

解决方法，

使用loc或者iloc

d.loc[d['col_1'] == 0, 'col_2'] = 1

情形二

先从原dataframe取出一个子dataframe，然后再对其中的元素赋值，例如

s = d[d['col_1'] == 0]
s.loc[:, 'col_2'] = 1

就会出现

SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

解决方法，

对子datafame先进行copy，然后再赋值

s = d[d['col_1'] == 0].copy()
s.loc[:, 'col_2'] = 1

尝试用iloc或者loc来索引，比如

# 替换'norm'列
df.loc[:,'norm'] = np.random.randn(10)

# 替换第十列
df.iloc[:,10] = np.random.randn(10)

设置plt.bar里的bottom参数，可以达到堆积叠加效果

x = [1, 2, 3]

y1 = np.array([2, 3, 2])

y2 = np.array([3, 1, 5])

y3 = np.array([1, 2, 1])

plt.bar(x, y1, color='green', label='y1')

plt.bar(x, y2, bottom=y1, color='red', label='y2')

plt.bar(x, y3, bottom=y1+y2, color='blue', label='y3')

plt.legend(loc=[1, 0])

plt.show()

# ipython@python3环境

import pandas as pd
import numpy as np

with open('~/train.csv') as f:
    data = pd.read_csv(f)

X = data.drop(['y','id'], axis=1)
X = np.array(X)

#  每一行代表一张图片，选取第一行。
pic1 = X[1]
# 图片分辨率是40*40
pic1 = pic1.reshape((40, 40))

# 绘图
%matplotlib inline
from matplotlib import pyplot as plt
# 传入cmap='gray'指定图片为黑白
plt.imshow(pic1, cmap='gray')

另外补充一下，如果是彩色图片，在reshape的时候需要设置成三维，分别代表每个像素点RGB三种配色的取值：

pic1.reshape((height, width, 3))

import matplotlib.pyplot as plt

plt.imshow(my_figure, cmap=plt.cm.binary)

plt.show()

# 设置背景色为粉色

plt.rcParams['axes.facecolor'] = 'pink'

# 作图

plt.plot([0, 2], [2, 3])

# 显示

plt.show()

在默认的情况下 StandardScaler就是减去均值，然后除以标准差

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()

相当于$$\frac{原始数值-均值}{标准差}$$

当然在StandardScaler中也可以设置参数with_mean和with_std

from sklearn.preprocessing import StandardScaler
sc = StandardScaler(with_mean=False)

等价于$$\frac{原始数值}{标准差}$$

类似地

from sklearn.preprocessing import StandardScaler
sc = StandardScaler(with_std=False)

等价于$${原始数值-均值}$$

一般理解为步长、跨度或者步幅。稍微具体一点说就是window或者filter每次跨越的距离。

这个其实算是cnn里的基础概念，可以先试着理解一点背景，然后再去理解tensorflow或者其他package是如何使用这些网络的。

先把它转为时间对象

df['time'] = pd.to_datetime(df['time'])

然后再对time这列排序

df.sort_values('time', inplace=True)

请参考这个https://github.com/nicodv/kmodes

安装完之后，用法如下

import numpy as np

from kmodes.kmodes import KModes



# random categorical data

data = np.random.choice(20, (100, 10))



km = KModes(n_clusters=4, init='Huang', n_init=5, verbose=1)



clusters = km.fit_predict(data)



# Print the cluster centroids

print(km.cluster_centroids_)

用seaborn里的heatmap可以画出热图

import matplotlib.pyplot as plt

import seaborn as sns

import numpy as np

生成一个随机矩阵a，并画出热图

a = np.random.uniform(0, 1, size=(10, 10))

sns.heatmap(a, cmap='Reds')

plt.show()

也可以用不同的颜色

a = np.random.uniform(0, 1, size=(10, 10))

sns.heatmap(a, cmap='GnBu')

plt.show()

使用seaborn 中的heatmap来画，

seaborn是画图的库，比matplotlib.pyplot高级，易用一些。

import matplotlib.pyplot as plt

import numpy as np



a = np.random.random((16, 16))

plt.imshow(a, cmap='hot', interpolation='nearest')

plt.show()

效果如下

pyecharts可以画出比较漂亮的图，而且是可以交互的下面是官方文档

官方文档

这个很简单啊

df2 = df1.copy()

from sklearn.linear_model import SGDClassifier

clf = SGDClassifier()

clf.fit(X, y)

#得到回归系数

coefs = clf.coef_

#得到截距

intercept = clf.intercept_

python里的除号/是默认是整除

>>> 3 / 2

1

加上了上面那一段，除号/就变成了正常的小数除法了

>>> from __future__ import division

>>> 3 / 2

1.5

python3里不需要了，因为除法自然就是得到小数的

这段代码的意思就是在使用Python2的时候把高版本的Python3的特性引进当前版本中。

不大明白你的意思和销魂的换行，哈哈哈

你是批量修改一个csv文件中所有的列名吗？

-----更新-----

比如你有3个DataFrame，你要批量修改列名，比如第k个DataFrame的列都有后缀_k。

dfs = {0: df0, 1: df1, 2: df2}
for i in range(3):
     cols = list(dfs[i].columns)
     dfs[i].columns = map(lambda x: str(x) + '_%s'%i, cols)

emmmm 用pandas读取csv 之后用columns属性 得到包含所有列名的列表 就可以了吧

方差检验，当然还是上spss，利器

my_array.ndim

可以返回一个array的dimension的个数

len(my_array.shape)

可以参考这个ppt

讲的就是用贝叶斯方法来调参

def krrcv(

		alpha,

		degree,

		coef0,

		):

		

	params['alpha'] = max(alpha, 0)

	params['degree'] = max(degree, 0)

	params['alpha'] = max(alpha, 0)

	data=train_df

	target=y_train_df

	val=cross_val_score(KernelRidge(params),data,target,scoring='r2',cv=5).mean()

	return val

krrBO=BayesianOptimization(krrcv,{

				        'alpha':(0,1),

					'degree':(0,4),

				        'coef0':(0,5)

					})

					

这是我目前用贝叶斯网络优化 KRR的参数，但是总是出错，比如

TypeError: ufunc 'add' output (typecode 'O') could not be coerced to provided ou

tput parameter (typecode 'd') according to the casting rule ''same_kind''

网上参考的代码太少了，希望能够得到帮助！

>>> from datetime import date

>>> delta = date.today() - date(2017,1,1)

>>> delta.days
387

>>> import pandas as pd

>>> t1 = pd.to_datetime('2017-10-01')

>>> t2 = pd.to_datetime('2018-02-01')

>>> (t2 - t1).days

123

# 引用numpy模块
import numpy as np

#求数组a的中位数
np.median(a)

#求数组a的四分位数
np.percentile(a, [25, 50, 75])

试试

plt.legend( bbox_to_anchor=(1,1), loc='center left')

我都是用

plt.legend(loc=[1, 0])

numpy.linalg.matrix_rank(M)可以用求秩

>>> import numpy as np

>>> A = np.array([[1, 1], [2, 2]])

>>> A

array([[1, 1],

       [2, 2]])

>>> np.linalg.matrix_rank(A)

1

sequential model就是那种最简单的结构的模型。按顺序一层一层训练，一层一层往前的那种。没有什么环的结构。比如像前馈网络那样。

就像下图这样的，一层层的那种。

keras中定义模型的方法之一，一层层线性叠加的网络架构。另一种方法是通过函数式API可以构建任意形式的架构

sklearn.metrics.cohen_kappa_score(y1, y2, labels=None, weights=None, sample_weight=None)

这个挺简单的。

import numpy as np

def mse(y_real, y_pred):

    return np.mean((y_real - y_pred) ** 2)

sklearn里明明有现成的。

sklearn.metrics.mean_squared_error(y_true, y_pred, sample_weight=None, multioutput=’uniform_average’)

>>> a = np.array([1, 2, 3])

>>> a = a.reshape(-1, 1)

>>> a

array([[1],

       [2],

       [3]])

row_vec = np.array([1, 2, 3])

col_vec = np.array([row_vec]).T

注意row_vec外面的方括号，必须要有

试试

plt.rc('axes', axisbelow=True)

sklearn里就有啊

sklearn.discriminant_analysis.LinearDiscriminantAnalysis

label encoder就是把lable编码的。比如label是一串地名，是无法直接输入到sklearn的分类模型里作为训练标签的，所以需要先把地名转成数字。然后LabelEncoder就是帮你做这件事的。

>>> from sklearn import preprocessing

>>> le = preprocessing.LabelEncoder()

>>> le.fit(["paris", "paris", "tokyo", "amsterdam"]);

>>> le.transform(["tokyo", "tokyo", "paris", "amsterdam", "amsterdam"]) 

array([2, 2, 1, 0, 0])

把一些没什么上下文联系的文本转换成能作为input的数字，不然都没把文本输入到模型里去

再做特征工程时,我们需要处理已有特征,对于分类特征通常有两种处理方案:

• 自然数编码

使用sklearn中的LabelEncoder方法,转换为数值型特征

• 独热编码(one-hot encoding)

生成一个(n_examples * n_classes)大小的0~1矩阵，每个样本仅对应一个label

可以使用pandas中的get_dummies实现

用plt.text(x, y, your_text)，x是文字起始点的横坐标，y是文字的纵坐标。

import matplotlib.pyplot as plt



plt.plot([0, 2], [0, 2])

plt.text(0.5, 1, 'put some text')

plt.show()

设置plt.scatter里的marker属性

>>> import matplotlib.pyplot as plt

>>> plt.style.use('ggplot')

>>> plt.scatter([0, 2, 4], [0, 1, 2], s=80, lw=2, marker='+', color='red', label='Positive')

>>> plt.scatter([1, 3, 5], [2, 1, 0], s=80, lw=2, marker='_', color='green', label='Negative')

>>> plt.legend(loc=(1, 0.8))

>>> plt.show()

目测是你的y_pred出了问题，你的y_pred是(900, 2)的array，也就是有两列。

因为predict_proba返回的是两列。predict_proba的用法参考这里。

简而言之，你上面的代码改成这样就可以了。

y_pred = clf.predict_proba(X_test)[:, 1]

roc_auc = roc_auc_score(y_test, y_pred)

moving_mean = df['a'].rolling(window=3).mean()

pandas里的rolling可以用rolling sum也可以rolling mean

这个问题出现过一次。看这里。

比如一个pd.DataFrame，变量名为df，可以用df.info()和df.describe()

df.info()返回这个dataframe的基本信息，比如以iris数据集为例，150行，5列，每列的列名等等。

>>> df.info()

df.describe()可以返回每一列更具体的信息，比如均值、方差、四分位等等。

>>> df.describe()

>>> df.describe()

可以用head来查看一个dataframe的前几行，你就知道基本信息了

>>> df.head()

mantora您好，感谢您的提问！为了方便其他朋友更好地理解您的问题，您的标题已经被修改。

--------我试着回答您的问题--------

针对于您的问题，建议你检查class_id两端是否有空格。有时候空格会造成不匹配。

其次一个方法，我注意到class_id是您的第二列，所以可以试试

print(train.columns[1])
y_train = train.pop(train.columns[1])

建议你看看官方文档呀

pop一个列，pop完之后这个列就会被删掉。如果pop一个不存在的列，就KeyError。

你pop之前有这个column吗？因为pop之后，这个column就被删除了，所以你不能反复调用pop这个语句的。

万能的matplotlib里有pie函数，可以直接画饼图。

labels = ['Cookies', 'Jellybean', 'Milkshake', 'Cheesecake']

sizes = [38.4, 40.6, 20.7, 10.3]

plt.pie(sizes, labels=labels, autopct='%1.1f%%')

plt.legend(loc=[0.9, 0.6])

plt.axis('equal')

plt.show()

如果数据是pandas的类型，那么画饼图更容易

import pandas as pd

import matplotlib.pyplot as plt

plt.style.use('ggplot')



df = pd.DataFrame({'Country': ['china', 'india', 'usa'], 'Population': [14, 13, 3]})



df.Population.groupby(df.Country).sum().plot(kind='pie')

plt.axis('equal')

plt.legend()

plt.show()

方法一：

from sklearn.datasets import load_iris

import pandas as pd

import numpy as np



iris = load_iris()

df = pd.DataFrame(iris.data, columns=iris.feature_names)

方法二：

iris数据在UCI网站上也有，可以从网站上导入

import pandas



url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"



names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']



dataset = pandas.read_csv(url, names=names) #读取csv数据

如果你需要把y列也放进dataframe里的话

from sklearn import datasets

import pandas as pd

import numpy as np



iris = datasets.load_iris()

col_names = iris['feature_names'] + ['target']

data = pd.DataFrame(data= np.c_[iris['data'], iris['target']], columns=col_names)

设置最多可显示的列数。下面的代码设置最多显示100列。

pd.options.display.max_columns = 100

也可以取消限制，比如设置为None。

pd.options.display.max_columns = None

转置之后呢

这个的确没有好的解决方法。

一个比较笨的方法是写一个函数，根据给定的颜色和alpha自动计算出透明化之后的RGB。

可以参考calculate RGB with given alpha

试试pystruct

的确好像没见过beta regression的python包。

搜了一下之后就只发现了这个betareg.py

如果你也会R的话，R里面倒是有library

R packages betareg

以及参考文献

所谓曲线(curve)实际上就是一堆散点，散点下方的面积和就是AUC。

梯形法则，就是说把一个个小面积看作梯形，然后auc就是这些梯形的面积和。

此外还有矩形法则，auc就是矩阵面积的和。

当然，我们肉眼也能判断，梯形法则得到的面积更精确一些。

梯形法则：百度百科

就是用线性插值法计算面积。

两者都可以。

但要注意，输入sklearn 的必须是数值型数据

一般来说把df格式的转换成矩阵储存形式比较好，这样就能和np的计算函数一起用了，同时的np的array形式可以赋值到dataframe

你的fit里的那个categorical_feature是不应该有的，因为fit()里就没有这个参数。

官方的文档里只有下面几个参数

fit(X, y, sample_weight=None, eval_set=None, eval_metric=None, 

early_stopping_rounds=None, verbose=True, xgb_model=None)

建议你把categorical_feature这个去掉再试试。

>>> from keras.datasets import mnist

>>> (train_images, train_labels), (test_images, test_labels) = mnist.load_data()

你可以直接到MNIST官方网站下载。

然后再用python读进来。

我自己想明白了，应该是直接用多元正态分布比较好

numpy.random.multivariate_normal

n_init就是初始化的次数。

为什么要多次初始化呢？

因为k means无法达到全局最优，每次收敛到最后的结果是局部最优，所以就需要跑很多次独立初始化的k means，比如说n_init=10就是跑10次。然后从这10次里面选最优的那个。

不同初始化只取决于不同的初始点，也就是初始质心。

k means无法保证收敛到最优解，所以要反复进行，选择当中最优的。

n_init就是重复进行k means的次数。

legend里有一个参数是bbox_to_anchor，接受tuple给的坐标，可以指定任意位置

相同的问题

matplotlib.pyplot中怎么把legend放到图片外面去？

我都是用

plt.legend(loc=[1, 0])

scipy里的entropy实际上就可以计算Kullback–Leibler divergence

>>> from scipy.stats import entropy

>>> entropy(p, q)

@sasa 写了二项分布的情况，其实KL还可以做两个高斯分布的情况

假设两个高斯分布$p:N(\mu_1, \sigma_1^2)$，$q:N(\mu_2,\sigma_2^2)$，这两个高斯分布的KL divergence就等于

$$\text{KL}(p,q)=\log\frac{\sigma_2}{\sigma_1}+\frac{\sigma_1^2+(\mu_1-\mu_2)^2}{2\sigma_2^2}-\frac{1}{2}$$

上面的式子用python很好写的

完全不影响结果，最多影响显示和输出。

用过jupyter notebook的都知道，每个cell只会显示最后一个输出结果，除非用print。例如

x = 3
x
x ** 2

Jupiter notebook中会显示

9

3不会被显示出来。题主问的这段代码

from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"

的作用就是让全部结果都显示出来。设置完之后，最上面那段代码的结果就是

3
9

设置as_index=False就可以了

train.groupby(['is_workday', 'weather'], as_index=False)['y'].mean()

效果如下

.reset_index()可以不

那个远程的程序是你自己写的不？如果是的话就方便多啦

我一般都是在程序先写好了代码，自动把图片、数据都存放在服务器的临时文件夹里。跑完之后，把文件（图片、数据）scp回自己的笔记本。用完了之后再把服务器里临时存放的给删掉。

室外和体感做斜率是什么意思？

这种错误

RuntimeError: Invalid DISPLAY variable

可以在import的时候试试下面的代码，加上agg

import matplotlib.pyplot as plt

plt.switch_backend('agg')

你的目的是？判断下一帧是三种类型的哪一种吗？

为什么只用初始概率和状态转移矩阵呢？我觉得音频本身的信息更重要啊

把它们的信息结合在一起然后搞个时间序列模型应该是不错的选择

用np.vstack就可以了

np.vstack([a, new_row])

例如

>>> a

array([[1, 2, 3],

       [4, 5, 6],

       [7, 8, 9]])

>>> new_row = [1, 5, 9]

>>> b = np.vstack([a, new_row])

>>> b

array([[1, 2, 3],

       [4, 5, 6],

       [7, 8, 9],

       [1, 5, 9]])

>>> import numpy as np

>>> a=np.array([[1,2],[3,4]])

>>> b=np.array([[5,6],[7,8]])

>>> c=np.concatenate((a,b),axis=0)

>>> c

array([[1, 2],

       [3, 4],

       [5, 6],

       [7, 8]])

>>> c=np.concatenate((a,b),axis=1)

>>> c

array([[1, 2, 5, 6],

       [3, 4, 7, 8]])

>>> 

肯定是id超过了train_output_names这个list的长度了吧，你可以用try debug，比如

try:

    output_image = load_image(train_output_names[id])

except:

    print('error id: %s'%id)

然后你再看看自己哪里写错了

df = my_spark_df.toPandas()

第一个例子中

tf.placeholder(tf.float32, shape=(None, 1024))

1024是指的数据的尺寸，None指的batch size的大小，所以可以是任何数。

第二个例子里

tf.placeholder(tf.float32, shape=[None, img_height, img_width, channels])

类似地，后面几个是图片尺寸的参数，第一个参数为None，表示batch size的大小。

举个例子，假如我有一个文件a.txt，然后按行来读取。

# 读取a.txt
>>> with open('a.txt') as f:
        content = f.readlines()
>>> content
['Today is good.\n', 'Tomorrow is good.\n', 'Yesterday was bad.\n', 'See you.']
>>>
# 打乱content中的顺序
>>> import random
>>> random.shuffle(content)
>>> content
['Yesterday was bad.\n', 'See you.', 'Today is good.\n', 'Tomorrow is good.\n']

你意思是划分数据集？sklearn中有

from sklearn.model_selection import train_test_split

可以随机划分数据集。

如果不是划分数据集。那么可以使用random随机函数，就可以打乱行数了。多使用python

# -*- coding: utf-8 -*-

from matplotlib import pyplot as plt

import numpy as np

from mpl_toolkits.mplot3d import Axes3D

data = np.random.randint(0, 255, size=[40, 40, 40])
x, y, z = data[0], data[1], data[2]
ax = plt.subplot(111, projection='3d')  # 创建一个三维的绘图工程
#  将数据点分成三部分画，在颜色上有区分度
ax.scatter(x[:10], y[:10], z[:10], c='y')  # 绘制数据点
ax.scatter(x[10:20], y[10:20], z[10:20], c='r')
ax.scatter(x[30:40], y[30:40], z[30:40], c='g')
ax.set_zlabel('Z')  # 坐标轴
ax.set_ylabel('Y')
ax.set_xlabel('X')
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D



# 生成数据

data = np.random.randint(0,255,size=[40,40,40])

x,y,z= data[0],data[1],data[2]



# 创建三维对象

fig= plt.figure()

ax = Axes3D(fig)



# 绘制散点图

ax.scatter(x[:10],y[:10],z[:10],c='y')

ax.scatter(x[10:20],y[10:20],z[10:20],c='r')

ax.scatter(x[30:40],y[30:40],z[30:40],c='g')



# 显示图像

plt.show()

df.count()

nltk我不知道有没有这个轮子，不过这个就是拿来做文本

自己去看下官方文档，说不定就有

sklearn里也有的

from sklearn.feature_extraction.text import CountVectorizer 

text = "this is a foo bar sentences and i want to ngramize it"

vectorizer = CountVectorizer(ngram_range=(1,6))

analyzer = vectorizer.build_analyzer()

print(analyzer(text))

仅供参考

有两种方法

spark_df.schema.names

或者

spark_df.columns

df.printSchema()

X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
test_fold = [0, 1, -1, 1]

test_fold 长度和训练集相同。

-1所在的index只放在train_set里。

其他的数字，每一轮选一个数字，该数字所在的所有index作为test_set。

比如说第一轮，数字0所在的位置作为test_set，即X[0]；

第二轮，数字1所在的位置作为test_set,即X[1],X[3]。

http://blog.niuhemoon.xyz/pages/2018/04/08/word-cloud-doc-cn/

https://github.com/amueller/word_cloud

https://github.com/2niuhe/lyrics_wordcloud

参考wordcloud

from wordcloud import WordCloud

wordclound

这个叫非负最小二乘回归。sklearn.linear_model.Lasso里可以设置positive=True来使得系数都为正。如果你不需要正则化的话就把alpha设成0或者很小的数。

from sklearn.linear_model import Lasso

model = Lasso(alpha=0.00001, positive=True)

model.fit(X,y)

这是带不等式条件的二次规划（Quadratic Programming）

$argmin_{w}{|Xw-y|^2} s.t. w>0$，

可以用http://cvxopt.org/examples/tutorial/qp.html

https://scaron.info/blog/quadratic-programming-in-python.html

选择第一列到倒数第二列就可以了

a = a[:, :-1]

删除最后一列

my_array = np.delete(my_array, -1, axis=1)

删除第一列

my_array = np.delete(my_array, 0, axis=1)

我在github上找到一个解决方案，步骤如下

1. 先去这里找到你对应的版本的whl文件，比如你是python3.6，64位windows，那么就下载wordcloud‑1.4.1‑cp36‑cp36m‑win_amd64.whl

2. 到你这个下载文件所在的文件夹里面，在你的command prompt里面输入

python -m pip install wordcloud‑1.4.1‑cp36‑cp36m‑win_amd64.whl

然后就应该安装完毕了

使用open来读文件，然后统计多少行。

def lineNumber(filename) :

    with open(filename) as lines :

        return len(lines.readlines())

readlines  

或者dataframe

sum(1 for line in open(`filename`).readlines())

印象中在stack overflow上见过同样的问题

请看官方文档

作用：

把一个array限制在一定范围内

例如，a被限制在了3到8的范围内：

>>> a =[2, 3, 1, 4, 10, 9]

>>> np.clip(a, 3, 8)

array([3, 3, 3, 4, 8, 8])

np.clip对高维的numpy.ndarray也是有效的。