机器学习总结

# encoding=utf8
from sklearn.cluster import KMeans
from sklearn.datasets import load_digits, fetch_20newsgroups, make_blobs
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LinearRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import numpy as np
import pandas as pd

#回归模型，用来预测
from sklearn.tree import DecisionTreeClassifier


def price_predict():
    #http://scikit-learn.org/stable/modules/linear_model.html
    #数据有三个特征：距离地铁距离、附近小学数量、小区绿化率
    # P =  W1 * A + W2*B + W3 *C
    X = np.array([[500.0, 3.0, 0.3], [1000.0, 1.0, 0.6],
                  [750.0, 2.0, 0.3], [600.0, 5.0, 0.2], [1200.0, 1.0, 0.6]])
    #具有三个特征的房屋对应的房价
    Y = np.array([10000., 9000., 8000., 12000., 8500.])

    #将数据转化到均值是0，方差是1的标准分布内
    std_x = StandardScaler()
    x_train = std_x.fit_transform(X)

    std_y = StandardScaler()
    y_train = std_y.fit_transform(Y.reshape(-1,1))

    #构建线性预测模型
    lr = LinearRegression()
    #模型在历史数据上进行训练，Y.reshape(-1,1)将Y变为二维数组，fit函数要求二维数组
    lr.fit(x_train,y_train)
    #使用训练模型预测新房屋[1300,3.0,0.4]的价格

    x_predict = std_x.transform(np.array([[1300,3.0,0.4]]))
    print(std_y.inverse_transform(lr.predict(x_predict)))



#k近邻分类(k表示以最近的几个邻居作为分类的指标)
#kNN表示了物以类聚人以群居的基本思考方法，最近的k个邻居是什么类别，预测样本就会被化为该类别
def knn_predict_rev(point):
    #http://scikit-learn.org/stable/modules/neighbors.html
    #数据理解为二维坐标上的6个点
    X = np.array([[1.0, 1.0], [1, 1.5], [0.5, 1.5],[3.0, 3.0], [3.0, 3.5], [2.8, 3.1]])
    #6个点的类别,按顺序和X依次对应，[1.0,1.0]的类别是0，依次类推
    Y = np.array([0,0,0,1,1,1])

    #n_neighbors就是kNN中的k
    knn = KNeighborsClassifier(n_neighbors=3)
    knn.fit(X,Y)
    print(knn.predict(np.array([[2.0,3.0]])))


def decide_play():
    #ID3
    """
    #http://scikit-learn.org/stable/modules/tree.html
    什么是Gini？
    dtree.csv样例数据:
    Outlook,Temperatur,Humidity,Windy,PlayGolf
    sunny,85,85,FALSE,no
    sunny,80,90,TRUE,no
    overcast,83,86,FALSE,yes
    rainy,70,96,FALSE,yes
    ......
    :return:
    """
    df = pd.read_csv('dtree.csv')
    #将数据转换为字典格式，orient="record"参数指定数据格式为{column:value}的形式
    #第一行数据为{Outlook:'sunny',Temperatur:85,Humidity:85,Windy:False,PlayGolf:no}
    #一个字典对应一行数据
    dict_train  = df.loc[:,['Outlook','Temperatur','Humidity','Windy']].to_dict(orient="record")
    #如果pandas从DataFrame取出一列数据，该数据类型会变为Series
    dict_target = pd.DataFrame(df['PlayGolf'],columns=['PlayGolf']).to_dict(orient="record")
    #训练数据字典向量化
    dv_train = DictVectorizer(sparse=False)
    x_train = dv_train.fit_transform(dict_train)

    #目标数据字典向量化
    dv_target = DictVectorizer(sparse=False)
    y_target = dv_target.fit_transform(dict_target)


    #创建训练模型并训练
    d_tree = DecisionTreeClassifier()
    d_tree.fit(x_train,y_target)

    data_predict = {'Humidity': 85,
      'Outlook': 'sunny',
      'Temperatur': 85,
      'Windy': False}

    x_data = dv_train.transform(data_predict)
    print dv_target.inverse_transform(d_tree.predict(x_data))

