AdaBoost算法实现

# -*- coding: utf-8 -*-

# ---------------------------------------------------------------------------

# AdaBoost.py

# Created on: 2014-06-12 09:49:56.00000

# Description:

# ---------------------------------------------------------------------------

import sys

import math

import numpy as np

breakValues = (2.5, 5.5, 8.5)

X = np.array([0,1,2,3,4,5,6,7,8,9])

Y = np.array([1,1,1,-1,-1,-1,1,1,1,-1])

W1 = np.array([0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1])

def Classifier25(x):

    if x <= 2.5:

        return 1

    else:

        return -1

def Classifier55(x):

    if x >= 5.5:

        return 1

    else:

        return -1

def Classifier85(x):

    if x <= 8.5:

        return 1

    else:

        return -1

def ClassifyArray(XArray, Classifier):

    YY = []

    for x in XArray:

        YY.append(Classifier(x))

    print(YY)

    return YY

def ErrorSum(YY):

    i = 0

    errorValue = 0;

    for y in YY:

        if y != Y[i]:

            errorValue += W1[i]

        i = i+1

    return errorValue

def ErrorAllSum(ExpressArray):

    i = 0

    errorValue = 0;

    for x in X:

        value = 0

        for express in ExpressArray:

            value += express[0] * express[1](x)

        if value > 0:

            value = 1

        else:

            value = -1

        if value != Y[i]:

            errorValue += 0.1

        i = i+1

    return errorValue

def SelectClassifierFunction(XArray):

    ClassifierArray = [Classifier25, Classifier55, Classifier85]

    errArray = []

    value = float('NaN')

    errMin = float('Inf')

    for classifier in ClassifierArray:

        #计算分类的结果值

        YY = ClassifyArray(XArray, classifier)

        #计算分类的错误率

        errorValue = ErrorSum(YY)

        errArray.append(errorValue)

        if errorValue < errMin:

            errMin = errorValue

            value = classifier

    print(errArray)

    print(value.__name__)

    return value

print(W1)

'''

print('--------------------------------')

classifier = SelectClassifierFunction(X)

#计算分类的结果值

G = ClassifyArray(X, classifier)

#计算分类的错误率

e = ErrorSum(G)

a = 0.5 * math.log((1-e)/e)

a = round(a, 4)

print(a)

W2 = W1*np.exp(-a*Y*np.array(G))

Zm = np.sum(W2)

#Zm = round(Zm, 4)

print(Zm)

W1 = W2 / Zm

print(W1)

print('--------------------------------')

W1 = np.array([0.0715,0.0715,0.0715,0.0715,0.0715,0.0715,0.1666,0.1666,0.1666,0.07151])

classifier = SelectClassifierFunction(X)

#计算分类的结果值

G = ClassifyArray(X, classifier)

#计算分类的错误率

e = ErrorSum(G)

a = 0.5 * math.log((1-e)/e)

a = round(a, 4)

print(a)

W2 = W1*np.exp(-a*Y*np.array(G))

Zm = np.sum(W2)

#Zm = round(Zm, 4)

print(Zm)

W1 = W2 / Zm

print(W1)

print('--------------------------------')

W1 = np.array([0.0455, 0.0455, 0.0455, 0.1667, 0.1667, 0.01667, 0.1060, 0.1060, 0.1060, 0.0455])

classifier = SelectClassifierFunction(X)

#计算分类的结果值

G = ClassifyArray(X, classifier)

#计算分类的错误率

e = ErrorSum(G)

a = 0.5 * math.log((1-e)/e)

a = round(a, 4)

print(a)

W2 = W1*np.exp(-a*Y*np.array(G))

Zm = np.sum(W2)

#Zm = round(Zm, 4)

print(Zm)

W1 = W2 / Zm

print(W1)

'''

errorAll = 100

ExpressArray = []

while errorAll > 0.1:

    print('--------------------------------')

    classifier = SelectClassifierFunction(X)

    #计算分类的结果值

    G = ClassifyArray(X, classifier)

    #计算分类的错误率

    e = ErrorSum(G)

    a = 0.5 * math.log((1-e)/e)

    a = round(a, 4)

    print('a:' + str(a))

    W2 = W1*np.exp(-a*Y*np.array(G))

    Zm = np.sum(W2)

    #Zm = round(Zm, 4)

    print(Zm)

    print('Zm:' + str(Zm))

    W1 = W2 / Zm

    print('W1:' + str(W1))

    ExpressArray.append([a,classifier])

    errorAll = ErrorAllSum(ExpressArray)

    print('errorAll:' + str(errorAll))

expressString = 'G(x) = sign( '

i = 0

for express in ExpressArray:

    if i > 0:

        expressString += ' + '

    expressString += str(express[0]) + ' * ' + express[1].__name__+'(x)'

    i += 1

expressString += ' )'

print('--------------------------------')

print('分类函数为：\n' + expressString)

print('--------------------------------')