Python中库的调用

import sklearn

数据集的划分

sklearn.model_selection.train_test_split(arrays, *options)

x 数据集的特征值
y 数据集的标签值
test_size 测试集的大小，一般为float
random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
return 测试集特征训练集特征值值，训练标签，测试标签(默认随机取)
一般使用为

x_train, x_test, y_train, y_test = train_test_split(data, target, random_state = 22)

其中 data为自变量集 target为因变量

特征工程

字典特征提取

from sklearn.feature_extraction import DictVectorizer
transfer = DictVectorizer(sparse=True) # 实例化转换器类
data = transfer.fit_transform(data) # 类似独热编码

sparse为True为使用传统独热编码
为False为使用向量说明当前位置用于节省空间加快运行效率

data_dure = pd.get_dummies(data2, columns=['...']) # 独热编码 columns为剔除无关项

文本特征提取

英文

from sklearn.feature_extraction import DictVectorizer
transfer = CountVectorizer() # 实例化 sparse 默认为True
data = transfer.fit_transform(data) # 调用

例如

transfer = CountVectorizer()
data = transfer.fit_transform(data) # 调用fit_transform

对于

data = ["life is short,i like like python", "life is too long,i dislike python"]

输出结果为

文本特征抽取的结果：
[[0 1 1 2 0 1 1 0]
[1 1 1 0 1 1 0 1]]
返回特征名字：
[‘dislike’, ‘is’, ‘life’, ‘like’, ‘long’, ‘python’, > ‘short’, ‘too’]

即对应字母在句子中出现的次数

中文 jieba分词处理

对于

data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。","我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。","如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]

对其进行

text_list = []
for sent in data:
    text_list.append(cut_word(sent))

text = " ".join(list(jieba.cut(text))) # 使用jieba对中文字符串进行分词

transfer = CountVectorizer() # 实例化转换器
data = transfer.fit_transform(text_list)

类似地得到

文本特征抽取的结果：
[[2 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 1 0]
[0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 0 1]
[1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0 0]]
返回特征名字：
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出',
'取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放
弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝
对', '美好', '联系', '过去', '还是', '这样']

Tf-idf文本特征提取

能够自动获取关键词
TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的概率高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。
TF-IDF作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。
可提取出更具有分类意义的词
对于

data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]

对其进行

# 使用jieba处理文本
import jieba
text_list = []
for sent in data:
    text_list.append" ".join(list(jieba.cut(sent))))

from sklearn.feature_extraction.text import TfidfVectorizer
transfer = TfidfVectorizer(stop_words=['一种', '不会', '不要']) # 实例化转换器 stop为去掉的词?
data = transfer.fit_transform(text_list)

其结果为

