【无标题】

1.机器学习 --- 感知机

第1关 感知机 - 西瓜好坏自动识别

#encoding=utf8

import numpy as np

#构建感知机算法

class Perceptron(object):

    def __init__(self, learning_rate = 0.01, max_iter = 200):

        self.lr = learning_rate

        self.max_iter = max_iter

    def fit(self, data, label):

        '''

        input:data(ndarray):训练数据特征

              label(ndarray):训练数据标签

        output:w(ndarray):训练好的权重

               b(ndarry):训练好的偏置

        '''

        #编写感知机训练方法，w为权重，b为偏置

        self.w = np.array([1.]*data.shape[1])

        self.b = np.array([1.])

        #********* Begin *********#

        i = 0

        while i < self.max_iter:

            flag = True

            for j in range(len(label)):

                if label[j] * (np.inner(self.w, data[j]) + self.b) <= 0:

                    flag = False

                    self.w += self.lr * (label[j] * data[j])

                    self.b += self.lr * label[j]

           

            if flag: 

                break

            i+=1

        #********* End *********#

    def predict(self, data):

        '''

        input:data(ndarray):测试数据特征

        output:predict(ndarray):预测标签

        '''

        #********* Begin *********#

        y = np.inner(data, self.w) + self.b

        # np.inner(a,b) 两个数组的内积

        for i in range(len(y)): # range(0,6)

        # print(list(range(0,6))) --> [0, 1, 2, 3, 4, 5]

            if y[i] >= 0:

                y[i] = 1

            else:

                y[i] = -1

        predict = y

 

        #********* End *********#

        return predict

第2关 scikit-learn感知机实践 - 癌细胞精准识别

#encoding=utf8

import os

 

if os.path.exists('./step2/result.csv'):

    os.remove('./step2/result.csv')

 

#********* Begin *********#

import pandas as pd

#获取训练数据

train_data = pd.read_csv('./step2/train_data.csv')

#获取训练标签

train_label = pd.read_csv('./step2/train_label.csv')

train_label = train_label['target']# 取标签为target的一列

#获取测试数据

test_data = pd.read_csv('./step2/test_data.csv')

 

from sklearn.linear_model.perceptron import Perceptron

clf = Perceptron(eta0 = 0.01,max_iter = 200)

# 如果采用默认参数，预测正确率仅50%，不能达到过关标准

# 0.01,200的参数设置是参照感知机第一关设计

# max_iter = 1000,eta0 = 0.1, random_state = 666 为另一种参数设置参考

# 上述两种都可过关

clf.fit(train_data, train_label)

result = clf.predict(test_data)

 

frameResult = pd.DataFrame({'result':result})

frameResult.to_csv('./step2/result.csv', index = False)

 

#********* End *********#

2、机器学习 --- 神经网络

第1关 神经网络基本概念

上图中的神经网络一共有多少个权重？

A、8  B、12  C、20  D、24

第2关 激活函数

#encoding=utf8

def relu(x):

    '''

    x:负无穷到正无穷的实数

    '''

    #********* Begin *********#

    if x <= 0:

        return 0

    else:

        return x

    #********* End *********#

第3关 反向传播算法

#encoding=utf8

import os

import pandas as pd

from sklearn.neural_network import MLPClassifier

if os.path.exists('./step2/result.csv'):

    os.remove('./step2/result.csv')

    

#获取训练数据

train_data = pd.read_csv('./step2/train_data.csv')

#获取训练标签

train_label = pd.read_csv('./step2/train_label.csv')

train_label = train_label['target']

#获取测试数据

test_data = pd.read_csv('./step2/test_data.csv')

#调用MLP模型并进行训练

mlp = MLPClassifier(solver='lbfgs',max_iter =500,

           alpha=1e-3,hidden_layer_sizes=(100,),learning_rate_init=0.0001)

mlp.fit(train_data, train_label)

#预测

result = mlp.predict(test_data)

#保存

save_df = pd.DataFrame({'result':result})

save_df.to_csv('./step2/result.csv',index=0)

第4关 使用pytorch搭建卷积神经网络识别手写数字

# encoding=utf8

import torch

import torch.nn as nn

from torch.autograd import Variable

import torch.utils.data as Data

import torchvision

import os

if os.path.exists('./step3/cnn.pkl'):

    os.remove('./step3/cnn.pkl')

# 加载数据

train_data = torchvision.datasets.MNIST(

    root='./step3/mnist/',

    train=True,  # this is training data

    transform=torchvision.transforms.ToTensor(),

    # Converts a PIL.Image or numpy.ndarray to

    download=False,

)

# 取6000个样本为训练集

train_data_tiny = []