def article_category():
    #http://scikit-learn.org/stable/modules/naive_bayes.html#multinomial-naive-bayes
    """
    使用朴素贝叶斯，根据关键词对文章内容进行分类
    20newsgroups中的数据形式:
    ['文章1','文章2',........,'文章n']
    整体是一个数组，文章n代表一段文字
    :return:
    """
    #加载20newsgroups数据源，里面是主要英文报刊杂志的文章整理
    #categories指明要加载的文章类别，subset指明要加载训练集
    categories = ['alt.atheism', 'soc.religion.christian', 'comp.graphics', 'sci.med']
    twenty_train = fetch_20newsgroups(subset='train',categories=categories)

    #计算所有文章的TFIDF
    tfidf_transformer = TfidfVectorizer()
    X_train_tfidf = tfidf_transformer.fit_transform(twenty_train.data)
    #构建多项式朴素贝叶斯模型
    clf = MultinomialNB(alpha=1.0).fit(X_train_tfidf, twenty_train.target)
    #需要判断类别的两篇文章
    docs_new = ['Chemical reaction', 'Intel CPU is good']
    #将要判断的文章向量花
    X_new_tfidf = tfidf_transformer.transform(docs_new)
    #进行预测
    predicted = clf.predict(X_new_tfidf)
    #zip 将数组a[1,2,3] b['a','b','c']变为[(1,'a'),(2,'b'),(3,'c')]
    for doc, category in zip(docs_new, predicted):
        print('%r => %s' % (doc, twenty_train.target_names[category]))


from sklearn.svm import LinearSVC
import matplotlib.pyplot as plt
#支持向量机:找到分类界面，使支持向量间的间隔最大，支持向量到分割界面的距离最小
#支持向量是通过到分割界面距离最小的点的向量，且两向量间的距离最大
def hw_recognition():
    #http://scikit-learn.org/stable/modules/svm.html
    digits = load_digits()
    #random_state 设置随机种子
    X_train, X_test, Y_train, Y_test = train_test_split(digits.data, digits.target,
                                                        test_size=0.25, random_state=23)
    ss = StandardScaler()
    #fit是实例方法，必须由实例调用
    X_train = ss.fit_transform(X_train)
    X_test = ss.transform(X_test)

    lsvc = LinearSVC()
    lsvc.fit(X_train, Y_train)

    #Y_predict = lsvc.predict(np.array([digits.data[220]]))
    #plt.imshow(digits.images[220])
    #print Y_predict
    #plt.show()
    Y_predict = lsvc.predict(X_test)
    #生成评估报告:
    #precision(精确率) = 正正/(正正+反正)
    #recall(召回率，覆盖率)    = 正正/(正正+正反)
    #按照行解释正反: 正正:真正的正例预测为正例，正反:真正的正例预测为反例，反正:真正的反例预测为正例，
    #反反:真正的反例预测为反例
    print classification_report(Y_test, Y_predict, target_names=digits.target_names.astype(str))



def kmeans_plot():
    """
    #http://scikit-learn.org/stable/modules/clustering.html
    kmeans算法的过程:(假如有两类)
    1.随机选择两个点作为聚类的中心
    2.计算所有点距离两个中心的距离，选择距离较近的点作为类别。(例如:距离蓝点近，类别是蓝色)
    3.计算已经分好类的各组数据的平均值，使用各组数据的平均值中心作为新的中心
    4.以新的中心为依据，跳转到第2步
    5.直到收敛(两次迭代的数值没有明显的变化:新中心点距离上一次计算中心点的距离小于某个阈值，例如：0.03)

    """
    plt.figure(figsize=(6, 3))

    n_samples = 1500
    random_state = 170
    X, y = make_blobs(n_samples=n_samples, random_state=random_state)
    y_pred = KMeans(n_clusters=2, random_state=random_state).fit_predict(X)

    plt.subplot(121)
    plt.scatter(X[:, 0], X[:, 1], c=y_pred)

    plt.subplot(122)
    plt.scatter(X[:, 0], X[:, 1], c=y)


hw_recognition()

"""
A,B表明两个工作地点的收益，A一个小时50$,B一个小时100$
W1,W2是两地工作时间，称为:权重，机器学习中要调整的系数,[W1,W2]构成一个二维搜索空间
T = W1 * A + W2 * B 是我们的评估函数
TMax = 650 是期望目标，也是我们的学习目标
每天工作8小时，每地至少工作一小时,这是学习约束

delta = |T - TMax| 绝对值是我们的评估函数,损失函数(cost,loss)
delta达到什么结果搜索结束，由算法来设计,例如delta=1 搜索结束(搜索结束也称为函数收敛)

在搜索空间中尝试搜索过程中，对W1、W2改变的幅度称为学习率
"""