机器学习基石作业1

第一题很明显：（1）质数有很明确的定义，所以辨别质数并不需要ML；（2）在课件中反复提到的信用卡发放问题；（3）计算重力加

速度有明确的方法，不需要ML；（4）在繁忙十字路口最优交通红绿灯的周期，由于每端时间的车流量很难去预测，所以需要ML去自

己学习控制周期；（5）根据年龄推荐医学检验，无法通过明确定义程序直接判断，电脑需要自己ML得出值得推荐的结果。

下棋时data是一笔一笔喂给电脑，每一步没有明确的label，题目中也提到了feedback，也就是奖惩，所以很明显是reinforcement

learning

依题意书并没有label，和课件中的例子articles=>topic，一样，很明显是unsupervised learning

依题意是binary classification，每个x有明确的label，所以是supervised learning

评估药物的疗效，由于每次实验很贵，也就是标注每个x很贵，所以我们的data只有一部分有label，只有当机器不确定的情况，我们才

去做实验获得label，所以这是active learning

Off-Training-Set error即不在训练集中的测试错误，所以我们求的是N+1~N+L的error，依题意只有当

1~N+L中的数是偶数的时候f ≠ g产生error，所以1~N+L中共有⌊(N+L)/2⌋个偶数，1~N中共有⌊N/2⌋

个偶数，所以N+1~N+L中有⌊(N+L)/2⌋-⌊N/2⌋个偶数，所以Eots = 1/L * (⌊(N+L)/2⌋-⌊N/2⌋)

这道题乍一看真是绕啊。。。仔细分析一下，有多少种能产生D in a noiseless setting的f，也就是说在D内这些f产生的值都是相同

的，这些f的不同都发生在N+1~N+L中，在N+1~N+L中每个值都有{-1,1}两种取值，所以共有2ˆL种不同的情况，即能产生2ˆL个

不同的f

前三个选项很明显可以看出来不对，思考下第四个选项为什么对，Eots是不在训练集中的测试错误，也就是A(D)和f在N+1~N+L上结

果的差异，通过上题我们知道，f已经取得了N+1~N+L上所有可能的结果，所以A₁(D)和A_{2^{(D)在N+1~N+L上的取值，都是f中的一}}

^{_{种，所以A1(D)和A2(D)与所有f的Eots取期望，是一样的。（我们可以这样计算，对于每一个A，A(D)与f的差异都是从0到f分布的，}}

_{^{我们都可以通过如下方法计算：}}

_{^{0位差异:C(L,0)个，1位差异:C(L,1）个，2位差异：C(L,2)，3位差异：C(L,3)，······，L位差异:C(L,L)。所以不管什么A值都是一}}

_{^{样的，期望也就是一样的。)}}

 这道题就是比较简单的概率计算：C(10,5) * 0.5ˆ10 ≈0.24

C(10,1) * 0.1 * 0.9ˆ9 ≈ 0.39

C(10,1) * 0.9 * 0.1ˆ9 + 0.1ˆ10 = 9.1*10^-9

hoeffding不等式：P(|v - µ| > 0.8) ≤ 2*eˆ(-2 * 0.8ˆ2 * 10) ≈ 5.52*10^-6

又是概率问题，出现5个橘色1的概率，橘色1出现在B和C类型骰子里，所以

（1/4 * 0 + 1/4 * 1 + 1/4 * 1 + 1/4 * 0）ˆ5 = 1/32 = 8/256

上一题的升级版，能出现的纯橘色数字1,2,3,4,5,6，其中1,3分布在B和C类型的骰子上，4,6出现在A和D类型的骰子上，2出现在A,C

类型的骰子上，5出现在B,D类型的骰子上。针对这4中情况来计算：

(1) （1/4 * 0 + 1/4 * 1 + 1/4 * 1 + 1/4 * 0）ˆ5 = 1/32

(2) （1/4 * 1 + 1/4 * 0 + 1/4 * 0 + 1/4 * 1）ˆ5 = 1/32

(3) （1/4 * 1 + 1/4 * 0 + 1/4 * 1 + 1/4 * 0）ˆ5 = 1/32

(4) （1/4 * 0 + 1/4 * 1 + 1/4 * 0 + 1/4 * 1）ˆ5 = 1/32

由于(1)和(3)中有C重复，(1)和(4)中有B重复，(2)和(3)中有A重复，(2)和(4)中有D重复，需要去掉重复的情况