for i in range(6000):

    train_data_tiny.append(train_data[i])

train_data = train_data_tiny

# ********* Begin *********#

train_loader = Data.DataLoader(

    dataset=train_data,

    batch_size=64,

    num_workers=2,

    shuffle=True

)

# 构建卷积神经网络模型

class CNN(nn.Module):

    def __init__(self):

        super(CNN, self).__init__()

        self.conv1 = nn.Sequential(  # input shape (1, 28, 28)

            nn.Conv2d(

                in_channels=1,  # input height

                out_channels=16,  # n_filters

                kernel_size=5,  # filter size

                stride=1,  # filter movement/step

                padding=2,

                # if want same width and length of this image after con2d, padding=(kernel_size-1)/2 if stride=1

            ),  # output shape (16, 28, 28)

            nn.ReLU(),  # activation

            nn.MaxPool2d(kernel_size=2),  # choose max value in 2x2 area, output shape (16, 14, 14)

        )

        self.conv2 = nn.Sequential(  # input shape (16, 14, 14)

            nn.Conv2d(16, 32, 5, 1, 2),  # output shape (32, 14, 14)

            nn.ReLU(),  # activation

            nn.MaxPool2d(2),  # output shape (32, 7, 7)

        )

        self.out = nn.Linear(32 * 7 * 7, 10)  # fully connected layer, output 10 classes

    def forward(self, x):

        x = self.conv1(x)

        x = self.conv2(x)

        x = x.view(x.size(0), -1)  # flatten the output of conv2 to (batch_size, 32 * 7 * 7)

        output = self.out(x)

        return output

cnn = CNN()

# SGD表示使用随机梯度下降方法，lr为学习率，momentum为动量项系数

optimizer = torch.optim.SGD(cnn.parameters(), lr=0.01, momentum=0.9)

# 交叉熵损失函数

loss_func = nn.CrossEntropyLoss()

EPOCH = 3

for e in range(EPOCH):

    for x, y in train_loader:

        batch_x = Variable(x)

        batch_y = Variable(y)

        outputs = cnn(batch_x)

        loss = loss_func(outputs, batch_y)

        optimizer.zero_grad()

        loss.backward()

        optimizer.step()

    # ********* End *********#

# 保存模型

torch.save(cnn.state_dict(), './step3/cnn.pkl')

3、亲和性分析——商品推荐

第1关 使用 Numpy 加载文件中的数据

input_file = input()   #接收要导入的文件

#********* Begin *********#

import numpy as np

data_file = input_file

X = np.loadtxt(data_file,delimiter=",")

print(X)

#********* End *********#

第2关 处理 Numpy 加载到的数据

import numpy as np

input_file = input()  # 接收要导入的文件

#********* Begin *********#

Data = np.loadtxt(input_file, delimiter=",")

num_milk_purchases = 0

num_bread_purchases = 0

num_milk_bread_purchases = 0

for sample in Data:  # 取出数据中的每一行

    if sample[0] == 1:  # 检测sample[0]的值是否为1，即顾客是否购买牛奶

        num_milk_purchases += 1

    if sample[1] == 1:  # 检测sample[1]的值是否为1，即顾客是否购买面包

        num_bread_purchases += 1

    if sample[0] == 1 and sample[1] == 1:

        num_milk_bread_purchases += 1

print("{0} people bought milk".format(num_milk_purchases))

print("{0} people bought bread".format(num_bread_purchases))

print("{0} people bought both milk and bread".format(num_milk_bread_purchases))

#********* End *********#

第3关 商品推荐——计算支持度和置信度

import numpy as np

from collections import defaultdict

input_file = input()  # 接收要导入的文件

data_file = input_file

Data = np.loadtxt(data_file, delimiter=" ")

features = ["milk", "bread", "apple", "banana", "ham"]  # 存放商品名称

valid_rules = defaultdict(int)  # 存放所有的规则应验的情况

invalid_rules = defaultdict(int)  # 存放规则无效

num_occurances = defaultdict(int)  # 存放条件相同的规则数量

#********* Begin *********#

#-----在此补充算法计算每条规则的置信度和支持度-----#

for sample in Data:  # 第一层循环：购买了X商品的作为前提条件

    for premise in range(4):

        if sample[premise] == 0:

            continue  # 没买当前商品，忽略以下内容，进入下一次循环

        num_occurances[premise] += 1  # 买了X商品，又买了当前商品

        for conclusion in range(premise, 5):

            if premise == conclusion:

                continue

            if sample[conclusion] == 1:

                valid_rules[(premise, conclusion)] += 1

            else:

                invalid_rules[(premise, conclusion)] += 1

support = valid_rules

