天纵检测（SKYLABS）是从事EMC（电磁兼容）检测工作的第三方实验室之一。今天我们就给大家讲讲EMC标准的结构划分及分类问题。
EMC标准和其它大多数组织的标准体系框架类似，其采用了国际电工委员会（IEC）的标准分类方法。从大的方面说，其标准类别可分成基础标准、通用标准、产品标准，其中产品标准又可分为系列产品标准和专用产品标准。每类标准都包括发射（EMI）和抗扰度（EMS）两个方面的内容。
1、EMC基础标准
基础EMC标准规定达到电磁兼容的一般和基本条件或规则，它们与涉及EMC问题的所有系列产品、系统或设施有关，并可适用于这些产品，但不规定产品的发射限制或抗扰度判定准则。它们是制定其他EMC标准（如通用标准或产品标准）的基础或引用的文件。
基础标准涉及的内容包括：术语、电磁现象的描述、兼容性电平的规范、骚扰发射限制的总要求、测量、试验技术和方法、试验等级、环境的描述和分类等等。比较典型的EMC基础标准如IEC61000，GB/T 17626等。
2、EMC通用标准
通用EMC标准是关于特定环境下的电磁兼容标准。它规定一组最低的基本要求和测量/试验程序，可应用于该特定环境下工作的所有产品或系统。如某种产品没有系列产品标准或专用产品标准，可使用通用EMC标准。
通用EMC标准将特定环境分为两大类：
1）居住、商业和轻工业环境
a.居住环境如住宅、公寓；
b.商业环境如商店、超市等零售网点，办公楼、银行等商务楼，电影院、网吧等公共娱乐场所；
c.轻工业环境如小型工厂、实验室等。
这其中比较典型的EMC在居住环境中的通用标准有GB 17799.3等。
2）工业环境
如大的感性负载或容性负载频繁开关的场所，大电流并伴有强磁场的场所等。制定通用EMC标准必须参考EMC基础标准，因为它们是不包含详细的测量和试验方法以及测量和试验所需的设备等。通用EMC标准包含有关的发射（限制）和抗扰度（性能判定）要求及相应的测量和试验规定。通用EMC标准仅规定了有限的几项要求和测量/试验方法，以便达到最佳的技术/经济效果，但这并不妨碍要求产品应设计成具有特定环境下对于各种电磁骚扰都能正常工作的性能。比较典型的工业环境下的通用标准有GB 17799.4等。
3、EMC产品标准
产品EMC标准根据适用于产品范围的大小和产品的特性又可进一步分为系列产品EMC标准和专用产品EMC标准。
**系列产品EMC标准是指一组类似产品、系统或设施，对于它们可采用相同的EMC标准。**系列产品EMC标准针对特定的产品类别规定了专门的EMC（包括发射和抗扰度）要求、限制和测量/试验程序。产品类标准比通用标准包含更多的特殊性和详细的性能要求，以及产品运行条件等。产品类别的范围可以很宽，也可以很窄。比如EN55014、EN55015、EN55022、EN55011和EN55013分别是关于家用电器和电动工具、照明灯具、信息技术设备、工科医射频设备、声音和广播电视接收设备的无线电骚扰特性测量及限值的标准，这些标准分别代表了一个大类产品对电磁骚扰发射限度的要求。
系列产品EMC标准应采用基础EMC标准规定的测量/试验方法，其测试与限制或性能判定准则必须与通用EMC标准相兼容。系统产品EMC标准比通用EMC标准优先采用。系列产品标准比通用标准要包括更专门和更详细的性能判定准则。
**专用产品EMC标准是关于特定产品、系统或设施而制定的EMC标准。**根据这些产品特性必须考虑一些专门的条件，它们采用的规则和系列产品EMC标准相同。专门产品EMC标准应比系列产品EMC标准优先采用。仅在特例情况下才允许与规定的发射限值不同的限值。在决定产品的抗扰度要求时，必须考虑产品的专门功能特性，专门产品EMC标准要给出精确的性能判定准则。因此，产品标准与系列产品标准或通用标准有差异是合理的。比如针对手机的YD/T 1032-2000就是属于产品标准范畴。
总结来说，EMC基础标准其主要描述了EMC现象、规定了EMC测试方法、设备，定义等级。EMC通用标准则按照设备使用环境进行划分，当产品没有特定的产品类标准可以遵循时，可使用通用标准来进行EMC测试。而EMC产品类标准是针对某种产品系列的EMC测试标准，其会引用基础标准，但也会根据产品的特殊性提出更多而详细的具体产品测试规定。正常情况下当有EMC产品标准的，应遵循产品标准进行测试并对试验结果进行判断，而当没有对应产品标准时，则可基于通用标准进行EMC结果的判定。