所以(1)+(3)+(2)+(4) - 1/4ˆ5 * 4 = 1/8 - 1/256 = 31/256

navi cycle的意思是，每次发生的错误时，循环不重新开始，而是接着进行。程序代码如下

import numpy

class navi_cycle_PLA(object):
    def __init__(self, dimension, count):
        self.__dimension = dimension
        self.__count = count

    def train_Matrix(self, path):
        training_set = open(path)
        X_train = numpy.zeros((self.__count, self.__dimension))
        y_train = numpy.zeros((self.__count, 1))
        x = []
        x_count = 0
        for line in training_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    y_train[x_count,0] = int(str.split('	')[1].strip())
            X_train[x_count,:] = x
            x = []
            x_count += 1
        return X_train, y_train

    def interationCount(self, path):
        count = 0
        X_train, y_train = self.train_Matrix(path)
        w = numpy.zeros((self.__dimension, 1))
        while True:
            flag = 0
            for i in range(self.__count):
                if numpy.dot(X_train[i, :], w)[0] * y_train[i, 0] <= 0:
                    w += y_train[i, 0] * X_train[i,:].reshape(5, 1)
                    count += 1
                    flag = 1
            if flag == 0:
                break
        return count

my_Percetron = navi_cycle_PLA(5, 400)
print my_Percetron.interationCount("ntumlone_hw1_hw1_15_train.dat")

每次实验前把X的顺序打乱，重复2000次

import numpy
import random

class random_PLA(object):
    def __init__(self, dimension, count):
        self.__dimension = dimension
        self.__count = count

    def random_Matrix(self, path):
        training_set = open(path)
        randomLst = []
        x = []
        x_count = 0
        for line in training_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    x.append(int(str.split('	')[1].strip()))
            randomLst.append(x)
            x = []
            x_count += 1
        return randomLst

    def train_Maxtrix(self, path):
        X_train = numpy.zeros((self.__count, self.__dimension))
        y_train = numpy.zeros((self.__count, 1))
        randomLst = self.random_Matrix(path)
        random.shuffle(randomLst)
        for i in range(self.__count):
            for j in range(self.__dimension):
                X_train[i, j] = randomLst[i][j]
            y_train[i, 0] = randomLst[i][self.__dimension]
        return X_train, y_train


    def interationCount(self, path):
        count = 0
        X_train, y_train = self.train_Maxtrix(path)
        w = numpy.zeros((self.__dimension, 1))
        while True:
            flag = 0
            for i in range(self.__count):
                if numpy.dot(X_train[i, :], w)[0] * y_train[i, 0] <= 0:
                    w += y_train[i, 0] * X_train[i,:].reshape(5, 1)
                    count += 1
                    flag = 1
            if flag == 0:
                break
        return count

average_count = 0
for i in range(2000):
    my_Percetron = random_PLA(5, 400)
    average_count += my_Percetron.interationCount('ntumlone_hw1_hw1_15_train.dat')
print average_count / 2000.0

这次是在w每次更新的时候加上一个权重0.5

import numpy
import random

class random_PLA(object):
    def __init__(self, dimension, count):
        self.__dimension = dimension
        self.__count = count

    def random_Matrix(self, path):
        training_set = open(path)
        randomLst = []
        x = []
        x_count = 0
        for line in training_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    x.append(int(str.split('	')[1].strip()))
            randomLst.append(x)
            x = []
            x_count += 1
        return randomLst

    def train_Maxtrix(self, path):
        X_train = numpy.zeros((self.__count, self.__dimension))
        y_train = numpy.zeros((self.__count, 1))
        randomLst = self.random_Matrix(path)
        random.shuffle(randomLst)
        for i in range(self.__count):
            for j in range(self.__dimension):
                X_train[i, j] = randomLst[i][j]
            y_train[i, 0] = randomLst[i][self.__dimension]
        return X_train, y_train


    def interationCount(self, path):
        count = 0
        X_train, y_train = self.train_Maxtrix(path)
        w = numpy.zeros((self.__dimension, 1))
        while True:
            flag = 0
            for i in range(self.__count):
                if numpy.dot(X_train[i, :], w)[0] * y_train[i, 0] <= 0:
                    w += 0.5 * y_train[i, 0] * X_train[i,:].reshape(5, 1)
                    count += 1
                    flag = 1
            if flag == 0:
                break
        return count