文本特征抽取的结果：
[[ 0. 0. 0. 0.43643578 0. 0. 0.
0. 0. 0.21821789 0. 0.21821789 0. 0.
0. 0. 0.21821789 0.21821789 0. 0.43643578
0. 0.21821789 0. 0.43643578 0.21821789 0. 0.
0. 0.21821789 0.21821789 0. 0. 0.21821789
0. ]
[ 0.2410822 0. 0. 0. 0.2410822 0.2410822
0.2410822 0. 0. 0. 0. 0. 0.
0. 0.2410822 0.55004769 0. 0. 0. 0.
0.2410822 0. 0. 0. 0. 0.48216441
0. 0. 0. 0. 0. 0.2410822
0. 0.2410822 ]
[ 0. 0.644003 0.48300225 0. 0. 0. 0.
0.16100075 0.16100075 0. 0.16100075 0. 0.16100075
0.16100075 0. 0.12244522 0. 0. 0.16100075
0. 0. 0. 0.16100075 0. 0. 0.
0.3220015 0.16100075 0. 0. 0.16100075 0. 0.
0. ]]
返回特征名字：
['之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天',
'含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星
系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过
去', '还是', '这样']

特征预处理

归一化

通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程
将数据压缩至一个既定范围内
使得特征都能被学习到

sklearn.preprocessing.MinMaxScaler()

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

data = pd.read_csv("dating.txt")
transfer = MinMaxScaler(feature_range=(2, 3)) # 实例化转换器类
data = transfer.fit_transform(data[['milage', 'Liters', 'Consumtime']])

标准化

剔除异常值的影响
适合目前大数据场景

sklearn.preprocessing.StandardScaler( )

transfer = StandardScaler()
data = transfer.fit_transform(data[['milage','Liters','Consumtime']])

特征降维

降维是指在某些限定条件下，降低随机变量(特征)个数，得到一组“不相关”主变量的过程
降低随机变量的个数

sklearn.feature_selection

特征选择

Filter过滤式

主要探究特征本身特点、特征与特征和目标值之间关联
方差选择法：低方差特征过滤

sklearn.feature_selection.VarianceThreshold(threshold = 0.0) # 删除所有低方差特征

使用例如

transfer = VarianceThreshold(threshold=1)
data = transfer.fit_transform(data.iloc[:, 1:10])

iloc为指定位置先行再列

主成分分析(PCA) PCA降维

定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量
作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。
应用：回归分析或者聚类分析当中

sklearn.decomposition.PCA(n_components = None)

对于n_components：
小数：表示保留百分之多少的信息
整数：减少到多少特征
例如

from sklearn.decomposition import PCA
transfer = PCA(n_components = 0.9) # 保留90%的信息
data1 = transfer.fit_transform(data)
transfer2 = PCA(n_components=3) # 减少到3个特征
data2 = transfer2.fit_transform(data)

合并表

import pandas as pd
result = pd.merge(csv1, csv2, on = [test1, test2]) # 将csv1中的tset1和csv2的test2在一张表中 按索引进行合并

sklearn转换器和预估器

转换器

特征工程的接口称之为转换器
有以下三种
fit_transform
fit
transform
其差别如以下

In [1]: from sklearn.preprocessing import StandardScaler
In [2]: std1 = StandardScaler()
In [3]: a = [[1,2,3], [4,5,6]]
In [4]: std1.fit_transform(a)
Out[4]:array([[-1., -1., -1.],[ 1., 1., 1.]])
In [5]: std2 = StandardScaler()
In [6]: std2.fit(a)
Out[6]: StandardScaler(copy=True, with_mean=True, with_std=True)
In [7]: std2.transform(a)
Out[7]:array([[-1., -1., -1.],[ 1., 1., 1.]])

可知fit_transform的作用相当于transform加上fit
fit方法可看作训练

估计器

sklearn机器学习算法的实现
调用.fit()进行计算生成model\

模型评估方法:
1)直接对比真实值与预测值\

y_predict = estimator.predict(x_test)
if y_test == y_predict

2)利用公式计算\

accurary = estimator.score(x_test, y_test)

分类算法

KNN算法

核心思想:根据邻居确定类别
可能出现的问题:
k过小容易收到异常点影响
k过大容易收到样本不均匀影响
需要做无量纲化处理——标准化

sklearn.neighbors.KNeighborsClassifier(n_neighbors = 5, algorithm = 'auto')

· n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数
· algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

使用案例——鸢尾花分类

-> knn_demo.ipynb

模型选择和调优

交叉验证

将拿到的训练数据，分为训练和验证集。以下图为例：将数据分成5份，其中一份作为验证集。然后经过5次(组)的测试，每次都更换不同的验证集。即得到5组模型的结果，取平均值作为最终结果。又称5折交叉验证。
交叉验证目的：为了让被评估的模型更加准确可信

超参数搜索——网格搜索

获取最佳参数(超参数)-(如KNN中的K值)\

sklearn.model_selection.GridSearchCV(estimator, param_grid = None,cv = None)

对估计器的指定参数值进行详尽搜索
estimator：估计器对象
param_grid：估计器参数(dict){“n_neighbors”:[1,3,5]}
cv：指定几折交叉验证类似epoch
fit：输入训练数据
score：准确率
输出结果为

bestscore:在交叉验证中验证的最好结果
bestestimator：最好的参数模型
cvresults:每次交叉验证后的验证集准确率结果和训练集准确率结果

例如

knn = KNeighborsClassifier()
param = {"n_neighbors": [3, 5, 10]}
gc = GridSearchCV(knn, param_grid=param, cv=2)
gc.fit(x_train, y_train)
print("选择了某个模型测试集当中预测的准确率为：", gc.score(x_test, y_test))
# 训练验证集的结果
print("在交叉验证当中验证的最好结果：", gc.best_score_)
print("gc选择了的模型K值是：", gc.best_estimator_)
print("每次交叉验证的结果为：", gc.cv_results_)

朴素贝叶斯算法

sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
朴素贝叶斯分类
各结论之间相互独立使用贝叶斯公式
alpha：拉普拉斯平滑系数
优点：
朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
对缺失数据不太敏感，算法也比较简单，常用于文本分类。
分类准确度高，速度快
缺点：
朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
对缺失数据不太敏感，算法也比较简单，常用于文本分类。
分类准确度高，速度快

决策树

class sklearn.tree.DecisionTreeClassifier(criterion = 'gini', max_depth=None, random_state=None)

criterion:默认是’gini’系数，也可以选择信息增益的熵’entropy’
max_depth:树的深度大小
random_state:随机数种子
其中会有些超参数如max_depth:树的深度大小等
优点：
简单的理解和解释，树木可视化。
可解释能力强
缺点：
决策树学习者可以创建不能很好地推广数据的过于复杂的树，这被称为过拟合。

决策树可视化

sklearn.tree.export_graphviz()
例如

tree.export_graphviz(estimator,out_file='tree.dot',feature_names=[","])

此处可使用graphviz工具进行树可视化
ubuntu下使用sudo apt-get install graphviz Mac:brew install graphviz
使用dot -Tpng tree.dot -o tree.png将dot转换为png或jpg

随机森林

包含多个决策树的分类器
训练集随机特征随机

class sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion = 'gini', max_depth = None, bootstrap = True, random_state = None, min_samples_split = 2)

n_estimators：integer，optional（default = 10）森林里的树木数量
120,200,300,500,800,1200
criteria：string，可选（default =“gini”）分割特征的测量方法
max_depth：integer或None，可选（默认=无）树的最大深度 5,8,15,25,30
max_features=”auto”,每个决策树的最大特征数量
If “auto”, then max_features=sqrt(n_features) .
If “sqrt”, then max_features=sqrt(n_features) (same as “auto”).
If “log2”, then max_features=log2(n_features) .
If None, then max_features=n_features .
bootstrap：boolean，optional（default = True）是否在构建树时使用放回抽样
min_samples_split:节点划分最少样本数
min_samples_leaf:叶子节点的最小样本数
其中存在超参数：n_estimator, max_depth, min_samples_split, min_samples_leaf
优点：
在当前所有算法中，具有极好的准确率
能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维
能够评估各个特征在分类问题上的重要性

回归和聚类算法

线性回归

线性回归概念

线性模型：自变量为一次或参数为一次
但仅参数为一次非线性关系
线性关系一定为线性模型
线性模型不一定为线性关系

优化算法

正规方程

公式求解
缺点：当特征过多过复杂时，求解速度太慢并且得不到结果

梯度下降

面对训练数据规模十分庞大的任务，能够找到较好的结果

API

# 正规方程
sklearn.linear_model.LinearRegression(fit_intercept = True)

fit_intercept：是否计算偏置
LinearRegression.coef_：回归系数
LinearRegression.intercept_：偏置

# 梯度下降
sklearn.linear_model.SGDRegressor(loss = "squared_loss", fit_intercept = True, learning_rate = 'invscaling', eta0=0.01)

loss:损失类型
loss=”squared_loss”: 普通最小二乘法
fit_intercept：是否计算偏置
learning_rate : string, optional 学习率算法

学习率填充：
‘constant’: eta = eta0
‘optimal’: eta = 1.0 / (alpha * (t + t0)) [default]
‘invscaling’: eta = eta0 / pow(t, power_t) power_t=0.25:存在父类当中
对于一个常数值的学习率来说，可以使用learning_rate=’constant’ ，并使用eta0来指定学习率。

SGDRegressor.coef_：回归系数
SGDRegressor.intercept_：偏置

性能评估

sklearn.metrics.mean_squared_error(y_true, y_pred)

均方误差回归损失
y_true:真实值
y_pred:预测值
return:浮点数结果

例如