机器学习笔记二
数据划分和分类算法
sklearn数据集与估计器
数据集划分
转换器和预估器
分类算法-K近邻算法
分类算法-朴素贝叶斯算法
分类模型评估
模型的选择与调优
决策树与随机森林

数据划分和分类算法
sklearn数据集与估计器
数据集划分


训练集（训练使用）

大多数
目的

建立模型





测试集（评估使用）

少部分
目的

评估模型（算法不同，评估标准不同）





常见划分比例

70% 30%
80% 20%
75% 25% （最多）



API

sklearn.model_selection.train_test_split
参数

x

数据集的特征


y

数据集的标签值


test_size

测试集的大小
一般为float


random_state

随机种子


return(返回值)

训练集特征值，测试集特征值，训练标签(目标值)，测试标签(默认随机)







数据集API介绍

sklearn.datasets

加载流行数据集
datasets.load_*()

获取小规模数据集
数据包含在satasets里


datasets.fetch_*(data_home=None)

加载大规模数据集，需要从网络下载







数据格式

返回的数据类型

datasets.base.Bunsh(字典格式)


data

特征数据数组
[n_samples * n_features]
二维的np.ndarray数组


target

标签数组
一个 n_samples 的一维np.adarray数组


DESCR

数据描述


features_names

特征名
有的没有


target_names

标签名称





数据集介绍

分类数据集

- 鸢尾花数据集

-from sklearn.datasets import load_iris

- 直接实例化一个数据集，然后用 .data .target 等获取数据

- 用于分类的大数据集