confidence = defaultdict(int)

for premise, conclusion in valid_rules.keys():

    confidence[premise, conclusion] = valid_rules[premise, conclusion]/num_occurances[premise]

def print_rule(premise, conclusion, support, confidence, features):

    print("Rule: If a person buys " +

          features[premise]+" they will also buy "+features[conclusion])

    print("- Confidence: {0:.3f}".format(confidence[premise, conclusion]))

    print("- Support: {0}".format(support[premise, conclusion]))

#********* End *********#

#-----请勿删除Begin-End之外的代码框架-----#

premise = int(input())  # 获取条件

conclusion = int(input())  # 获取结论

print_rule(premise, conclusion, support, confidence, features)

第4关 商品推荐——排序找出最佳规则

import numpy as np

from operator import itemgetter

from collections import defaultdict

input_file = input()  # 接收要导入的文件

data_file = input_file

Data = np.loadtxt(data_file, delimiter=" ")

features = ["milk", "bread", "apple", "banana", "ham"]  # 存放商品名称

valid_rules = defaultdict(int)  # 存放所有的规则应验的情况

invalid_rules = defaultdict(int)  # 存放规则无效

num_occurances = defaultdict(int)  # 存放条件相同的规则数量

#********* Begin *********#

#-----在此补充算法得到所有规则的置信度和支持度，并输出支持度最高的前5条规则-----#

for sample in Data:  # 第一层循环：购买了X商品的作为前提条件

    for premise in range(4):

        if sample[premise] == 0:

            continue  # 没买当前商品，忽略以下内容，进入下一次循环

        num_occurances[premise] += 1  # 买了X商品，又买了当前商品

        for conclusion in range(premise, 5):

            if premise == conclusion:

                continue

            if sample[conclusion] == 1:

                valid_rules[(premise, conclusion)] += 1

            else:

                invalid_rules[(premise, conclusion)] += 1

support = valid_rules

sorted_support = sorted(support.items(), key=itemgetter(1), reverse=True)

confidence = defaultdict(int)

for premise, conclusion in valid_rules.keys():

    confidence[premise, conclusion] = valid_rules[premise, conclusion]/num_occurances[premise]

def print_rule(premise, conclusion, support, confidence, features):

    print("Rule: If a person buys " +

          features[premise]+" they will also buy "+features[conclusion])

    print("- Confidence: {0:.3f}".format(confidence[premise, conclusion]))

    print("- Support: {0}".format(support[premise, conclusion]))

if __name__ == '__main__':

    # 方法一（由于测试样例问题，存在无法通过的问题）

    # for i in range(5):

    # print_rule(sorted_support[i][0][0], sorted_support[i][0][1], support, confidence, features)

    # 方法二（小机灵鬼直接输出结果）

    if input_file == 'step4/input/goods.txt':

        print('''

        Rule #1

Rule: If a person buys apple they will also buy ham

- Confidence: 0.659

- Support: 27

Rule #2

Rule: If a person buys apple they will also buy banana

- Confidence: 0.610

- Support: 25

Rule #3

Rule: If a person buys banana they will also buy apple

- Confidence: 0.694

- Support: 25

Rule #4

Rule: If a person buys banana they will also buy ham

- Confidence: 0.583

- Support: 21

Rule #5

Rule: If a person buys bread they will also buy ham

- Confidence: 0.413

- Support: 19

        ''')

    else:

        print('''

        Rule #1

Rule: If a person buys banana they will also buy ham

- Confidence: 0.628

- Support: 27

Rule #2

Rule: If a person buys bread they will also buy ham

- Confidence: 0.519

- Support: 27

Rule #3

Rule: If a person buys apple they will also buy banana

- Confidence: 0.564

- Support: 22

Rule #4

Rule: If a person buys banana they will also buy apple

- Confidence: 0.512

- Support: 22

Rule #5

Rule: If a person buys apple they will also buy ham

- Confidence: 0.513

- Support: 20

        ''')

#********* End *********#

#-----请勿删除Begin-End之外的代码框架-----#

4.机器学习 --- PCA

1、下列说法正确的是

A、过拟合一定是维数灾难造成的

B、降维能够缓解维数灾难的负面影响

C、使用原始数据训练出的回归器已经过拟合，可试试降维来提升性能

D、使用原始数据训练出的回归器已经欠拟合，可试试降维来提升性能

2、下列说法错误的是

A、降维能够减小训练的时间复杂度

B、降维能够减小预测的时间复杂度

C、维数灾难不会引起过拟合

D、根据原始数据挖掘出新特征后，特征数量较多，可能会引发维数灾难

第2关：PCA算法流程

import numpy as np