def mylinearregression():
"""
线性回归预测房子价格
:return:
"""
lb = load_boston()
# print(lb.data)
# print(lb.target)
# 对数据集进行划分
x_train, x_test, y_train, y_test = train_test_split(lb.data, lb.target,
test_size=0.3, random_state=24)
# 需要做标准化处理对于特征值处理
std_x = StandardScaler()
x_train = std_x.fit_transform(x_train)
x_test = std_x.fit_transform(x_test)
# print(x_train)
# 对于目标值进行标准化
std_y = StandardScaler()
y_train = std_y.fit_transform(y_train)
y_test = std_y.transform(y_test)
y_test = std_y.inverse_transform(y_test)
# 使用线性模型进行预测
# 使用正规方程求解
lr = LinearRegression()
# # 此时在干什么？
lr.fit(x_train, y_train)
y_lr_predict = std_y.inverse_transform(lr.predict(x_test))
print(lr.coef_)
print("正规方程预测的结果为：", y_lr_predict)
print("正规方程的均方误差为：", mean_squared_error(y_test, y_lr_predict))
# 梯度下降进行预测
sgd = SGDRegressor()

sgd.fit(x_train, y_train)
print("SGD的权重参数为：", sgd.coef_)

y_sgd_predict = std_y.inverse_transform(sgd.predict(x_test))

print("SGD的预测的结果为：", y_sgd_predict)

print("SGD的均方误差为：", mean_squared_error(y_test, y_sgd_predict))

欠拟合和过拟合

概念

欠拟合

一个假设在训练数据上能够获得比其他假设更好的拟合，但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)

过拟合

一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)

解决

正则化

L2正则化 - 更常用

作用：可以使得其中一些W的都很小，都接近于0，削弱某个特征的影响
优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
Ridge回归岭回归

L1正则化

作用：可以使得其中一些W的值直接为0，删除这个特征的影响
LASSO回归

岭回归

带L2正则化的线性回归

sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True,solver="auto", normalize=False)

alpha:正则化力度也叫λ λ取值：0~~1 1~~10
solver:会根据数据自动选择优化方法 sag:如果数据集、特征都比较大，选择该随机梯度下降优化
normalize:数据是否进行标准化
normalize=False:可以在fit之前调用preprocessing.StandardScaler标准化数据
Ridge.coef_:回归权重
Ridge.intercept_:回归偏置

逻辑回归(分类算法)

逻辑回归概念

逻辑回归是一种分类算法，虽然名字中带有回归，但是它与回归之间有一定的联系。由于算法的简单和高效，在实际中应用非常广泛。
利于解决二分类问题
线性回归的输出作为逻辑回归的输入

sigmoid激活函数

回归的结果输入到sigmoid函数当中
输出结果：[0, 1]区间中的一个概率值，默认为0.5为阈值

逻辑回归最终的分类是通过属于某个类别的概率值来判断是否属于某个类别，并且这个类别默认标记为1(正例),另外的一个类别会标记为0(反例)。（方便损失计算）

输出结果解释(重要)：假设有两个类别A，B，并且假设我们的概率值为属于A(1)这个类别的概率值。现在有一个样本的输入到逻辑回归输出结果0.6，那么这个概率值超过0.5，意味着我们训练或者预测的结果就是A(1)类别。

对数似然损失

API

sklearn.linear_model.LogisticRegression(solver = 'liblinear', penalty=‘l2’, C = 1.0)

solver:优化求解方式（默认开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数） sag：根据数据集自动选择，随机平均梯度下降
penalty：正则化的种类
C：正则化力度

代码举例

def logisticregression():
"""
逻辑回归进行癌症预测
:return: None
"""
# 1、读取数据，处理缺失值以及标准化
column_name = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell
Size', 'Uniformity of Cell Shape',
'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare
Nuclei', 'Bland Chromatin',
'Normal Nucleoli', 'Mitoses', 'Class']
data = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learningdatabases/breast-cancer-wisconsin/breast-cancer-wisconsin.data", names=column_name)
# 删除缺失值
data = data.replace(to_replace='?', value=np.nan)
data = data.dropna()
# 取出特征值
x = data[column_name[1:10]]
y = data[column_name[10]]
# 分割数据集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)

# 进行标准化
std = StandardScaler()
x_train = std.fit_transform(x_train)
x_test = std.transform(x_test)

# 使用逻辑回归
lr = LogisticRegression()
lr.fit(x_train, y_train)
print("得出来的权重：", lr.coef_)

# 预测类别
print("预测的类别：", lr.predict(x_test))

# 得出准确率
print("预测的准确率:", lr.score(x_test, y_test))
return None

分类的评估方法

精确率与召回率

混淆矩阵

精确率(Precision)与召回率(Recall)

精确率：预测结果为正例样本中真实为正例的比例（了解）
召回率(查全率)：真实为正例的样本中预测结果为正例的比例（查的全，对正样本的区分能力）