average_count = 0
for i in range(2000):
    my_Percetron = random_PLA(5, 400)
    average_count += my_Percetron.interationCount('ntumlone_hw1_hw1_15_train.dat')
print average_count / 2000.0

从这题开始，考察的是Pocket算法了，话不多说，上代码：

import numpy
import random
import copy

class Pocket(object):
    def __init__(self, dimension, train_count, test_count):
        self.__dimension = dimension
        self.__train_count = train_count
        self.__test_count = test_count

    def random_Matrix(self, path):
        training_set = open(path)
        randomLst = []
        x = []
        x_count = 0
        for line in training_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    x.append(int(str.split('	')[1].strip()))
            randomLst.append(x)
            x = []
            x_count += 1
        return randomLst

    def train_Maxtrix(self, path):
        X_train = numpy.zeros((self.__train_count, self.__dimension))
        y_train = numpy.zeros((self.__train_count, 1))
        randomLst = self.random_Matrix(path)
        random.shuffle(randomLst)
        for i in range(self.__train_count):
            for j in range(self.__dimension):
                X_train[i, j] = randomLst[i][j]
            y_train[i, 0] = randomLst[i][self.__dimension]
        return X_train, y_train


    def interationW(self, path):
        count = 0
        X_train, y_train = self.train_Maxtrix(path)
        w = numpy.zeros((self.__dimension, 1))
        bestCount = self.__train_count
        bestW = numpy.zeros((self.__dimension, 1))

        while True:
            for i in range(self.__train_count):
                if numpy.dot(X_train[i, :], w)[0] * y_train[i, 0] <= 0:
                    w += 0.5 * y_train[i, 0] * X_train[i,:].reshape(5, 1)
                    count += 1
                    num = 0
                    for j in range(self.__train_count):
                        if numpy.dot(X_train[j, :], w)[0] * y_train[j, 0] <= 0:
                            num += 1
                    if num < bestCount:
                        bestCount = num
                        bestW = copy.deepcopy(w)
                    if count == 50:
                        break
            if count == 50:
                break
        return bestW

    def test_Matrix(self, test_path):
        X_test = numpy.zeros((self.__test_count, self.__dimension))
        y_test = numpy.zeros((self.__test_count, 1))
        test_set = open(test_path)
        x = []
        x_count = 0
        for line in test_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    y_test[x_count, 0] = (int(str.split('	')[1].strip()))
            X_test[x_count, :] = x
            x = []
            x_count += 1
        return X_test, y_test

    def testError(self, train_path, test_path):
        w = self.interationW(train_path)
        X_test, y_test = self.test_Matrix(test_path)
        count = 0.0
        for i in range(self.__test_count):
            if numpy.dot(X_test[i, :], w)[0] * y_test[i, 0] <= 0:
                count += 1
        return count / self.__test_count

average_error_rate = 0
for i in range(2000):
    my_Pocket = Pocket(5, 500, 500)
    average_error_rate += my_Pocket.testError('ntumlone_hw1_hw1_18_train.dat', 'ntumlone_hw1_hw1_18_test.dat')
print average_error_rate / 2000.0

这道题意在，Pocket和PLA做对比，看样看出Pocket算法在同等更新下好很多：

import numpy
import random

class random_PLA(object):
    def __init__(self, dimension, train_count, test_count):
        self.__dimension = dimension
        self.__train_count = train_count
        self.__test_count = test_count

    def random_Matrix(self, path):
        training_set = open(path)
        randomLst = []
        x = []
        x_count = 0
        for line in training_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    x.append(int(str.split('	')[1].strip()))
            randomLst.append(x)
            x = []
            x_count += 1
        return randomLst

    def train_Maxtrix(self, path):
        X_train = numpy.zeros((self.__train_count, self.__dimension))
        y_train = numpy.zeros((self.__train_count, 1))
        randomLst = self.random_Matrix(path)
        random.shuffle(randomLst)
        for i in range(self.__train_count):
            for j in range(self.__dimension):
                X_train[i, j] = randomLst[i][j]
            y_train[i, 0] = randomLst[i][self.__dimension]
        return X_train, y_train


    def interationW(self, path):
        count = 0
        X_train, y_train = self.train_Maxtrix(path)
        w = numpy.zeros((self.__dimension, 1))
        while True:
            for i in range(self.__train_count):
                if numpy.dot(X_train[i, :], w)[0] * y_train[i, 0] <= 0:
                    w += 0.5 * y_train[i, 0] * X_train[i,:].reshape(5, 1)
                    count += 1
                if count == 50:
                    break
            if count == 50:
                break
        return w

    def test_Matrix(self, test_path):
        X_test = numpy.zeros((self.__test_count, self.__dimension))
        y_test = numpy.zeros((self.__test_count, 1))
        test_set = open(test_path)
        x = []
        x_count = 0
        for line in test_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    y_test[x_count, 0] = (int(str.split('	')[1].strip()))
            X_test[x_count, :] = x
            x = []
            x_count += 1
        return X_test, y_test

    def testError(self, train_path, test_path):
        w = self.interationW(train_path)
        X_test, y_test = self.test_Matrix(test_path)
        count = 0.0
        for i in range(self.__test_count):
            if numpy.dot(X_test[i, :], w)[0] * y_test[i, 0] <= 0:
                count += 1
        return count / self.__test_count