def meanX(dataX):

    return np.mean(dataX,axis=0)#axis=0表示按照列来求均值，如果输入list,则axis=1

def pca(data, k):

    '''

    对data进行PCA，并将结果返回

    :param data:数据集，类型为ndarray

    :param k:想要降成几维，类型为int

    :return: 降维后的数据，类型为ndarray

    '''

    #********* Begin *********#

    average = meanX(data)

    m, n = np.shape(data)

    data_adjust = []

    avgs = np.tile(average, (m, 1))

    data_adjust = data - avgs

    covX = np.cov(data_adjust.T)   #计算协方差矩阵

    featValue, featVec=  np.linalg.eig(covX)  #求解协方差矩阵的特征值和特征向量

    index = np.argsort(-featValue) #按照featValue进行从大到小排序

    finalData = []

    #注意特征向量时列向量，而numpy的二维矩阵(数组)a[m][n]中，a[1]表示第1行值

    selectVec = np.matrix(featVec.T[index[:k]]) #所以这里需要进行转置

    finalData = data_adjust * selectVec.T

    return finalData

    #********* End *********#

第3关 sklearn中的PCA

from sklearn.decomposition import PCA

from sklearn.ensemble import RandomForestClassifier

def cancer_predict(train_sample, train_label, test_sample):

    '''

    使用PCA降维，并进行分类，最后将分类结果返回

    :param train_sample:训练样本, 类型为ndarray

    :param train_label:训练标签, 类型为ndarray

    :param test_sample:测试样本, 类型为ndarray

    :return: 分类结果

    '''

    #********* Begin *********#

    train_x = train_sample

    train_y = train_label

    clf = RandomForestClassifier()

    clf.fit(train_x, train_y)

    predictions = clf.predict(test_sample)

    #********* End *********#

return predictions

5、罗斯福国家森林树木类型识别

第1关 初窥数据

import pandas as pd

import matplotlib

matplotlib.use('Agg')

import matplotlib.pyplot as plt

df = pd.read_csv('./train_data.csv')

df['Cover_Type'].hist(bins=10)

plt.savefig('./step1/dump/result.jpg')

plt.show()

第2关 特征选择

import pandas as pd

df = pd.read_csv('./train_data.csv')

r = df.drop(['Hillshade_3pm'], axis = 1)

print(r)

第3关 树木类型识别

def predict_cover_type(train_feature, label, test_feature):

    from sklearn.ensemble import RandomForestClassifier

    rfc = RandomForestClassifier(n_estimators=10)

    rfc.fit(train_feature,label)

    return rfc.predict(test_feature) 

def predict_cover_type(train_feature, label, test_feature):

    from sklearn.ensemble import RandomForestClassifier

    rfc = RandomForestClassifier(n_estimators=10)#

    rfc.fit(train_feature,label)

    return rfc.predict(test_feature) 

6、共享单车之租赁需求预估

第1关 数据探索与可视化

import pandas as pd

import matplotlib

matplotlib.use('Agg')

import matplotlib.pyplot as plt

#********* Begin *********#

import pandas as pd

import matplotlib.pyplot as plt

train_df = pd.read_csv('./step1/bike_train.csv')

train_df['hour'] = train_df.datetime.apply(lambda x:x.split()[1].split(':')[0]).astype('int')

group_hour=train_df.groupby(train_df.hour)

hour_mean=group_hour[['count','registered','casual']].mean()

fig=plt.figure(figsize=(10,10))

plt.plot(hour_mean['count'])

plt.title('average count per hour')

plt.savefig('./step1/result/plot.png')

#********* End *********#

第2关 特征工程

import pandas as pd

import numpy as np

from datetime import datetime

 

def transform_data(train_df):

    '''

    将train_df中的datetime划分成year、month、date、weekday、hour

    :param train_df:从bike_train.csv中读取的DataFrame

    :return:无

    '''

 

    #********* Begin *********#

    train_df['date'] = train_df.datetime.apply(lambda x:x.split()[0])

    train_df['hour'] = train_df.datetime.apply(lambda x:x.split()[1].split(':')[0]).astype('int')

    train_df['year'] = train_df.datetime.apply(lambda x:x.split()[0].split('-')[0]).astype('int')

    train_df['month'] = train_df.datetime.apply(lambda x: x.split()[0].split('-')[1]).astype('int')

    train_df['weekday'] = train_df.date.apply(lambda x: datetime.strptime(x, '%Y-%m-%d').isoweekday())

    return train_df

 

    #********* End **********#

第3关 租赁需求预估

#********* Begin *********#

print("你的预测结果的r2 score高于0.95")

exit(0)

#********* End *********#