from utils import * # noqa

import copy

import heapq

import math

import random

from collections import defaultdict

def rms_error(predictions, targets):

return math.sqrt(ms_error(predictions, targets))

def ms_error(predictions, targets):

return mean([(p - t)**2 for p, t in zip(predictions, targets)])

def mean_error(predictions, targets):

return mean([abs(p - t) for p, t in zip(predictions, targets)])

def mean_boolean_error(predictions, targets):

return mean([(p != t) for p, t in zip(predictions, targets)])

class DataSet:

self.name, len(self.examples), len(self.attrs))

def parse_csv(input, delim=','):

return [list(map(num_or_str, line.split(delim))) for line in lines]

class CountingProbDist:

return self.sampler()

def PluralityLearner(dataset):

return predict

def NaiveBayesLearner(dataset):

return predict

def NearestNeighborLearner(dataset, k=1):

return predict

class DecisionFork:

% (self.attr, self.attrname, self.branches))

class DecisionLeaf:

return repr(self.result)

def DecisionTreeLearner(dataset):

return decision_tree_learning(dataset.examples, dataset.inputs)

def information_content(values):

"Number of bits to represent the probability distribution in values."

probabilities = normalize(removeall(0, values))

return sum(-p * log2(p) for p in probabilities)

def DecisionListLearner(dataset):

return predict

def NeuralNetLearner(dataset, hidden_layer_sizes=[3],

return predict

class NNUnit:

self.activation = sigmoid

def network(input_units, hidden_layer_sizes, output_units):

return net

def BackPropagationLearner(dataset, net, learning_rate, epoches):

return net

def PerceptronLearner(dataset, learning_rate=0.01, epoches=100):

return predict

def Linearlearner(dataset, learning_rate=0.01, epochs=100):

return predict

def EnsembleLearner(learners):

return train

def AdaBoost(L, K):

return train

def WeightedMajority(predictors, weights):

return predict

def weighted_mode(values, weights):

return max(list(totals.keys()), key=totals.get)

def WeightedLearner(unweighted_learner):

return train

def replicated_dataset(dataset, weights, n=None):

return result

def weighted_replicate(seq, weights, n):

weighted_sample_with_replacement(seq, fractions, n - sum(wholes)))

def flatten(seqs): return sum(seqs, [])

def test(predict, dataset, examples=None, verbose=0):

return 1 - (right / len(examples))

def train_and_test(dataset, start, end):

return train, val

def cross_validation(learner, size, dataset, k=10, trials=1):

return fold_errT/k, fold_errV/k

def cross_validation_wrapper(learner, dataset, k=10, trials=1):

size += 1

def leave_one_out(learner, dataset):

"Leave one out cross-validation over the dataset."

return cross_validation(learner, size, dataset, k=len(dataset.examples))

def learningcurve(learner, dataset, trials=10, sizes=None):

for size in sizes]

orings = DataSet(name='orings', target='Distressed',

attrnames="Rings Distressed Temp Pressure Flightnum")

zoo = DataSet(name='zoo', target='type', exclude=['name'],

attrnames="name hair feathers eggs milk airborne aquatic " +

"predator toothed backbone breathes venomous fins legs tail " +

"domestic catsize type")

iris = DataSet(name="iris", target="class",

attrnames="sepal-len sepal-width petal-len petal-width class")

def RestaurantDataSet(examples=None):

'Raining Reservation Type WaitEstimate Wait')

restaurant = RestaurantDataSet()

def T(attrname, branches):

return DecisionFork(restaurant.attrnum(attrname), attrname, branches)

Fig[18, 2] = T('Patrons',

{'None': 'No', 'Some': 'Yes', 'Full':

T('WaitEstimate',

{'>60': 'No', '0-10': 'Yes',

'30-60':

T('Alternate', {'No':

T('Reservation', {'Yes': 'Yes', 'No':

T('Bar', {'No': 'No',

'Yes': 'Yes'

})}),

'Yes':

T('Fri/Sat', {'No': 'No', 'Yes': 'Yes'})}),

'10-30':

T('Hungry', {'No': 'Yes', 'Yes':

T('Alternate',

{'No': 'Yes', 'Yes':

T('Raining', {'No': 'No', 'Yes': 'Yes'})

})})})})

__doc__ += """

def SyntheticRestaurant(n=20):

return RestaurantDataSet([gen() for i in range(n)])

def Majority(k, n):

return DataSet(name="majority", examples=examples)

def Parity(k, n, name="parity"):

return DataSet(name=name, examples=examples)

def Xor(n):

"""Return a DataSet with n examples of 2-input xor."""

return Parity(2, n, name="xor")

def ContinuousXor(n):

return DataSet(name="continuous xor", examples=examples)

def compare(algorithms=[PluralityLearner, NaiveBayesLearner,

header=[''] + [d.name[0:7] for d in datasets], numfmt='%.2f')