机器学习3《数据集与k-近邻算法》

Posted 2021-02-12 bookmiki

机器学习数据类型：
    ●离散型数据:由记录不同类别个体的数目所得到的数据，又称计数数据，所
    有这些数据全部都是整数，而且不能再细分，也不能进一步提高他们的精确度。
    
    ●连续型数据:交量可以在某个范围内取任一数，即变量的取值可以是连续
    的，如，长度，时间、质量值等，这类整数通常是非整数，含有小数部分。
    
    
    注:只要记住一点，离散型是区间内不可分，连续型是区间内可分

机器学习算法分类
●监督学习(预测)
        分类 ：  k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络
        回归  ： 线性回归、岭回归
        标注 ： 隐马尔可夫模型(不做要求).
        注： 在监督学习里面 分类的数据类型是离散 回归的数据类型是连续
●无监督学习 ： 
        聚类  k-means


再解释一下fit_transform() = 输入数据转换数据
                fit() = 输入数据单不转换 先计算
                transform() = 转换数据

 

我们在机器学习中少不了对大数据的分析与处理，那么我们的数据怎么来呢？并且我们的数据是怎么训练呢？

sklearn里面保存了许多的数据集

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

    load_* 与 fetch_* 返回的数据类型是datasets.base.Bunch（字典格式）
        data: 特征数据数组，是[n_sample * n_features]的二维 numoy.ndarray数组
        target: 标签数组，是n_samples的一维 numpy.ndarray 数组
        DESCR：数据描述
        feature_name: 特征名，新闻数据，手写数字，回归数据集没有
        target_name: 标签名
        eg：
            用于分类的大数据集
                sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train‘)
                    subset: train或者test, all 可选，选择需要加载的数据集，训练集的训练，测试集的测试， 两者的全部
                                                                一般都是all 然后自己用train_test_split()划分
            回归数据集：
                datasets.load_boston()----------加载并返回boston房价数据集
                datasets.load_diabetes()--------加载并返回糖尿病数据集
        sklearn.datasets.clear_data_home(data_home)
            清除目录下的数据

测试集与数据集的分割

机器学习一般的数据集会划分为两个部分
    训练集：用于训练，构建模型
    测试数据：在模型检验时使用，用于评估模型是否有效
        一般 训练集 ：测试集 = 0.75 ：0.25
        数据集进行分割：
            API: sklearn.model_selection.train_test_split
                X =  数据集的特征值
                Y =  数据集的标签
                test_size : 测试集的大小一般为float
                random_state : 随机种子，不同的种子会造成不同的随机采样结果，相同的种子，采样结果相同
                return ： 训练集的特征值， 测试集的特征值， 训练标签，测试标签（默认随机抽取）

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
def bird():
    data = load_iris()
    print(‘data:
‘, data.data)
    print(‘target:
‘, data.target)
    print(‘DESCR: ‘, data.DESCR)

    print(‘-----------------------------------------------------------------‘)
    data_train, data_text, target_train, target_text = train_test_split(data.data, data.target, test_size=0.25)
    print(‘data 训练集：‘, data_train)
    print(‘target‘)
    print(‘data 测试集：‘, data_text)

load_iris 数据集与分割

k-近邻算法

 

k-近临算法：KNN  ----------------------需要做标准化
    哪个理你最近哪个的类型就是你的类型（比较最近）
    定义（如果一个样本在特征空间中的k个最相似（即特征空间中最临近）的样本中的人大多数属于某一个类别，则该样本也属于这个类型）
    公式： ({a - a‘}^2 +(b+b‘)^2...)的根号项
    k值影响：
        k值取很小： 容易受异常点影响
        k值取很大： 容易受k值数量（类别）波动
    优点：
        简单，易于理解，易于实现，无需估计参数，无需训练
    缺点：
        懒惰算法，对测试样本分类时的计算量大，内存开销大
        必须指定k值，k值选择不当则分类精度不能保证
    使用场景：
        小数据场景，几千 几万样本，具体场景具体业务去测试
    API: sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, algorithm=‘auto‘)
        参数：
            n_neighbors: int 可选默认为5（邻居数） ，k_neighbors 查询默认使用的邻居数
            
            algorithm：{‘auto‘, ‘ball_tree‘, ‘kd_tree‘, ‘brute‘} 可选用与计算最近邻居的算法
            ‘ball_tree‘ 将会使用balltrue， kd_tree将使用KDtree ‘auto’ 将尝试更具传递给fit放大的值来决定最合适的算法。（不同实现方法影响效率）
            
        knn = KNeighborsClassifier()
        knn.fit(data) 传入数据
        knn.score(x_test, y_test)  
        knn.predict(x_test)  # 预测特征测试集的目标集

 