F1-score 反应模型稳健型

分类评估报告API

sklearn.metrics.classification_report(y_true, y_pred, labels = [], target_names = None)

y_true：真实目标值
y_pred：估计器预测目标值
labels:指定类别对应的数字
target_names：目标类别名称
return：每个类别精确率与召回率

例如

print("精确率和召回率为：", classification_report(y_test, lr.predict(x_test), labels=[2, 4], target_names = ['良性', '恶性']))

ROC曲线与AUC指标

ROC曲线

ROC曲线的横轴就是FPRate，纵轴就是TPRate，当二者相等时，表示的意义则是：对于不论真实类别是1还是0的样本，分类器预测为1的概率是相等的，此时AUC为0.5

AUC指标

AUC只能用来评价二分类
AUC非常适合评价样本不平衡中的分类器性能

AUC的概率意义是随机取一对正负样本，正样本得分大于负样本的概率
AUC的最小值为0.5，最大值为1，取值越高越好
AUC=1，完美分类器，采用这个预测模型时，不管设定什么阈值都能得出完美预测。绝大多数预测的场合，不存在完美分类器。
0.5 < AUC < 1，优于随机猜测。这个分类器（模型）妥善设定阈值的话，能有预测价值。

最终AUC的范围在[0.5, 1]之间，并且越接近1越好

AUC计算API

from sklearn.metrics import roc_auc_score
sklearn.metrics.roc_auc_score(y_true, y_score)

计算ROC曲线面积，即AUC值
y_true:每个样本的真实类别，必须为0(反例),1(正例)标记
y_score:每个样本预测的概率值

例如

# 0.5~1之间，越接近于1约好
y_test = np.where(y_test > 2.5, 1, 0)
print("AUC指标：", roc_auc_score(y_test, lr.predict(x_test)))

模型保存与加载

from sklearn.externals import joblib
# 保存
joblib.dump(rf, 'test.pkl')
# 加载
estimator = joblib.load('test.pkl')

例如

# 使用线性模型进行预测
# 使用正规方程求解
lr = LinearRegression()
# 此时在干什么？
lr.fit(x_train, y_train)
# 保存训练完结束的模型
joblib.dump(lr, "test.pkl")

及

# 通过已有的模型去预测房价
model = joblib.load("test.pkl")
print("从文件加载进来的模型预测房价的结果：",
std_y.inverse_transform(model.predict(x_test)))

无监督学习 k-means算法

特点分析：采用迭代式算法，直观易懂并且非常实用
缺点：容易收敛到局部最优解(多次聚类)

k-means算法聚类步骤

1、随机设置K个特征空间内的点作为初始的聚类中心
2、对于其他每个点计算到K个中心的距离，未知的点选择最近的一个聚类中心点作为标记类别
3、接着对着标记的聚类中心之后，重新计算出每个聚类的新中心点（平均值）
4、如果计算得出的新中心点与原中心点一样，那么结束，否则重新进行第二步过程

API

sklearn.cluster.KMeans(n_clusters=8,init=‘k-means++’)

k-means聚类
n_clusters:开始的聚类中心数量
init:初始化方法，默认为’k-means ++’
labels_:默认标记的类型，可以和真实值比较（不是值比较）

Kmeans性能评估指标

轮廓系数及轮廓系数值分析

如果b_i>>a_i:趋近于1效果越好， b_i << a_i:趋近于-1，效果不好。轮廓系数的值是介于 [-1,1] ，越趋近于1代表内聚度和分离度都相对较优。

轮廓系数API

sklearn.metrics.silhouette_score(X, labels)

计算所有样本的平均轮廓系数
X：特征值
labels：被聚类标记的目标值

用户聚类结果评估

silhouette_score(cust, pre)

使用数据处理方法

缩小数据范围

使用query()方法进行数据挑选
如

data = data.query("x < 2.5 & x > 2 & y < 1 & 1")

处理时间特征

使用pd.to_datatime()
如

time_value = pd.to_datatime(data["time"], unit = "s")

unit为单位此处为秒

为了方便得到时间可使用
pd.DatetimeIndex()
例如

date = pd.DatetimeIndex(time_value)

分组并统计使用groupby().count()
例如

count = data.groupby("place_id").count()

对place_id进行统计

布尔索引place_count[place_count > 3]

机器学习-Sklearn