- sklearn.datasets.fetch_20wsgroups(data_home=None,subset='train)- subset: "train"/"test"/"all",可选 - 新闻的数据集 - data_home:目录的位置 -dataset.clear_data_home(data_home=None)`

- 清除目录下的数据

回归数据集

sklearn.datasets.load_boston()

波士顿房价数据集


sklearn.datasets.load_diabetes()

加载和返回糖尿病数据集







转换器和预估器

转换器

实现了特征工程的api
fit_transform()

输入数据直接转换
fit() + transform()


fit()

输入数据，但不做事情
计算一些数据，平均值/方差 等


transform()

进行数据的转换
以fit()计算出的标准来进行数据的转换




估计器(estimator)

是一类实现算法的api
注重于算法当中的参数和属性
分类的估计器

K近邻算法

sklearn.neighbors


贝叶斯分类

sklearn.naive_bayes


逻辑回归

sklearn.linear_model.LogisticRegression


决策树与随机森林

sklearn.tree




回归的估计器

线性回归

sklearn.linear_model.LinearRegression


岭回归

sklearn.linear_model.Ridge




聚类


估计器使用流程

调用fit()

fit(x_train,y_train)


输入测试集数据

预测结果:

y_predict = predict(x_test)


预测准确率:

score(test,y_test)







分类算法-K近邻算法


核心思想

通过邻居来计算自己



定义

k个最相似(即特诊空间中最邻近)的样本中的大多数属于某一个类别



如何求距离

欧式距离
如: a(a1,a2,a3) b(b1,b2,b3)
根号((a1-b1)2+(a2-b2)2+(a3-b3)^2)



需要做标准化处理（重要）


API

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

n_neighbors

最近的邻居的数


algorithm 加快搜索速度

auto
ball_tree
kd_tree
brute







k值取多大？有什么影响？

k值取很小

容易受异常点影响


k值取很大

容易受k值数量(类别)波动





性能问题?

时间复杂度很高



总结

优点

简单，易于理解，易于实现,无需估计参数，无需训练(迭代)


缺点

懒惰算法,对测试样本分类是的计算量大，内存消耗大
必须指定k值(n_neighbors),k值选择不当则分类精度不能保证





使用场景

小数据场景
几千~几万样本 集体场景业务去测试



实例

数据集下载
# coding=utf-8
# K-近邻算法
from sklearn.neighbors import KNeighborsClassifier
# 测试集和训练集分割
from sklearn.model_selection import train_test_split
# 标准化
from sklearn.preprocessing import StandardScaler
import pandas as pd


def knncls():
    """
    使用k-近邻算法预测用户签到位置
    :return: None
    """
    # 读取数据
    data = pd.read_csv("../file/FBlocation/train.csv")
    
    # print(data.head(10))
    
    # 处理数据
    # 1.缩小数据  查询数据筛选
    data = data.query("x > 1.0 & x < 1.25 & y > 2.5 & y < 2.75")  # 相当于 查询语句  传递字符串条件
    
    # 2. 处理时间数据, 按秒转换
    time_value = pd.to_datetime(data.loc[:,"time"], unit="s")
    
    # print(time_value)
    
    # 将日期格式转换成字典格式
    time_value = pd.DatetimeIndex(time_value)
    
    
    # 3. 构造特征
    # 最好写成这样子的， 不然会又警告
    # 先将数据复制一份 然后在使用.loc[row,col] = 来赋值
    # data["day"]= time_value.day  也是可以的，不过会有警告
    data = data.copy()
    data.loc[:, "day"]= time_value.day
    data.loc[:, "week_day"] = time_value.weekday
    data.loc[:, "hour"] = time_value.hour
    
    # 将原数据的时间戳个删除  pandas 中 axis 1 是列
    data = data.drop(["time"], axis=1)
    
    
    # print(data)
    
    # 4. 统计分组 然后将签到数量少于n个的目标位置删除
    place_count = data.groupby("place_id").count()
    # print(place_count)

    # reset_index 重新设置索引  将 place_count 单独作为一列
    tf = place_count[place_count.row_id > 3].reset_index()  # 保存 place_count 中 数据大于3的place_count
    # print(tf)
    
    data = data[data["place_id"].isin(tf.place_id)]  # 保存目标位置大于3的样本数据
    # print(data)

    # 删除 row_id
    data = data.drop(["row_id"], axis=1)
    print(data)
    
    # 5. 取出数据中的特征值和目标值
    y = data["place_id"]
    
    x = data.drop(["place_id"],axis=1)
    
    # 6. 进行数据的分割 训练集和测试集
    x_train,x_test,y_train,y_test = train_test_split(x , y,test_size=0.25)
    # 特征工程 (标准化)
    # 1. 实例化一个api
    std = StandardScaler()
    
    # 2. 对 训练集 和 测试集 的特征值标准化
    x_train = std.fit_transform(x_train)  # 输入值 进行计算标准  最后返回标准化的值
    x_test = std.transform(x_test)  # 直接计算标准
    
    # 进行算法流程  n_neighbors ：超参数
    knn = KNeighborsClassifier(n_neighbors=8)
    
    # fit  ,predict , score
    knn.fit(x_train,y_train)  # 输入数据   一般不操作
    
    # 1. 得出预测结果
    y_predict = knn.predict(x_test)
    print("预测的目标签到位置:", y_predict)
    
    # 2. 得出准确率
    score = knn.score(x_test,y_test)
    print("预测的准确率:",score)
    return None


if __name__ == '__main__':
    knncls()



分类算法-朴素贝叶斯算法

概念

看属于哪个分类的概率是多少，选取最大的那个概率


条件概率

事件A在事件B已经发生条件的发生概率
P(A|B) = P(A1,A2|B) = P(A1|B)P(A2|B)
条件：

此条件概率成立，A1和A2之间条件相互独立
所有特征之间条件独立
不独立的情况：

自然语言处理解决






联合概率

包含所有条件，且所有条件同时成立
P(A,B) = P(A)P(B)


特点

特征相互独立


公式

P(C|W)=P(W|C)P©/P(W)
W: 是给定围挡的特征值(评数统计，预测文档提供)
C: 是文档的类别
可以理解为

P(C|F1,F2,…) = P(F1,F2,…|C)P©/P(F1,F2,…)


P©

每个文档类别的概率(某文档类别/总文档数量)


P(W)

给定类别下特征(被预测文档中出现的词)的概率
计算方法：

1.P(F1|C)=Ni/N

2. Ni: 为F1词在C类别所有文档中出现的次数(训练文档计算)

3. N: 为类别C下的文档所有词出现的次数总和




在求所属概率的时候出现 0，解决方法

添加 拉普拉斯平滑系数
P(F1|C) = (Ni+α)/(N+αm)

α为指定的系数，一般为1，m为训练文档中统计出特征词的个数




API

sklearn.naive_bayes.MultinomiaNB(α=1.0)
α: 拉普拉斯平滑系数


最初的准确率还是可以的，但是准确率不容易提高
总结

训练集误差大的话，结果不好
不需要条参数
优点

模型源于古典数学理论,有稳定的分类效率
对缺失数据不太敏感，算法也比较简单，常用于文本分类
分类准确度高，速度快


缺点

假设了文章中一些词语另外一些词语独立没关系 -> 不太靠谱
训练集当中进行统计词这些工作，会对结果造成干扰


使用重点

文本分类
不过神经网络的效果比这个好一些




案例
# coding=utf-8
# 新闻类数据集
from sklearn.datasets import fetch_20newsgroups
# 数据分割
from sklearn.model_selection import train_test_split
# 特征抽取  文本
from sklearn.feature_extraction.text import TfidfVectorizer
# 朴素贝叶斯算法
from sklearn.naive_bayes import  MultinomialNB
# 准确率和召回率
from sklearn.metrics import classification_report



def naviebayes():
    """
    朴素贝叶斯进行文本分类
    :return: None
    """
    news = fetch_20newsgroups(data_home="../file/",subset="all")
    
    # 进行数据分隔
    # news.data: 特征值    news.target : 目标值
    x_train,x_test,y_train,y_test = train_test_split(news.data, news.target, test_size=0.25)
    
    # 进行特征的抽取
    tf = TfidfVectorizer()
    
    # 以训练集当中的词的列表进行每篇文章重要性统计 ['a','b','c','d']
    x_train = tf.fit_transform(x_train)
    
    print("词的标签:",tf.get_feature_names())
    # 默认是sparse类型
    print(x_train.toarray())
    x_test = tf.transform(x_test)
    
    
    # 进行朴素贝叶斯算法实现预测
    mlt = MultinomialNB(alpha=1.0)
    
    mlt.fit(x_train,y_train)
    
    # 预测的目标值
    y_predict = mlt.predict(x_test)
    print("预测的分类:",y_predict)
    
    score = mlt.score(x_test,y_test)
    print("预测的准确率:",score)
    
    # 召回率和精确率  这个没有必要使用召回率和精确率
    print("每个类别的精确率和召回率:\n",classification_report(y_test,y_predict,target_names=news.target_names))
    

    return None

if __name__ == '__main__':
    naviebayes()




分类模型评估

一般常见评估标准

estimator.score()

一般最常见使用的是准确率，即预测结果正确的百分比




混淆矩阵

在分类任务下，预测结果(Predicted Condition)与正确标记(True Condition)之间存在四种不同的组合，构成混淆矩阵
适用于多分类


精确率和召回率

精确率

预测结果为正例样本中真实为正例的比例(查的准)


召回率

真实为正例的样本中预测结果为正例的比例(查的全，对正样本的区分能力)




其他分类标准

F1-score，反映了模型的稳健型

提高召回率，但是不能更改别的概率




分类评估API

sklearn.metrics..classification_report(y_true,y_pred,target_names=None)
参数

y_true

真实目标值


y_pred

估计器预测目标值


target_names

目标类别名称


return (返回值)

返回每个类别精确率和召回率







模型的选择与调优

交叉验证

将所有数据分成n等份
将训练集分成两部分

训练集
验证集


目的

为了让被评估的模型更加准确可信


一般用10折交叉验证


网格搜索

调参数的

K-近邻 : 超参数 K


每组超参数用交叉验证来进行评估


API


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

对估计器的指定参数值进行详尽搜索

estimator:估计器对象
param_grid:估计器参数(dict类型)

如：KNN:{“n_neighbors”:[3,5,8,10]}


cv: 指定几折交叉验证
fit:输入训练数据
score:准确率(测试集)


结果分析:


best_score_: 交叉验证中验证的最好结果
best_estimator_:最好的参数模型
cv_results_: 每次交叉验证后的验证集准确率结果和训练集准确率结果






knn交叉验证、网格搜索实例

数据和之前的knn实例数据一样
# coding=utf-8
# K-近邻算法
from sklearn.neighbors import KNeighborsClassifier
# 测试集和训练集分割和 网格搜索
from sklearn.model_selection import train_test_split, GridSearchCV
# 标准化
from sklearn.preprocessing import StandardScaler
import pandas as pd


def knncls():
    """
    使用k-近邻算法预测用户签到位置
    :return: None
    """
    # 读取数据
    data = pd.read_csv("../file/FBlocation/train.csv")
    
    # print(data.head(10))
    
    # 处理数据
    # 1.缩小数据  查询数据筛选
    data = data.query("x > 1.0 & x < 1.25 & y > 2.5 & y < 2.75")  # 相当于 查询语句  传递字符串条件
    
    # 2. 处理时间数据, 按秒转换
    time_value = pd.to_datetime(data.loc[:,"time"], unit="s")
    
    # print(time_value)
    
    # 将日期格式转换成字典格式
    time_value = pd.DatetimeIndex(time_value)
    
    
    # 3. 构造特征
    # 最好写成这样子的， 不然会又警告
    # 先将数据复制一份 然后在使用.loc[row,col] = 来赋值
    # data["day"]= time_value.day  也是可以的，不过会有警告
    data = data.copy()
    data.loc[:, "day"]= time_value.day
    data.loc[:, "week_day"] = time_value.weekday
    data.loc[:, "hour"] = time_value.hour
    
    # 将原数据的时间戳个删除  pandas 中 axis 1 是列
    data = data.drop(["time"], axis=1)
    
    
    # print(data)
    
    # 4. 统计分组 然后将签到数量少于n个的目标位置删除
    place_count = data.groupby("place_id").count()
    # print(place_count)

    # reset_index 重新设置索引  将 place_count 单独作为一列
    tf = place_count[place_count.row_id > 3].reset_index()  # 保存 place_count 中 数据大于3的place_count
    # print(tf)
    
    data = data[data["place_id"].isin(tf.place_id)]  # 保存目标位置大于3的样本数据
    # print(data)

    # 删除 row_id
    data = data.drop(["row_id"], axis=1)
    print(data)
    
    # 5. 取出数据中的特征值和目标值
    y = data["place_id"]
    
    x = data.drop(["place_id"],axis=1)
    
    # 6. 进行数据的分割 训练集和测试集
    x_train,x_test,y_train,y_test = train_test_split(x , y,test_size=0.25)
    # 特征工程 (标准化)
    # 1. 实例化一个api
    std = StandardScaler()
    
    # 2. 对 训练集 和 测试集 的特征值标准化
    x_train = std.fit_transform(x_train)  # 输入值 进行计算标准  最后返回标准化的值
    x_test = std.transform(x_test)  # 直接计算标准
    
    # 进行算法流程  n_neighbors ：超参数
    # 网格搜索中已经有了超参数所以这里不需要设置
    knn = KNeighborsClassifier()
    
    # 网格搜索个交叉验证
        # 构造一些参数的值进行搜索
    param = {"n_neighbors":[3,5,8,10]}
    
    # param_grid: 超参数  cv : 交叉验证的次数  第一个参数是模型
    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("选择最好的模型:\n",gc.best_estimator_)

    print("选择最好的模型参数:\n", gc.best_params_)
    
    print("每个超参数每次交叉验证的结果:\n",gc.cv_results_)
    return None


if __name__ == '__main__':
    knncls()



决策树与随机森林


信息熵

H = -((P1log(P1)) + P2log(P2)+…)

H:信息熵
P1:概率


信息熵越大，不确定性越大
当概率相同的越多的时候信息熵越大



决策树的划分依据

信息增益的大小来分类ID3

当得知一个特征条件之后，减少的信息熵的大小
计算

g(D,A) = H(D) - H(D|A)

g:某个特征信息的增益
H(D):初始信息熵大小

3.H(D|A): A特征带来的信息熵的大小






C4.5

信息增益比 最大的准则


CART
回归树

平方误差 最小


分类树

基尼系数  最小的准则

在sklearn中可以选择划分默认原则







决策树API

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

决策树分类器
参数

criterion: 默认是gini系数，也可以选择信息增益的熵entropy
max_depth:树的深度
random_state:随机数种子
method:
decision_path:返回决策树的路径




决策树本地化API

sklearn.tree.export_graphviz(estimator,out_file='路径',feature_names='特征列表')

estimator:决策树
out_file: 文件输出路径 (最后的路径名称一定是.dot结尾的)
feature_names: 特征值的列表
dot 文件转化

dot -Tpng dot文件名 -o titanic_tree.png









决策树的优缺点

优点

简单的理解和解释,树木可视化
需要很少的数据准备,其他技术通常需要数据归一化


缺点

决策树学习者可以创建不能很好地推广数据的归于复杂的数，过拟合


改进

减枝cart算法(决策树API当中已经实现,随机森林参数调优)
随机森林


注

企业重要决策,由于决策树很好的分析能力,字啊决策过程应用较多





随机森林


原理

生成多个分类器/模型 - 集成学习方法
包含了多个决策树



随机森林建立过程

数据集

N个样本,M个特征


单个树建立过程

随机在N个样本当中选择一个样本,重复N次(样本有可能重复)
随机在M个特征中选出m(m<M)个特征


建立多颗决策树
随机有放回的抽样





随机森林的API

sklearn.model_selection.RandomForestClassifier(n_estimator=10,criterion='gini',max_depth=None,bootstrap=True,random_state=None)

参数

n_estimator

森林里的顺木数量


criterion

分隔特征的测量方法


max_depth

树的最大深度，默认是无


bootstrap

是否在构建树时使用放回样本，默认放回


max_features=‘auto’

每个决策的最大特征数量









随机森林超参数搜索

n_estimator : 决策树的数量

一般为: 120、200、300、500、800、1200


max_depth : 树的最大深度

一般为: 5、8、15、25、30





随机森林 总结

优点

在当前所有的算法中，具有极好的准确率
能够有效地运行在大数据集上
能够处理具有高维特征的输入样本,而且不需要降维
能够评估各个特征在分类问题上的重要性


缺点

参数很多，找合适的参数有点难





决策树实例

泰坦尼克号数据下载
# coding=utf-8
import pandas as pd
# 导入决策树  和  决策树结构本地储存
from sklearn.tree import DecisionTreeClassifier, export_graphviz
# 导入特征抽取
from sklearn.feature_extraction import DictVectorizer
# 训练集和测试集分隔
from sklearn.model_selection import train_test_split


def decision():
    """
    决策树对泰坦尼克号进行预测生死
    :return:None
    """
    # 获取数据
    data = pd.read_csv("../file/titanic.txt")
    
    # 处理数据, 找出特征值和目标值
    x = data[["age","pclass","sex"]]
    
    y = data["survived"]
    
    x = x.copy()
    # 将 age 中空缺的值进行填充  inplace： 是否原地替换  默认为false
    x["age"].fillna(x["age"].mean() ,inplace=True)
    # 分隔数据  训练集和测试集
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
    
    
    # 特征工程 特征 -> 类别 -> one-hot 编码  (字典的特征抽取)
    dict = DictVectorizer(sparse=False)
    
    # one-hot 编码转换
    x_train = dict.fit_transform(x_train.to_dict(orient="records"))
    
    x_test = dict.transform(x_test.to_dict(orient="records"))
    
    print("特征抽取的名称:\n",dict.get_feature_names())
    print("训练集数据:\n",x_train)
    # 进行预测  max_depth: 树的深度
    dec = DecisionTreeClassifier(max_depth=5)
    
    # 输入数据
    dec.fit(x_train,y_train)
    
    # 输出预测分数
    print("预测的准确率:",dec.score(x_test,y_test))
    
    # 导出决策树结构
    export_graphviz(dec,out_file="../file/titanic_tree.dot",feature_names=['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'female', 'male'])
    return None


if __name__ == '__main__':
    decision()



随机森林实例

泰坦尼克号生存预测
# coding=utf-8
import pandas as pd
from sklearn.feature_extraction import DictVectorizer
# 数据分隔   导入网格搜索和交叉验证
from sklearn.model_selection import train_test_split, GridSearchCV
# 导入随机森林
from sklearn.ensemble import RandomForestClassifier

def Randomforest():
    """
    随机森林对泰坦尼克号进行预测生死
    :return:None
    """
    # 获取数据
    data = pd.read_csv("../file/titanic.txt")
    
    # 处理数据, 找出特征值和目标值
    x = data[["age", "pclass", "sex"]]
    
    y = data["survived"]
    
    x = x.copy()
    # 将 age 中空缺的值进行填充  inplace： 是否原地替换  默认为false
    x["age"].fillna(x["age"].mean(), inplace=True)
    # 分隔数据  训练集和测试集
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
    
    # 特征工程 特征 -> 类别 -> one-hot 编码  (字典的特征抽取)
    dict = DictVectorizer(sparse=False)
    
    # one-hot 编码转换
    x_train = dict.fit_transform(x_train.to_dict(orient="records"))
    
    x_test = dict.transform(x_test.to_dict(orient="records"))
    
    print("特征抽取的名称:\n", dict.get_feature_names())
    print("训练集数据:\n", x_train)
    
    # 随机森林
    rf = RandomForestClassifier()
    
    # 随机森林的超参数设置
    params = {"n_estimators":[120,200,300,500,800,1200],"max_depth":[5,8,15,25,30]}
    
    # 网格搜索和交叉验证
    gc = GridSearchCV(rf, param_grid=params, cv=2)
    
    # 输入数据
    gc.fit(x_train,y_train)
    
    # 查看准确率
    print("预测测试集的准确率:",gc.score(x_test,y_test))
    
    # print("在交叉验证中最好的结果:", gc.best_score_)

    print("选择最好的模型:\n", gc.best_estimator_)

    print("选择最好的模型参数:", gc.best_params_)
    
    # print("每个超参数每次交叉验证的结果:\n", gc.cv_results_)
    
    return None


if __name__ == '__main__':
    Randomforest()

    IP地址是指互联网协议地址（Internet Protocol Address，又译为网际协议地址），是IP
 Address的缩写。IP地址是IP协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。

IP地址的分类








分类


区分标识


网络号


主机号和个数


A类    


最高位固定为0      


A类网络号为8位   


主机号为24位，可以容纳2的24次方-2个主机    


B类


前两位为10


B类网络号为16位


主机号为16位，可以容纳2的16次方-2个主机


C类


前三位110


C类网络号为24位


主机号为8位， 可以容纳2的8次方-2个主机



减去2是因为：
    主机号全为1的IP称为广播地址；
    主机号全为0的IP称为网络号


子网掩码及子网分类
    子网掩码：它是一种用来指明一个IP地址的哪些位标识的是主机所在的子网，以及哪些位标识的是主机的位掩码。子网掩码不能单独存在，它必须结合IP地址一起使用。子网掩码只有一个作用，就是将某个IP地址划分成网络地址和主机地址两部分。（通俗来讲它的作用就是：区分IP地址中的网络号和主机号；)


例如：
    IP地址：202.197.119.110
    子网掩码：255.255.255.0     然后计算网络号和主机号。
    IP地址转为2进制：11001010.11000101.01110111.01101110
    子网掩码转2进制：11111111.11111111.11111111.00000000


求网络号：子网掩码和IP地址按位做与运算。





求主机号：先将子网掩码按位取反，然后和IP地址做与运算。





    使用子网掩码计算出IP地址的网络号，可以判断两个不同的IP地址是否在一个网络中。网络号相同则在同一个网络中；


子网划分：

1.一个大的网络划分成多个小的网络。（主机号做网络号）
例如：
一个C类IP：202.197.119.* 
子网掩码： 255.255.255.0
转化为2进制，然后求得IP的主机号和网络号；


IP按此可分段：







主机号可作为子网号来用，如果我们把该IP划分为6个子网，可取主机号的前3位来作为子网号：









2.多个网络并成一个网络。（网络号做主机号）



总结：
    IP地址由网络号和主机号组成，通过子网掩码可以知道一个IP地址的网络号和主机号。网络号划分子网，子网地址是借用基于每类的网络地址的主机部分创建的。划分子网后，通过使用掩码，把子网隐藏起来，使得从外部看网络没有变化。

学习目标

知道数据集的分为训练集和测试集
	
知道sklearn的分类、回归数据集
思考：拿到的数据是否全部都用来训练一个模型？

1 数据集的划分

机器学习一般的数据集会划分为两个部分：

训练数据：用于训练，构建模型
	
测试数据：在模型检验时使用，用于评估模型是否有效
划分比例：

训练集：70% 80% 75%
	
测试集：30% 20% 25%
API


sklearn.model_selection.train_test_split(arrays, *options)

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


2 sklearn数据集介绍

2.1 API


sklearn.datasets
	
加载获取流行数据集
		
datasets.load_*()
		
获取小规模数据集，数据包含在datasets里
		
		
datasets.fetch_*(data_home=None)
		
获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录,默认是 ~/scikit_learn_data/
		
	


2.2 分类和回归数据集

分类数据集


sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)
	
subset: 'train'或者'test','all'，可选，选择要加载的数据集.训练集的“训练”，测试集的“测试”，两者的“全部”
	
	
回归数据集


2.3 返回类型


load和 fetch返回的数据类型datasets.base.Bunch(字典格式)

	
data：特征数据数组，是 [n_samples * n_features] 的二维 numpy.ndarray 数组
		
target：标签数组，是 n_samples 的一维 numpy.ndarray 数组
		
DESCR：数据描述
		
feature_names：特征名,新闻数据，手写数字、回归数据集没有
		
target_names：标签名