eg：以下是facebook的一个数据集的用knn算法预测的实例

def knn():
    data = pd.read_csv(‘./train.csv‘)
    data = data.query(‘x>1 & x<2 & y>1 &y<2‘)

    place_count = data.groupby(‘place_id‘).count()    # 此时的index以悄然变成了place_id  且此时place_count会保留出place_id以外的特征，数值都为次数
    # 对所有的列进行计数汇总，详细请见https://blog.csdn.net/yiyele/article/details/80605909
    tf = place_count[place_count[‘row_id‘] > 3].reset_index()  # 挑选出次数小于30次的
    # tf = tf.reset_index()
    data = data[data[‘place_id‘].isin(tf.place_id)]


    time_value = pd.to_datetime(data[‘time‘], unit=‘s‘)
    # 拿到time value后发现斗个同一个的数据，所以我们可以去除中国干扰
    #                   并且日期和周末都可能影响，所以我们分开去测试，
    time_value = pd.DatetimeIndex(time_value)   # pd.DateIndex()就可以把日期格式转换成pd.Series的数据
    print(‘----------- time_value -----------------------‘)
    print(time_value)
    print(type(time_value))
    # 为数据添加新的特征
    data[‘day‘] = time_value.day
    data[‘hour‘] = time_value.hour
    # data[‘minute‘] = time_value.minute
    # data[‘week‘] = time_value.week
    data[‘weekday‘] = time_value.weekday

    # 去除掉老的特征
    data.drop([‘time‘], axis=1)



    print(‘----------- data -----------------------‘)
    print(data.head(10))
    print(type(data))

    # 分割数据
    ‘‘‘
        X: 特征集
            x_train：训练集 
            x_test：测试集 
            
        Y：目标集
            y_train：训练集 
            y_test：测试集
            
    ‘‘‘
    # 目标集
    y = data.place_id
    # 特征集
    x = data.drop([‘place_id‘], axis=1)

    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)

    # 特征工程 标准化
    # 需要标准化的是特征值的训练集和测试集
    st = StandardScaler()
    st.fit(x_train)
    x_train = st.transform(x_train)
    x_test = st.transform(x_test)

    # k-近邻
    Knn = KNeighborsClassifier()
    Knn.fit(x_train, y_train)
    _float_score = Knn.score(x_test, y_test)  # x_text, y_text  计算匹配度float32类型
    _y_test = Knn.predict(x_test)  # 预测特征测试集的目标集

    print(_float_score)

facebook社区签到预测

在这个示例里面额外掌握的pandas的知识有

　　1.data = data.query(‘x>1 & x<2 & y>1 & y<2‘)    data是pd.DataFrame格式

　　2.  将place_id的数据少于 3个的删除

　　place_count = data.groupby(‘place_id‘).count()    # 此时的index以悄然变成了place_id  且此时place_count会保留出place_id以外的特征，数值都为次数
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 对所有的列进行计数汇总，详细请见https://blog.csdn.net/yiyele/article/details/80605909
　　tf = place_count[place_count[‘row_id‘] > 3].reset_index()  # 挑选出次数小于30次的此时的rows是place_id 所以我们需要重新reset_index
　　# tf = tf.reset_index()
　　data = data[data[‘place_id‘].isin(tf.place_id)]  # 按照tf里面的筛选

　　3.处理日期数据：

　　　　pd.to_datetime(x)  x的格式为时间戳

　　　　pd.DatetimeIndex

 

 eg2: 以下是 鸢尾花的测试

# _*_coding:utf-8_*_
# /usr/bin/env python3
# Author：book Miki

import pandas as pd
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
def knn_ir():
    # 加载数据
    ir = load_iris()

    # 分割数据
    ‘‘‘
    X: 特征值
        X_train: 特征训练集
        X_test: 特征测试集 
    Y：目标值
        X_train: 特征训练集
        X_test: 特征测试集 
    ‘‘‘
    X = ir[‘data‘]
    Y = ir[‘target‘]
    X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.25)

    # 特征工程  标准化
    ss = StandardScaler()
    ss.fit(X)
    X_train = ss.transform(X_train)
    X_test = ss.transform(X_test)

    # k 近邻回归

    knn = KNeighborsClassifier(n_neighbors=3)
    knn.fit(X_train, Y_train)

    result = knn.score(X_test, Y_test)
    print(‘匹配度为：‘, result)


knn_ir()

鸢尾花

预测结果为   “匹配度为： 0.9736842105263158”