機器學習基石作業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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    y_train[x_count,0] = int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    x.append(int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    x.append(int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    x.append(int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    y_test[x_count, 0] = (int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    x.append(int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    y_test[x_count, 0] = (int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    x.append(int(str.split('\t')[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('\t')) == 1:
                    x.append(float(str))
                else:
                    x.append(float(str.split('\t')[0]))
                    y_test[x_count, 0] = (int(str.split('\t')[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道題看似不多，但是工作量真是大啊，概念，計算，編程全部都涵蓋了，真是不容易。。。

后面再接再厲了~