average_error_rate = 0
for i in range(2000):
    my_PLA = random_PLA(5, 500, 500)
    average_error_rate += my_PLA.testError('ntumlone_hw1_hw1_18_train.dat', 'ntumlone_hw1_hw1_18_test.dat')
print average_error_rate / 2000.0

和第18题一样，只是把更新次数增大到100：

import numpy
import random
import copy

class Pocket(object):
    def __init__(self, dimension, train_count, test_count):
        self.__dimension = dimension
        self.__train_count = train_count
        self.__test_count = test_count

    def random_Matrix(self, path):
        training_set = open(path)
        randomLst = []
        x = []
        x_count = 0
        for line in training_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    x.append(int(str.split('	')[1].strip()))
            randomLst.append(x)
            x = []
            x_count += 1
        return randomLst

    def train_Maxtrix(self, path):
        X_train = numpy.zeros((self.__train_count, self.__dimension))
        y_train = numpy.zeros((self.__train_count, 1))
        randomLst = self.random_Matrix(path)
        random.shuffle(randomLst)
        for i in range(self.__train_count):
            for j in range(self.__dimension):
                X_train[i, j] = randomLst[i][j]
            y_train[i, 0] = randomLst[i][self.__dimension]
        return X_train, y_train


    def interationW(self, path):
        count = 0
        X_train, y_train = self.train_Maxtrix(path)
        w = numpy.zeros((self.__dimension, 1))
        bestCount = self.__train_count
        bestW = numpy.zeros((self.__dimension, 1))

        while True:
            for i in range(self.__train_count):
                if numpy.dot(X_train[i, :], w)[0] * y_train[i, 0] <= 0:
                    w += 0.5 * y_train[i, 0] * X_train[i,:].reshape(5, 1)
                    count += 1
                    num = 0
                    for j in range(self.__train_count):
                        if numpy.dot(X_train[j, :], w)[0] * y_train[j, 0] <= 0:
                            num += 1
                    if num < bestCount:
                        bestCount = num
                        bestW = copy.deepcopy(w)
                    if count == 100:
                        break
            if count == 100:
                break
        return bestW

    def test_Matrix(self, test_path):
        X_test = numpy.zeros((self.__test_count, self.__dimension))
        y_test = numpy.zeros((self.__test_count, 1))
        test_set = open(test_path)
        x = []
        x_count = 0
        for line in test_set:
            x.append(1)
            for str in line.split(' '):
                if len(str.split('	')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('	')[0]))
                    y_test[x_count, 0] = (int(str.split('	')[1].strip()))
            X_test[x_count, :] = x
            x = []
            x_count += 1
        return X_test, y_test

    def testError(self, train_path, test_path):
        w = self.interationW(train_path)
        X_test, y_test = self.test_Matrix(test_path)
        count = 0.0
        for i in range(self.__test_count):
            if numpy.dot(X_test[i, :], w)[0] * y_test[i, 0] <= 0:
                count += 1
        return count / self.__test_count

average_error_rate = 0
for i in range(2000):
    my_Pocket = Pocket(5, 500, 500)
    average_error_rate += my_Pocket.testError('ntumlone_hw1_hw1_18_train.dat', 'ntumlone_hw1_hw1_18_test.dat')
print average_error_rate / 2000.0

到此第一次作业就全部完成了~~20道题看似不多，但是工作量真是大啊，概念，计算，编程全部都涵盖了，真是不容易。。。

后面再接再厉了~