diff --git a/learning4e.py b/learning4e.py index 68a2d5c48..6b1b7140d 100644 --- a/learning4e.py +++ b/learning4e.py @@ -1,6 +1,6 @@ from utils4e import ( removeall, unique, mode, argmax_random_tie, isclose, dotproduct, weighted_sample_with_replacement, - num_or_str, normalize, clip, print_table, open_data, probability, random_weights + num_or_str, normalize, clip, print_table, open_data, probability, random_weights, euclidean_distance ) import copy @@ -382,8 +382,8 @@ def cross_validation(learner, size, dataset, k=10, trials=1): examples = dataset.examples random.shuffle(dataset.examples) for fold in range(k): - train_data, val_data = train_test_split(dataset, fold * (n / k), - (fold + 1) * (n / k)) + train_data, val_data = train_test_split(dataset, fold * (n // k), + (fold + 1) * (n // k)) dataset.examples = train_data h = learner(dataset, size) fold_errs += err_ratio(h, dataset, train_data) @@ -393,6 +393,37 @@ def cross_validation(learner, size, dataset, k=10, trials=1): return fold_errs/k +def cross_validation_nosize(learner, dataset, k=10, trials=1): + """Do k-fold cross_validate and return their mean. + That is, keep out 1/k of the examples for testing on each of k runs. + Shuffle the examples first; if trials>1, average over several shuffles. + Returns Training error, Validataion error""" + k = k or len(dataset.examples) + if trials > 1: + trial_errs = 0 + for t in range(trials): + errs = cross_validation(learner, dataset, + k=10, trials=1) + trial_errs += errs + return trial_errs/trials + else: + fold_errs = 0 + n = len(dataset.examples) + examples = dataset.examples + random.shuffle(dataset.examples) + for fold in range(k): + train_data, val_data = train_test_split(dataset, fold * (n // k), + (fold + 1) * (n // k)) + dataset.examples = train_data + h = learner(dataset) + fold_errs += err_ratio(h, dataset, train_data) + + # Reverting back to original once test is completed + dataset.examples = examples + return fold_errs/k + + + def err_ratio(predict, dataset, examples=None, verbose=0): """Return the proportion of the examples that are NOT correctly predicted. verbose - 0: No output; 1: Output wrong; 2 (or greater): Output correct""" @@ -521,6 +552,8 @@ def LinearLearner(dataset, learning_rate=0.01, epochs=100): for example in examples: x = [1] + example y = dotproduct(w, x) + # if threshold: + # y = threshold(y) t = example[idx_t] err.append(t - y) @@ -554,17 +587,20 @@ def LogisticLinearLeaner(dataset, learning_rate=0.01, epochs=100): for epoch in range(epochs): err = [] + h= [] # Pass over all examples for example in examples: x = [1] + example y = 1/(1 + math.exp(-dotproduct(w, x))) - h = [y * (1-y)] + h.append(y * (1-y)) t = example[idx_t] err.append(t - y) # update weights for i in range(len(w)): - w[i] = w[i] + learning_rate * (dotproduct(dotproduct(err,h), X_col[i]) / num_examples) + buffer = [x*y for x,y in zip(err, h)] + # w[i] = w[i] + learning_rate * (dotproduct(err, X_col[i]) / num_examples) + w[i] = w[i] + learning_rate * (dotproduct(buffer, X_col[i]) / num_examples) def predict(example): x = [1] + example @@ -580,6 +616,7 @@ def NearestNeighborLearner(dataset, k=1): """k-NearestNeighbor: the k nearest neighbors vote.""" def predict(example): """Find the k closest items, and have them vote for the best.""" + example.pop(dataset.target) best = heapq.nsmallest(k, ((dataset.distance(e, example), e) for e in dataset.examples)) return mode(e[dataset.target] for (d, e) in best) @@ -829,6 +866,6 @@ def compare(algorithms=None, datasets=None, k=10, trials=1): Majority(7, 100), Parity(7, 100), Xor(100)] # of datasets print_table([[a.__name__.replace('Learner', '')] + - [cross_validation(a, d, k, trials) for d in datasets] + [cross_validation_nosize(a, d, k, trials) for d in datasets] for a in algorithms], - header=[''] + [d.name[0:7] for d in datasets], numfmt='%.2f') + header=[''] + [d.name[0:7] for d in datasets], numfmt='{0:.2f}') diff --git a/notebook4e.py b/notebook4e.py new file mode 100644 index 000000000..28f562e41 --- /dev/null +++ b/notebook4e.py @@ -0,0 +1,1151 @@ +from inspect import getsource + +from utils import argmax, argmin +from games import TicTacToe, alphabeta_player, random_player, Fig52Extended, infinity +from logic import parse_definite_clause, standardize_variables, unify, subst +from learning import DataSet +from IPython.display import HTML, display +from collections import Counter, defaultdict + +import matplotlib.pyplot as plt +from matplotlib.colors import ListedColormap +import numpy as np +from PIL import Image + +import os, struct +import array +import time + +# ______________________________________________________________________________ +# Magic Words + + +def pseudocode(algorithm): + """Print the pseudocode for the given algorithm.""" + from urllib.request import urlopen + from IPython.display import Markdown + + algorithm = algorithm.replace(' ', '-') + url = "https://raw.githubusercontent.com/aimacode/aima-pseudocode/master/md/{}.md".format(algorithm) + f = urlopen(url) + md = f.read().decode('utf-8') + md = md.split('\n', 1)[-1].strip() + md = '#' + md + return Markdown(md) + + +def psource(*functions): + """Print the source code for the given function(s).""" + source_code = '\n\n'.join(getsource(fn) for fn in functions) + try: + from pygments.formatters import HtmlFormatter + from pygments.lexers import PythonLexer + from pygments import highlight + + display(HTML(highlight(source_code, PythonLexer(), HtmlFormatter(full=True)))) + + except ImportError: + print(source_code) + + +def plot_model_boundary(dataset, attr1, attr2, model=None): + # prepare data + examples = np.asarray(dataset.examples) + X = np.asarray([examples[:, attr1], examples[:, attr2]]) + y = examples[:, dataset.target] + h = 0.1 + + # create color maps + cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#00AAFF']) + cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#00AAFF']) + + # calculate min, max and limits + x_min, x_max = X[0].min() - 1, X[0].max() + 1 + y_min, y_max = X[1].min() - 1, X[1].max() + 1 + # mesh the grid + xx, yy = np.meshgrid(np.arange(x_min, x_max, h), + np.arange(y_min, y_max, h)) + Z = [] + for grid in zip(xx.ravel(), yy.ravel()): + # put them back to the example + grid = np.round(grid, decimals=1).tolist() + Z.append(model(grid)) + # Put the result into a color plot + Z = np.asarray(Z) + Z = Z.reshape(xx.shape) + plt.figure() + plt.pcolormesh(xx, yy, Z, cmap=cmap_light) + + # Plot also the training points + plt.scatter(X[0], X[1], c=y, cmap=cmap_bold) + plt.xlim(xx.min(), xx.max()) + plt.ylim(yy.min(), yy.max()) + plt.show() + +# ______________________________________________________________________________ +# Iris Visualization + + +def show_iris(i=0, j=1, k=2): + """Plots the iris dataset in a 3D plot. + The three axes are given by i, j and k, + which correspond to three of the four iris features.""" + from mpl_toolkits.mplot3d import Axes3D + + plt.rcParams.update(plt.rcParamsDefault) + + fig = plt.figure() + ax = fig.add_subplot(111, projection='3d') + + iris = DataSet(name="iris") + buckets = iris.split_values_by_classes() + + features = ["Sepal Length", "Sepal Width", "Petal Length", "Petal Width"] + f1, f2, f3 = features[i], features[j], features[k] + + a_setosa = [v[i] for v in buckets["setosa"]] + b_setosa = [v[j] for v in buckets["setosa"]] + c_setosa = [v[k] for v in buckets["setosa"]] + + a_virginica = [v[i] for v in buckets["virginica"]] + b_virginica = [v[j] for v in buckets["virginica"]] + c_virginica = [v[k] for v in buckets["virginica"]] + + a_versicolor = [v[i] for v in buckets["versicolor"]] + b_versicolor = [v[j] for v in buckets["versicolor"]] + c_versicolor = [v[k] for v in buckets["versicolor"]] + + + for c, m, sl, sw, pl in [('b', 's', a_setosa, b_setosa, c_setosa), + ('g', '^', a_virginica, b_virginica, c_virginica), + ('r', 'o', a_versicolor, b_versicolor, c_versicolor)]: + ax.scatter(sl, sw, pl, c=c, marker=m) + + ax.set_xlabel(f1) + ax.set_ylabel(f2) + ax.set_zlabel(f3) + + plt.show() + + +# ______________________________________________________________________________ +# MNIST + + +def load_MNIST(path="aima-data/MNIST/Digits", fashion=False): + import os, struct + import array + import numpy as np + from collections import Counter + + if fashion: + path = "aima-data/MNIST/Fashion" + + plt.rcParams.update(plt.rcParamsDefault) + plt.rcParams['figure.figsize'] = (10.0, 8.0) + plt.rcParams['image.interpolation'] = 'nearest' + plt.rcParams['image.cmap'] = 'gray' + + train_img_file = open(os.path.join(path, "train-images-idx3-ubyte"), "rb") + train_lbl_file = open(os.path.join(path, "train-labels-idx1-ubyte"), "rb") + test_img_file = open(os.path.join(path, "t10k-images-idx3-ubyte"), "rb") + test_lbl_file = open(os.path.join(path, 't10k-labels-idx1-ubyte'), "rb") + + magic_nr, tr_size, tr_rows, tr_cols = struct.unpack(">IIII", train_img_file.read(16)) + tr_img = array.array("B", train_img_file.read()) + train_img_file.close() + magic_nr, tr_size = struct.unpack(">II", train_lbl_file.read(8)) + tr_lbl = array.array("b", train_lbl_file.read()) + train_lbl_file.close() + + magic_nr, te_size, te_rows, te_cols = struct.unpack(">IIII", test_img_file.read(16)) + te_img = array.array("B", test_img_file.read()) + test_img_file.close() + magic_nr, te_size = struct.unpack(">II", test_lbl_file.read(8)) + te_lbl = array.array("b", test_lbl_file.read()) + test_lbl_file.close() + + #print(len(tr_img), len(tr_lbl), tr_size) + #print(len(te_img), len(te_lbl), te_size) + + train_img = np.zeros((tr_size, tr_rows*tr_cols), dtype=np.int16) + train_lbl = np.zeros((tr_size,), dtype=np.int8) + for i in range(tr_size): + train_img[i] = np.array(tr_img[i*tr_rows*tr_cols : (i+1)*tr_rows*tr_cols]).reshape((tr_rows*te_cols)) + train_lbl[i] = tr_lbl[i] + + test_img = np.zeros((te_size, te_rows*te_cols), dtype=np.int16) + test_lbl = np.zeros((te_size,), dtype=np.int8) + for i in range(te_size): + test_img[i] = np.array(te_img[i*te_rows*te_cols : (i+1)*te_rows*te_cols]).reshape((te_rows*te_cols)) + test_lbl[i] = te_lbl[i] + + return(train_img, train_lbl, test_img, test_lbl) + + +digit_classes = [str(i) for i in range(10)] +fashion_classes = ["T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", + "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"] + + +def show_MNIST(labels, images, samples=8, fashion=False): + if not fashion: + classes = digit_classes + else: + classes = fashion_classes + + num_classes = len(classes) + + for y, cls in enumerate(classes): + idxs = np.nonzero([i == y for i in labels]) + idxs = np.random.choice(idxs[0], samples, replace=False) + for i , idx in enumerate(idxs): + plt_idx = i * num_classes + y + 1 + plt.subplot(samples, num_classes, plt_idx) + plt.imshow(images[idx].reshape((28, 28))) + plt.axis("off") + if i == 0: + plt.title(cls) + + plt.show() + + +def show_ave_MNIST(labels, images, fashion=False): + if not fashion: + item_type = "Digit" + classes = digit_classes + else: + item_type = "Apparel" + classes = fashion_classes + + num_classes = len(classes) + + for y, cls in enumerate(classes): + idxs = np.nonzero([i == y for i in labels]) + print(item_type, y, ":", len(idxs[0]), "images.") + + ave_img = np.mean(np.vstack([images[i] for i in idxs[0]]), axis = 0) + #print(ave_img.shape) + + plt.subplot(1, num_classes, y+1) + plt.imshow(ave_img.reshape((28, 28))) + plt.axis("off") + plt.title(cls) + + plt.show() + +# ______________________________________________________________________________ +# MDP + + +def make_plot_grid_step_function(columns, rows, U_over_time): + """ipywidgets interactive function supports single parameter as input. + This function creates and return such a function by taking as input + other parameters.""" + + def plot_grid_step(iteration): + data = U_over_time[iteration] + data = defaultdict(lambda: 0, data) + grid = [] + for row in range(rows): + current_row = [] + for column in range(columns): + current_row.append(data[(column, row)]) + grid.append(current_row) + grid.reverse() # output like book + fig = plt.imshow(grid, cmap=plt.cm.bwr, interpolation='nearest') + + plt.axis('off') + fig.axes.get_xaxis().set_visible(False) + fig.axes.get_yaxis().set_visible(False) + + for col in range(len(grid)): + for row in range(len(grid[0])): + magic = grid[col][row] + fig.axes.text(row, col, "{0:.2f}".format(magic), va='center', ha='center') + + plt.show() + + return plot_grid_step + +def make_visualize(slider): + """Takes an input a sliderand returns callback function + for timer and animation.""" + + def visualize_callback(Visualize, time_step): + if Visualize is True: + for i in range(slider.min, slider.max + 1): + slider.value = i + time.sleep(float(time_step)) + + return visualize_callback + +# ______________________________________________________________________________ + + +_canvas = """ + +
+ +
+ + +""" # noqa + + +class Canvas: + """Inherit from this class to manage the HTML canvas element in jupyter notebooks. + To create an object of this class any_name_xyz = Canvas("any_name_xyz") + The first argument given must be the name of the object being created. + IPython must be able to reference the variable name that is being passed.""" + + def __init__(self, varname, width=800, height=600, cid=None): + self.name = varname + self.cid = cid or varname + self.width = width + self.height = height + self.html = _canvas.format(self.cid, self.width, self.height, self.name) + self.exec_list = [] + display_html(self.html) + + def mouse_click(self, x, y): + """Override this method to handle mouse click at position (x, y)""" + raise NotImplementedError + + def mouse_move(self, x, y): + raise NotImplementedError + + def execute(self, exec_str): + """Stores the command to be executed to a list which is used later during update()""" + if not isinstance(exec_str, str): + print("Invalid execution argument:", exec_str) + self.alert("Received invalid execution command format") + prefix = "{0}_canvas_object.".format(self.cid) + self.exec_list.append(prefix + exec_str + ';') + + def fill(self, r, g, b): + """Changes the fill color to a color in rgb format""" + self.execute("fill({0}, {1}, {2})".format(r, g, b)) + + def stroke(self, r, g, b): + """Changes the colors of line/strokes to rgb""" + self.execute("stroke({0}, {1}, {2})".format(r, g, b)) + + def strokeWidth(self, w): + """Changes the width of lines/strokes to 'w' pixels""" + self.execute("strokeWidth({0})".format(w)) + + def rect(self, x, y, w, h): + """Draw a rectangle with 'w' width, 'h' height and (x, y) as the top-left corner""" + self.execute("rect({0}, {1}, {2}, {3})".format(x, y, w, h)) + + def rect_n(self, xn, yn, wn, hn): + """Similar to rect(), but the dimensions are normalized to fall between 0 and 1""" + x = round(xn * self.width) + y = round(yn * self.height) + w = round(wn * self.width) + h = round(hn * self.height) + self.rect(x, y, w, h) + + def line(self, x1, y1, x2, y2): + """Draw a line from (x1, y1) to (x2, y2)""" + self.execute("line({0}, {1}, {2}, {3})".format(x1, y1, x2, y2)) + + def line_n(self, x1n, y1n, x2n, y2n): + """Similar to line(), but the dimensions are normalized to fall between 0 and 1""" + x1 = round(x1n * self.width) + y1 = round(y1n * self.height) + x2 = round(x2n * self.width) + y2 = round(y2n * self.height) + self.line(x1, y1, x2, y2) + + def arc(self, x, y, r, start, stop): + """Draw an arc with (x, y) as centre, 'r' as radius from angles 'start' to 'stop'""" + self.execute("arc({0}, {1}, {2}, {3}, {4})".format(x, y, r, start, stop)) + + def arc_n(self, xn, yn, rn, start, stop): + """Similar to arc(), but the dimensions are normalized to fall between 0 and 1 + The normalizing factor for radius is selected between width and height by + seeing which is smaller.""" + x = round(xn * self.width) + y = round(yn * self.height) + r = round(rn * min(self.width, self.height)) + self.arc(x, y, r, start, stop) + + def clear(self): + """Clear the HTML canvas""" + self.execute("clear()") + + def font(self, font): + """Changes the font of text""" + self.execute('font("{0}")'.format(font)) + + def text(self, txt, x, y, fill=True): + """Display a text at (x, y)""" + if fill: + self.execute('fill_text("{0}", {1}, {2})'.format(txt, x, y)) + else: + self.execute('stroke_text("{0}", {1}, {2})'.format(txt, x, y)) + + def text_n(self, txt, xn, yn, fill=True): + """Similar to text(), but with normalized coordinates""" + x = round(xn * self.width) + y = round(yn * self.height) + self.text(txt, x, y, fill) + + def alert(self, message): + """Immediately display an alert""" + display_html(''.format(message)) + + def update(self): + """Execute the JS code to execute the commands queued by execute()""" + exec_code = "" + self.exec_list = [] + display_html(exec_code) + + +def display_html(html_string): + display(HTML(html_string)) + + +################################################################################ + + +class Canvas_TicTacToe(Canvas): + """Play a 3x3 TicTacToe game on HTML canvas""" + def __init__(self, varname, player_1='human', player_2='random', + width=300, height=350, cid=None): + valid_players = ('human', 'random', 'alphabeta') + if player_1 not in valid_players or player_2 not in valid_players: + raise TypeError("Players must be one of {}".format(valid_players)) + Canvas.__init__(self, varname, width, height, cid) + self.ttt = TicTacToe() + self.state = self.ttt.initial + self.turn = 0 + self.strokeWidth(5) + self.players = (player_1, player_2) + self.font("20px Arial") + self.draw_board() + + def mouse_click(self, x, y): + player = self.players[self.turn] + if self.ttt.terminal_test(self.state): + if 0.55 <= x/self.width <= 0.95 and 6/7 <= y/self.height <= 6/7+1/8: + self.state = self.ttt.initial + self.turn = 0 + self.draw_board() + return + + if player == 'human': + x, y = int(3*x/self.width) + 1, int(3*y/(self.height*6/7)) + 1 + if (x, y) not in self.ttt.actions(self.state): + # Invalid move + return + move = (x, y) + elif player == 'alphabeta': + move = alphabeta_player(self.ttt, self.state) + else: + move = random_player(self.ttt, self.state) + self.state = self.ttt.result(self.state, move) + self.turn ^= 1 + self.draw_board() + + def draw_board(self): + self.clear() + self.stroke(0, 0, 0) + offset = 1/20 + self.line_n(0 + offset, (1/3)*6/7, 1 - offset, (1/3)*6/7) + self.line_n(0 + offset, (2/3)*6/7, 1 - offset, (2/3)*6/7) + self.line_n(1/3, (0 + offset)*6/7, 1/3, (1 - offset)*6/7) + self.line_n(2/3, (0 + offset)*6/7, 2/3, (1 - offset)*6/7) + + board = self.state.board + for mark in board: + if board[mark] == 'X': + self.draw_x(mark) + elif board[mark] == 'O': + self.draw_o(mark) + if self.ttt.terminal_test(self.state): + # End game message + utility = self.ttt.utility(self.state, self.ttt.to_move(self.ttt.initial)) + if utility == 0: + self.text_n('Game Draw!', offset, 6/7 + offset) + else: + self.text_n('Player {} wins!'.format("XO"[utility < 0]), offset, 6/7 + offset) + # Find the 3 and draw a line + self.stroke([255, 0][self.turn], [0, 255][self.turn], 0) + for i in range(3): + if all([(i + 1, j + 1) in self.state.board for j in range(3)]) and \ + len({self.state.board[(i + 1, j + 1)] for j in range(3)}) == 1: + self.line_n(i/3 + 1/6, offset*6/7, i/3 + 1/6, (1 - offset)*6/7) + if all([(j + 1, i + 1) in self.state.board for j in range(3)]) and \ + len({self.state.board[(j + 1, i + 1)] for j in range(3)}) == 1: + self.line_n(offset, (i/3 + 1/6)*6/7, 1 - offset, (i/3 + 1/6)*6/7) + if all([(i + 1, i + 1) in self.state.board for i in range(3)]) and \ + len({self.state.board[(i + 1, i + 1)] for i in range(3)}) == 1: + self.line_n(offset, offset*6/7, 1 - offset, (1 - offset)*6/7) + if all([(i + 1, 3 - i) in self.state.board for i in range(3)]) and \ + len({self.state.board[(i + 1, 3 - i)] for i in range(3)}) == 1: + self.line_n(offset, (1 - offset)*6/7, 1 - offset, offset*6/7) + # restart button + self.fill(0, 0, 255) + self.rect_n(0.5 + offset, 6/7, 0.4, 1/8) + self.fill(0, 0, 0) + self.text_n('Restart', 0.5 + 2*offset, 13/14) + else: # Print which player's turn it is + self.text_n("Player {}'s move({})".format("XO"[self.turn], self.players[self.turn]), + offset, 6/7 + offset) + + self.update() + + def draw_x(self, position): + self.stroke(0, 255, 0) + x, y = [i-1 for i in position] + offset = 1/15 + self.line_n(x/3 + offset, (y/3 + offset)*6/7, x/3 + 1/3 - offset, (y/3 + 1/3 - offset)*6/7) + self.line_n(x/3 + 1/3 - offset, (y/3 + offset)*6/7, x/3 + offset, (y/3 + 1/3 - offset)*6/7) + + def draw_o(self, position): + self.stroke(255, 0, 0) + x, y = [i-1 for i in position] + self.arc_n(x/3 + 1/6, (y/3 + 1/6)*6/7, 1/9, 0, 360) + + +class Canvas_minimax(Canvas): + """Minimax for Fig52Extended on HTML canvas""" + def __init__(self, varname, util_list, width=800, height=600, cid=None): + Canvas.__init__(self, varname, width, height, cid) + self.utils = {node:util for node, util in zip(range(13, 40), util_list)} + self.game = Fig52Extended() + self.game.utils = self.utils + self.nodes = list(range(40)) + self.l = 1/40 + self.node_pos = {} + for i in range(4): + base = len(self.node_pos) + row_size = 3**i + for node in [base + j for j in range(row_size)]: + self.node_pos[node] = ((node - base)/row_size + 1/(2*row_size) - self.l/2, + self.l/2 + (self.l + (1 - 5*self.l)/3)*i) + self.font("12px Arial") + self.node_stack = [] + self.explored = {node for node in self.utils} + self.thick_lines = set() + self.change_list = [] + self.draw_graph() + self.stack_manager = self.stack_manager_gen() + + def minimax(self, node): + game = self.game + player = game.to_move(node) + def max_value(node): + if game.terminal_test(node): + return game.utility(node, player) + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + max_a = argmax(game.actions(node), key=lambda x: min_value(game.result(node, x))) + max_node = game.result(node, max_a) + self.utils[node] = self.utils[max_node] + x1, y1 = self.node_pos[node] + x2, y2 = self.node_pos[max_node] + self.change_list.append(('l', (node, max_node - 3*node - 1))) + self.change_list.append(('e', node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return self.utils[node] + + def min_value(node): + if game.terminal_test(node): + return game.utility(node, player) + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + min_a = argmin(game.actions(node), key=lambda x: max_value(game.result(node, x))) + min_node = game.result(node, min_a) + self.utils[node] = self.utils[min_node] + x1, y1 = self.node_pos[node] + x2, y2 = self.node_pos[min_node] + self.change_list.append(('l', (node, min_node - 3*node - 1))) + self.change_list.append(('e', node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return self.utils[node] + + return max_value(node) + + def stack_manager_gen(self): + self.minimax(0) + for change in self.change_list: + if change[0] == 'a': + self.node_stack.append(change[1]) + elif change[0] == 'e': + self.explored.add(change[1]) + elif change[0] == 'h': + yield + elif change[0] == 'l': + self.thick_lines.add(change[1]) + elif change[0] == 'p': + self.node_stack.pop() + + def mouse_click(self, x, y): + try: + self.stack_manager.send(None) + except StopIteration: + pass + self.draw_graph() + + def draw_graph(self): + self.clear() + # draw nodes + self.stroke(0, 0, 0) + self.strokeWidth(1) + # highlight for nodes in stack + for node in self.node_stack: + x, y = self.node_pos[node] + self.fill(200, 200, 0) + self.rect_n(x - self.l/5, y - self.l/5, self.l*7/5, self.l*7/5) + for node in self.nodes: + x, y = self.node_pos[node] + if node in self.explored: + self.fill(255, 255, 255) + else: + self.fill(200, 200, 200) + self.rect_n(x, y, self.l, self.l) + self.line_n(x, y, x + self.l, y) + self.line_n(x, y, x, y + self.l) + self.line_n(x + self.l, y + self.l, x + self.l, y) + self.line_n(x + self.l, y + self.l, x, y + self.l) + self.fill(0, 0, 0) + if node in self.explored: + self.text_n(self.utils[node], x + self.l/10, y + self.l*9/10) + # draw edges + for i in range(13): + x1, y1 = self.node_pos[i][0] + self.l/2, self.node_pos[i][1] + self.l + for j in range(3): + x2, y2 = self.node_pos[i*3 + j + 1][0] + self.l/2, self.node_pos[i*3 + j + 1][1] + if i in [1, 2, 3]: + self.stroke(200, 0, 0) + else: + self.stroke(0, 200, 0) + if (i, j) in self.thick_lines: + self.strokeWidth(3) + else: + self.strokeWidth(1) + self.line_n(x1, y1, x2, y2) + self.update() + + +class Canvas_alphabeta(Canvas): + """Alpha-beta pruning for Fig52Extended on HTML canvas""" + def __init__(self, varname, util_list, width=800, height=600, cid=None): + Canvas.__init__(self, varname, width, height, cid) + self.utils = {node:util for node, util in zip(range(13, 40), util_list)} + self.game = Fig52Extended() + self.game.utils = self.utils + self.nodes = list(range(40)) + self.l = 1/40 + self.node_pos = {} + for i in range(4): + base = len(self.node_pos) + row_size = 3**i + for node in [base + j for j in range(row_size)]: + self.node_pos[node] = ((node - base)/row_size + 1/(2*row_size) - self.l/2, + 3*self.l/2 + (self.l + (1 - 6*self.l)/3)*i) + self.font("12px Arial") + self.node_stack = [] + self.explored = {node for node in self.utils} + self.pruned = set() + self.ab = {} + self.thick_lines = set() + self.change_list = [] + self.draw_graph() + self.stack_manager = self.stack_manager_gen() + + def alphabeta_search(self, node): + game = self.game + player = game.to_move(node) + + # Functions used by alphabeta + def max_value(node, alpha, beta): + if game.terminal_test(node): + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + self.change_list.append(('p',)) + return game.utility(node, player) + v = -infinity + self.change_list.append(('a', node)) + self.change_list.append(('ab',node, v, beta)) + self.change_list.append(('h',)) + for a in game.actions(node): + min_val = min_value(game.result(node, a), alpha, beta) + if v < min_val: + v = min_val + max_node = game.result(node, a) + self.change_list.append(('ab',node, v, beta)) + if v >= beta: + self.change_list.append(('h',)) + self.pruned.add(node) + break + alpha = max(alpha, v) + self.utils[node] = v + if node not in self.pruned: + self.change_list.append(('l', (node, max_node - 3*node - 1))) + self.change_list.append(('e',node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return v + + def min_value(node, alpha, beta): + if game.terminal_test(node): + self.change_list.append(('a', node)) + self.change_list.append(('h',)) + self.change_list.append(('p',)) + return game.utility(node, player) + v = infinity + self.change_list.append(('a', node)) + self.change_list.append(('ab',node, alpha, v)) + self.change_list.append(('h',)) + for a in game.actions(node): + max_val = max_value(game.result(node, a), alpha, beta) + if v > max_val: + v = max_val + min_node = game.result(node, a) + self.change_list.append(('ab',node, alpha, v)) + if v <= alpha: + self.change_list.append(('h',)) + self.pruned.add(node) + break + beta = min(beta, v) + self.utils[node] = v + if node not in self.pruned: + self.change_list.append(('l', (node, min_node - 3*node - 1))) + self.change_list.append(('e',node)) + self.change_list.append(('p',)) + self.change_list.append(('h',)) + return v + + return max_value(node, -infinity, infinity) + + def stack_manager_gen(self): + self.alphabeta_search(0) + for change in self.change_list: + if change[0] == 'a': + self.node_stack.append(change[1]) + elif change[0] == 'ab': + self.ab[change[1]] = change[2:] + elif change[0] == 'e': + self.explored.add(change[1]) + elif change[0] == 'h': + yield + elif change[0] == 'l': + self.thick_lines.add(change[1]) + elif change[0] == 'p': + self.node_stack.pop() + + def mouse_click(self, x, y): + try: + self.stack_manager.send(None) + except StopIteration: + pass + self.draw_graph() + + def draw_graph(self): + self.clear() + # draw nodes + self.stroke(0, 0, 0) + self.strokeWidth(1) + # highlight for nodes in stack + for node in self.node_stack: + x, y = self.node_pos[node] + # alpha > beta + if node not in self.explored and self.ab[node][0] > self.ab[node][1]: + self.fill(200, 100, 100) + else: + self.fill(200, 200, 0) + self.rect_n(x - self.l/5, y - self.l/5, self.l*7/5, self.l*7/5) + for node in self.nodes: + x, y = self.node_pos[node] + if node in self.explored: + if node in self.pruned: + self.fill(50, 50, 50) + else: + self.fill(255, 255, 255) + else: + self.fill(200, 200, 200) + self.rect_n(x, y, self.l, self.l) + self.line_n(x, y, x + self.l, y) + self.line_n(x, y, x, y + self.l) + self.line_n(x + self.l, y + self.l, x + self.l, y) + self.line_n(x + self.l, y + self.l, x, y + self.l) + self.fill(0, 0, 0) + if node in self.explored and node not in self.pruned: + self.text_n(self.utils[node], x + self.l/10, y + self.l*9/10) + # draw edges + for i in range(13): + x1, y1 = self.node_pos[i][0] + self.l/2, self.node_pos[i][1] + self.l + for j in range(3): + x2, y2 = self.node_pos[i*3 + j + 1][0] + self.l/2, self.node_pos[i*3 + j + 1][1] + if i in [1, 2, 3]: + self.stroke(200, 0, 0) + else: + self.stroke(0, 200, 0) + if (i, j) in self.thick_lines: + self.strokeWidth(3) + else: + self.strokeWidth(1) + self.line_n(x1, y1, x2, y2) + # display alpha and beta + for node in self.node_stack: + if node not in self.explored: + x, y = self.node_pos[node] + alpha, beta = self.ab[node] + self.text_n(alpha, x - self.l/2, y - self.l/10) + self.text_n(beta, x + self.l, y - self.l/10) + self.update() + + +class Canvas_fol_bc_ask(Canvas): + """fol_bc_ask() on HTML canvas""" + def __init__(self, varname, kb, query, width=800, height=600, cid=None): + Canvas.__init__(self, varname, width, height, cid) + self.kb = kb + self.query = query + self.l = 1/20 + self.b = 3*self.l + bc_out = list(self.fol_bc_ask()) + if len(bc_out) is 0: + self.valid = False + else: + self.valid = True + graph = bc_out[0][0][0] + s = bc_out[0][1] + while True: + new_graph = subst(s, graph) + if graph == new_graph: + break + graph = new_graph + self.make_table(graph) + self.context = None + self.draw_table() + + def fol_bc_ask(self): + KB = self.kb + query = self.query + def fol_bc_or(KB, goal, theta): + for rule in KB.fetch_rules_for_goal(goal): + lhs, rhs = parse_definite_clause(standardize_variables(rule)) + for theta1 in fol_bc_and(KB, lhs, unify(rhs, goal, theta)): + yield ([(goal, theta1[0])], theta1[1]) + + def fol_bc_and(KB, goals, theta): + if theta is None: + pass + elif not goals: + yield ([], theta) + else: + first, rest = goals[0], goals[1:] + for theta1 in fol_bc_or(KB, subst(theta, first), theta): + for theta2 in fol_bc_and(KB, rest, theta1[1]): + yield (theta1[0] + theta2[0], theta2[1]) + + return fol_bc_or(KB, query, {}) + + def make_table(self, graph): + table = [] + pos = {} + links = set() + edges = set() + + def dfs(node, depth): + if len(table) <= depth: + table.append([]) + pos = len(table[depth]) + table[depth].append(node[0]) + for child in node[1]: + child_id = dfs(child, depth + 1) + links.add(((depth, pos), child_id)) + return (depth, pos) + + dfs(graph, 0) + y_off = 0.85/len(table) + for i, row in enumerate(table): + x_off = 0.95/len(row) + for j, node in enumerate(row): + pos[(i, j)] = (0.025 + j*x_off + (x_off - self.b)/2, 0.025 + i*y_off + (y_off - self.l)/2) + for p, c in links: + x1, y1 = pos[p] + x2, y2 = pos[c] + edges.add((x1 + self.b/2, y1 + self.l, x2 + self.b/2, y2)) + + self.table = table + self.pos = pos + self.edges = edges + + def mouse_click(self, x, y): + x, y = x/self.width, y/self.height + for node in self.pos: + xs, ys = self.pos[node] + xe, ye = xs + self.b, ys + self.l + if xs <= x <= xe and ys <= y <= ye: + self.context = node + break + self.draw_table() + + def draw_table(self): + self.clear() + self.strokeWidth(3) + self.stroke(0, 0, 0) + self.font("12px Arial") + if self.valid: + # draw nodes + for i, j in self.pos: + x, y = self.pos[(i, j)] + self.fill(200, 200, 200) + self.rect_n(x, y, self.b, self.l) + self.line_n(x, y, x + self.b, y) + self.line_n(x, y, x, y + self.l) + self.line_n(x + self.b, y, x + self.b, y + self.l) + self.line_n(x, y + self.l, x + self.b, y + self.l) + self.fill(0, 0, 0) + self.text_n(self.table[i][j], x + 0.01, y + self.l - 0.01) + #draw edges + for x1, y1, x2, y2 in self.edges: + self.line_n(x1, y1, x2, y2) + else: + self.fill(255, 0, 0) + self.rect_n(0, 0, 1, 1) + # text area + self.fill(255, 255, 255) + self.rect_n(0, 0.9, 1, 0.1) + self.strokeWidth(5) + self.stroke(0, 0, 0) + self.line_n(0, 0.9, 1, 0.9) + self.font("22px Arial") + self.fill(0, 0, 0) + self.text_n(self.table[self.context[0]][self.context[1]] if self.context else "Click for text", 0.025, 0.975) + self.update() + + +############################################################################################################ + +##################### Functions to assist plotting in search.ipynb #################### + +############################################################################################################ +import networkx as nx +import matplotlib.pyplot as plt +from matplotlib import lines + +from ipywidgets import interact +import ipywidgets as widgets +from IPython.display import display +import time +from search import GraphProblem, romania_map + +def show_map(graph_data, node_colors = None): + G = nx.Graph(graph_data['graph_dict']) + node_colors = node_colors or graph_data['node_colors'] + node_positions = graph_data['node_positions'] + node_label_pos = graph_data['node_label_positions'] + edge_weights= graph_data['edge_weights'] + + # set the size of the plot + plt.figure(figsize=(18,13)) + # draw the graph (both nodes and edges) with locations from romania_locations + nx.draw(G, pos={k: node_positions[k] for k in G.nodes()}, + node_color=[node_colors[node] for node in G.nodes()], linewidths=0.3, edgecolors='k') + + # draw labels for nodes + node_label_handles = nx.draw_networkx_labels(G, pos=node_label_pos, font_size=14) + + # add a white bounding box behind the node labels + [label.set_bbox(dict(facecolor='white', edgecolor='none')) for label in node_label_handles.values()] + + # add edge lables to the graph + nx.draw_networkx_edge_labels(G, pos=node_positions, edge_labels=edge_weights, font_size=14) + + # add a legend + white_circle = lines.Line2D([], [], color="white", marker='o', markersize=15, markerfacecolor="white") + orange_circle = lines.Line2D([], [], color="orange", marker='o', markersize=15, markerfacecolor="orange") + red_circle = lines.Line2D([], [], color="red", marker='o', markersize=15, markerfacecolor="red") + gray_circle = lines.Line2D([], [], color="gray", marker='o', markersize=15, markerfacecolor="gray") + green_circle = lines.Line2D([], [], color="green", marker='o', markersize=15, markerfacecolor="green") + plt.legend((white_circle, orange_circle, red_circle, gray_circle, green_circle), + ('Un-explored', 'Frontier', 'Currently Exploring', 'Explored', 'Final Solution'), + numpoints=1, prop={'size':16}, loc=(.8,.75)) + + # show the plot. No need to use in notebooks. nx.draw will show the graph itself. + plt.show() + +## helper functions for visualisations + +def final_path_colors(initial_node_colors, problem, solution): + "Return a node_colors dict of the final path provided the problem and solution." + + # get initial node colors + final_colors = dict(initial_node_colors) + # color all the nodes in solution and starting node to green + final_colors[problem.initial] = "green" + for node in solution: + final_colors[node] = "green" + return final_colors + +def display_visual(graph_data, user_input, algorithm=None, problem=None): + initial_node_colors = graph_data['node_colors'] + if user_input == False: + def slider_callback(iteration): + # don't show graph for the first time running the cell calling this function + try: + show_map(graph_data, node_colors=all_node_colors[iteration]) + except: + pass + def visualize_callback(Visualize): + if Visualize is True: + button.value = False + + global all_node_colors + + iterations, all_node_colors, node = algorithm(problem) + solution = node.solution() + all_node_colors.append(final_path_colors(all_node_colors[0], problem, solution)) + + slider.max = len(all_node_colors) - 1 + + for i in range(slider.max + 1): + slider.value = i + #time.sleep(.5) + + slider = widgets.IntSlider(min=0, max=1, step=1, value=0) + slider_visual = widgets.interactive(slider_callback, iteration=slider) + display(slider_visual) + + button = widgets.ToggleButton(value=False) + button_visual = widgets.interactive(visualize_callback, Visualize=button) + display(button_visual) + + if user_input == True: + node_colors = dict(initial_node_colors) + if isinstance(algorithm, dict): + assert set(algorithm.keys()).issubset({"Breadth First Tree Search", + "Depth First Tree Search", + "Breadth First Search", + "Depth First Graph Search", + "Best First Graph Search", + "Uniform Cost Search", + "Depth Limited Search", + "Iterative Deepening Search", + "Greedy Best First Search", + "A-star Search", + "Recursive Best First Search"}) + + algo_dropdown = widgets.Dropdown(description="Search algorithm: ", + options=sorted(list(algorithm.keys())), + value="Breadth First Tree Search") + display(algo_dropdown) + elif algorithm is None: + print("No algorithm to run.") + return 0 + + def slider_callback(iteration): + # don't show graph for the first time running the cell calling this function + try: + show_map(graph_data, node_colors=all_node_colors[iteration]) + except: + pass + + def visualize_callback(Visualize): + if Visualize is True: + button.value = False + + problem = GraphProblem(start_dropdown.value, end_dropdown.value, romania_map) + global all_node_colors + + user_algorithm = algorithm[algo_dropdown.value] + + iterations, all_node_colors, node = user_algorithm(problem) + solution = node.solution() + all_node_colors.append(final_path_colors(all_node_colors[0], problem, solution)) + + slider.max = len(all_node_colors) - 1 + + for i in range(slider.max + 1): + slider.value = i + #time.sleep(.5) + + start_dropdown = widgets.Dropdown(description="Start city: ", + options=sorted(list(node_colors.keys())), value="Arad") + display(start_dropdown) + + end_dropdown = widgets.Dropdown(description="Goal city: ", + options=sorted(list(node_colors.keys())), value="Fagaras") + display(end_dropdown) + + button = widgets.ToggleButton(value=False) + button_visual = widgets.interactive(visualize_callback, Visualize=button) + display(button_visual) + + slider = widgets.IntSlider(min=0, max=1, step=1, value=0) + slider_visual = widgets.interactive(slider_callback, iteration=slider) + display(slider_visual) + + +# Function to plot NQueensCSP in csp.py and NQueensProblem in search.py +def plot_NQueens(solution): + n = len(solution) + board = np.array([2 * int((i + j) % 2) for j in range(n) for i in range(n)]).reshape((n, n)) + im = Image.open('images/queen_s.png') + height = im.size[1] + im = np.array(im).astype(np.float) / 255 + fig = plt.figure(figsize=(7, 7)) + ax = fig.add_subplot(111) + ax.set_title('{} Queens'.format(n)) + plt.imshow(board, cmap='binary', interpolation='nearest') + # NQueensCSP gives a solution as a dictionary + if isinstance(solution, dict): + for (k, v) in solution.items(): + newax = fig.add_axes([0.064 + (k * 0.112), 0.062 + ((7 - v) * 0.112), 0.1, 0.1], zorder=1) + newax.imshow(im) + newax.axis('off') + # NQueensProblem gives a solution as a list + elif isinstance(solution, list): + for (k, v) in enumerate(solution): + newax = fig.add_axes([0.064 + (k * 0.112), 0.062 + ((7 - v) * 0.112), 0.1, 0.1], zorder=1) + newax.imshow(im) + newax.axis('off') + fig.tight_layout() + plt.show() + +# Function to plot a heatmap, given a grid +def heatmap(grid, cmap='binary', interpolation='nearest'): + fig = plt.figure(figsize=(7, 7)) + ax = fig.add_subplot(111) + ax.set_title('Heatmap') + plt.imshow(grid, cmap=cmap, interpolation=interpolation) + fig.tight_layout() + plt.show() + +# Generates a gaussian kernel +def gaussian_kernel(l=5, sig=1.0): + ax = np.arange(-l // 2 + 1., l // 2 + 1.) + xx, yy = np.meshgrid(ax, ax) + kernel = np.exp(-(xx**2 + yy**2) / (2. * sig**2)) + return kernel + +# Plots utility function for a POMDP +def plot_pomdp_utility(utility): + save = utility['0'][0] + delete = utility['1'][0] + ask_save = utility['2'][0] + ask_delete = utility['2'][-1] + left = (save[0] - ask_save[0]) / (save[0] - ask_save[0] + ask_save[1] - save[1]) + right = (delete[0] - ask_delete[0]) / (delete[0] - ask_delete[0] + ask_delete[1] - delete[1]) + + colors = ['g', 'b', 'k'] + for action in utility: + for value in utility[action]: + plt.plot(value, color=colors[int(action)]) + plt.vlines([left, right], -20, 10, linestyles='dashed', colors='c') + plt.ylim(-20, 13) + plt.xlim(0, 1) + plt.text(left/2 - 0.05, 10, 'Save') + plt.text((right + left)/2 - 0.02, 10, 'Ask') + plt.text((right + 1)/2 - 0.07, 10, 'Delete') + plt.show() diff --git a/notebooks/chapter18/Datasets.ipynb b/notebooks/chapter18/Datasets.ipynb new file mode 100644 index 000000000..9a48debcd --- /dev/null +++ b/notebooks/chapter18/Datasets.ipynb @@ -0,0 +1,646 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DATASETS" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following tutorial is a demonstration of the `DataSet` data structure which is frequently used in the following sections. `DataSet` plays the role of organizing data in different forms to make them able to be used by machine learning algorithms. Here we make the following datasets as examples:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Fisher's Iris: Each item represents a flower, with four measurements: the length and the width of the sepals and petals. Each item/flower is categorized into one of three species: Setosa, Versicolor and Virginica.\n", + "\n", + "- Zoo: The dataset holds different animals and their classification as \"mammal\", \"fish\", etc. The new animal we want to classify has the following measurements: 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1 (don't concern yourself with what the measurements mean).\n", + "\n", + "- Restaurant: The restaurant example in Fig XX of the book. Each item in the dataset represents a condition of customers to make decisions. The target class of each item can be \"yes\" or \"no\", meaning whether to dine in this restaurant.\n", + "\n", + "- Orings: The dataset holds different conditions of the night before each launch of the space shuttle. It is to predict the number of O-rings that will experience thermal distress for a given flight when the launch temperature is below freezing. The target class can be 0,1 or 2 meaning the number of oring failures." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make use the datasets easier, we have written a class, DataSet, in learning.py. The tutorials found here make use of this class. Now let's have a look at how it works." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intro" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A lot of the datasets we will work with are .csv files (although other formats are supported too). We have a collection of sample datasets ready to use on [aima-data](https://github.com/aimacode/aima-data/tree/a21fc108f52ad551344e947b0eb97df82f8d2b2b). Four examples are the datasets mentioned above (iris.csv, zoo.csv, orings.csv, and restaurant.csv). You can find plenty of datasets online, and a good repository of such datasets is [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets.php)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In such files, each line corresponds to one item/measurement. Each individual value in a line represents a feature and usually there is a value denoting the class of the item." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can find the code for the dataset in `learning4e.py` or use the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%psource DataSet" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing a Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are multiple ways to import a dataset from the `learning4e` module. But first the necessary modules need to be imported:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Importing from aima-data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dataset uploaded to aima-data can be imported as the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "iris = DataSet(name=\"iris\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check that we imported the correct dataset, we can do the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5.1, 3.5, 1.4, 0.2, 'setosa']\n", + "[0, 1, 2, 3]\n" + ] + } + ], + "source": [ + "print(iris.examples[0])\n", + "print(iris.inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Which correctly prints the first line in the csv file and the list of attribute indexes.\n", + "\n", + "When importing a dataset, we can specify to exclude an attribute (for example, at index 1) by setting the parameter exclude to the attribute index or name" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 2, 3]\n" + ] + } + ], + "source": [ + "iris2 = DataSet(name=\"iris\",exclude=[1])\n", + "print(iris2.inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing your own dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to use self-defined datasets, you need to prepare the csv files for the datasets in the following format of the [iris example](https://github.com/aimacode/aima-data/blob/a21fc108f52ad551344e947b0eb97df82f8d2b2b/iris.csv). Then you can create your own dataset by specifying the correct dataset name, attributes, targets and exclusive attributes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is how we create restaurant dataset in Figure 18.3 from restaurant.csv:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def RestaurantDataSet(examples=None):\n", + " \"\"\"Build a DataSet of Restaurant waiting examples. [Figure 18.3]\"\"\"\n", + " return DataSet(name='restaurant', target='Wait', examples=examples,\n", + " attrnames='Alternate Bar Fri/Sat Hungry Patrons Price ' +\n", + " 'Raining Reservation Type WaitEstimate Wait')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Please note that the dataset name should be the same to the csv file name in order to assist the program finding the correct file." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "restaurant = RestaurantDataSet()\n", + "restaurant.inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Class Attributes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we will demonstrate the attributes of a `DataSet` object and how they can be utilized. All the attributes can be specified when defining a dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- examples: Holds the items of the dataset. Each item is a list of values. Could be indexed or sliced." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[5.1, 3.5, 1.4, 0.2, 'setosa'],\n", + " [4.9, 3.0, 1.4, 0.2, 'setosa'],\n", + " [4.7, 3.2, 1.3, 0.2, 'setosa']]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iris.examples[:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **attrs**: The indexes of the features (by default in the range of [0,f), where f is the number of features). For example, item[i] returns the feature at index i of item.\n", + "\n", + "- **attrnames**: An optional list with attribute names. For example, item[s], where s is a feature name, returns the feature of name s in item.\n", + "\n", + "- **target**: The attribute a learning algorithm will try to predict. By default the last attribute.\n", + "\n", + "- **inputs**: This is the indexes of attributes without the target." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "attrs: [0, 1, 2, 3, 4]\n", + "attrnames (by default same as attrs): ['sepal-len', 'sepal-width', 'petal-len', 'petal-width', 'class']\n", + "target: 4\n", + "inputs: [0, 1, 2, 3]\n" + ] + } + ], + "source": [ + "print(\"attrs:\", iris.attrs)\n", + "print(\"attrnames (by default same as attrs):\", iris.attrnames)\n", + "print(\"target:\", iris.target)\n", + "print(\"inputs:\", iris.inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **values**: A list of lists which holds the set of possible values for the corresponding attribute/feature. If initially None, it gets computed (by the function setproblem) from the examples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For instance if we want to show the possible values of the first attribute:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.7, 5.5, 5.0, 4.9, 5.1, 4.6, 5.4, 4.4, 4.8, 4.3, 5.8, 7.0, 7.1, 4.5, 5.9, 5.6, 6.9, 6.5, 6.4, 6.6, 6.0, 6.1, 7.6, 7.4, 7.9, 5.7, 5.3, 5.2, 6.3, 6.7, 6.2, 6.8, 7.3, 7.2, 7.7]\n" + ] + } + ], + "source": [ + "print(iris.values[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **name**: Name of the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "name: iris\n" + ] + } + ], + "source": [ + "print(\"name:\", iris.name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **source**: The source of the dataset (url or other). Not used in the code.\n", + "\n", + "- **exclude**: A list of indexes to exclude from inputs. The list can include either attribute indexes (attrs) or names (attrnames)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Helper Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will now take a look at the auxiliary functions found in the class. These functions help modify a DataSet object to your needs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **sanitize**: Takes as input an example and returns it with non-input (target) attributes replaced by None. Useful for testing. Keep in mind that the example given is not itself sanitized, but instead a sanitized copy is returned." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the function doesn't actually change the given example; it returns a sanitized copy of it." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sanitized: [5.1, 3.5, 1.4, 0.2, None]\n", + "Original: [5.1, 3.5, 1.4, 0.2, 'setosa']\n" + ] + } + ], + "source": [ + "print(\"Sanitized:\",iris.sanitize(iris.examples[0]))\n", + "print(\"Original:\",iris.examples[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **classes_to_numbers**: Maps the class names of a dataset to numbers. If the class names are not given, they are computed from the dataset values. Useful for classifiers that return a numerical value instead of a string." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For a lot of the classifiers in the book, classes should have numerical values. With this function we are able to map string class names to numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class of first example: setosa\n", + "Class of first example: 0\n" + ] + } + ], + "source": [ + "print(\"Class of first example:\",iris2.examples[0][iris2.target])\n", + "iris2.classes_to_numbers()\n", + "print(\"Class of first example:\",iris2.examples[0][iris2.target])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **remove_examples**: Removes examples containing a given value. Useful for removing examples with missing values, or for removing classes (needed for binary classifiers)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Currently the iris dataset has three classes, setosa, virginica and versicolor. We want though to convert it to a binary class dataset (a dataset with two classes). The class we want to remove is \"virginica\". To accomplish that we will utilize the helper function remove_examples." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['setosa', 'versicolor']\n" + ] + } + ], + "source": [ + "iris2 = DataSet(name=\"iris\")\n", + "\n", + "iris2.remove_examples(\"virginica\")\n", + "print(iris2.values[iris2.target])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **find_means_and_deviations**: find the mean values and deviations of each class in the dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the iris example we have three classes, thus both means and deviations have the length of 3." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3 3\n" + ] + } + ], + "source": [ + "means, deviations = iris.find_means_and_deviations()\n", + "print(len(means), len(deviations))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setosa feature means: [5.006, 3.418, 1.464, 0.244]\n", + "Versicolor mean for first feature: 5.936\n", + "Setosa feature deviations: [0.3524896872134513, 0.38102439795469095, 0.17351115943644546, 0.10720950308167838]\n", + "Virginica deviation for second feature: 0.32249663817263746\n" + ] + } + ], + "source": [ + "print(\"Setosa feature means:\", means[\"setosa\"])\n", + "print(\"Versicolor mean for first feature:\", means[\"versicolor\"][0])\n", + "\n", + "print(\"Setosa feature deviations:\", deviations[\"setosa\"])\n", + "print(\"Virginica deviation for second feature:\",deviations[\"virginica\"][1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the example datasets are used extensively in the code of the book, below we show the common ways to provide a visualized tool that helps in comprehending the dataset and thus how the algorithms work." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Iris Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot the dataset in a 3D space using matplotlib and the function show_iris from notebook.py. The function takes as input three parameters, i, j and k, which are indicises to the iris features, \"Sepal Length\", \"Sepal Width\", \"Petal Length\" and \"Petal Width\" (0 to 3). By default we show the first three features." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "\n", + "show_iris()\n", + "show_iris(0, 1, 3)\n", + "show_iris(1, 2, 3)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/Decision Tree.ipynb b/notebooks/chapter18/Decision Tree.ipynb new file mode 100644 index 000000000..832733e5e --- /dev/null +++ b/notebooks/chapter18/Decision Tree.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DECISION TREE LEARNER\n", + "\n", + "### Overview\n", + "\n", + "#### Decision Trees\n", + "A decision tree is a flowchart that uses a tree of decisions and their possible consequences for classification. At each non-leaf node of the tree an attribute of the input is tested, based on which corresponding branch leading to a child-node is selected. At the leaf node the input is classified based on the class label of this leaf node. The paths from root to leaves represent classification rules based on which leaf nodes are assigned class labels.\n", + "![perceptron](images/decisiontree_fruit.jpg)\n", + "#### Decision Tree Learning\n", + "Decision tree learning is the construction of a decision tree from class-labeled training data. The data is expected to be a tuple in which each record of the tuple is an attribute used for classification. The decision tree is built top-down, by choosing a variable at each step that best splits the set of items. There are different metrics for measuring the \"best split\". These generally measure the homogeneity of the target variable within the subsets.\n", + "\n", + "#### Gini Impurity\n", + "Gini impurity of a set is the probability of a randomly chosen element to be incorrectly labeled if it was randomly labeled according to the distribution of labels in the set.\n", + "\n", + "$$I_G(p) = \\sum{p_i(1 - p_i)} = 1 - \\sum{p_i^2}$$\n", + "\n", + "We select a split which minimizes the Gini impurity in child nodes.\n", + "\n", + "#### Information Gain\n", + "Information gain is based on the concept of entropy from information theory. Entropy is defined as:\n", + "\n", + "$$H(p) = -\\sum{p_i \\log_2{p_i}}$$\n", + "\n", + "Information Gain is difference between entropy of the parent and weighted sum of entropy of children. The feature used for splitting is the one which provides the most information gain.\n", + "\n", + "#### Pseudocode\n", + "\n", + "You can view the pseudocode by running the cell below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pseudocode(\"Decision Tree Learning\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation\n", + "The nodes of the tree constructed by our learning algorithm are stored using either `DecisionFork` or `DecisionLeaf` based on whether they are a parent node or a leaf node respectively." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(DecisionFork)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "DecisionFork holds the attribute, which is tested at that node, and a dict of branches. The branches store the child nodes, one for each of the attribute's values. Calling an object of this class as a function with input tuple as an argument returns the next node in the classification path based on the result of the attribute test." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(DecisionTreeLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The implementation of DecisionTreeLearner provided in learning.py uses information gain as the metric for selecting which attribute to test for splitting. The function builds the tree top-down in a recursive manner. Based on the input it makes one of the four choices:\n", + "\n", + "
    \n", + "
  1. If the input at the current step has no training data we return the mode of classes of input data received in the parent step (previous level of recursion).
    2. \n", + "
  2. If all values in training data belong to the same class it returns a `DecisionLeaf` whose class label is the class which all the data belongs to.
    3. \n", + "
  3. If the data has no attributes that can be tested we return the class with highest plurality value in the training data.
    4. \n", + "
  4. We choose the attribute which gives the highest amount of entropy gain and return a `DecisionFork` which splits based on this attribute. Each branch recursively calls `decision_tree_learning` to construct the sub-tree.
    5. \n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "Here we will apply the Decision Tree Learner to classify our previous example datasets. `DecisionTreeLearner` only takes a `DataSet` object as input and will automatically learn the attributes and targets of data. The learner function will return a `DecisionFork` object which can be use to predict further data example.\n", + "\n", + "Decision Tree can be used to simulate the process of human making a decision. It can be applied to either binary or multiple classification. For many complex problems like digit image classification, decision tree can yeild very good results. Thus it can be the first algorithm to in order to investigate a dataset at the beginning of a project." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Iris Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try on the algorithm on iris example as it has less attributes which makes it clearer to demonstrate. \n", + "The first step is to load dataset to decision tree learner" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "\n", + "DTL = DecisionTreeLearner(iris)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can try a new example on the trained learner:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "setosa\n" + ] + } + ], + "source": [ + "print(DTL([5.1, 3.0, 1.1, 0.1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, the Decision Tree learner classifies the sample as \"setosa\" as seen in the previous section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Restaurant Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try the decision tree algorithm on Figure 18.3 example" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "restaurant = DataSet(name=\"restaurant\", attrnames='Alternate Bar Fri/Sat Hungry Patrons Price ' +\n", + " 'Raining Reservation Type WaitEstimate Wait')\n", + "RT = DecisionTreeLearner(restaurant)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we try to print the object, we can see the trained decision tree in the from of nested decision forks:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DecisionFork(4, 'Patrons', {'Full': DecisionFork(9, 'WaitEstimate', {'10-30': DecisionFork(8, 'Type', {'Italian': 'No', 'French': 'No', 'Burger': 'Yes', 'Thai': 'Yes'}), '>60': 'No', '0-10': 'No', '30-60': DecisionFork(8, 'Type', {'Italian': 'No', 'French': 'Yes', 'Burger': 'Yes', 'Thai': 'No'})}), 'None': 'No', 'Some': 'Yes'})\n" + ] + } + ], + "source": [ + "print(RT)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try a new example according to the attribute names:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Alternate', 'Bar', 'Fri/Sat', 'Hungry', 'Patrons', 'Price', 'Raining', 'Reservation', 'Type', 'WaitEstimate', 'Wait']\n" + ] + } + ], + "source": [ + "print(restaurant.attrnames)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try some Thai food with full patron and waiting time between 10 and 30 minites:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Yes\n" + ] + } + ], + "source": [ + "example = ['Yes', 'No', 'Yes', 'Yes', 'Full', '$', 'No', 'No', 'Thai', '10-30', 'Yes']\n", + "print(RT(example))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to try some else like French:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No\n" + ] + } + ], + "source": [ + "example = ['Yes', 'No', 'Yes', 'Yes', 'Full', '$', 'No', 'No', 'French', '10-30', 'Yes']\n", + "print(RT(example))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Random Forest" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Overview\n", + "\n", + "![random_forest.png](images/random_forest.png) \n", + "Image via [src](https://cdn-images-1.medium.com/max/800/0*tG-IWcxL1jg7RkT0.png)\n", + "\n", + "#### Random Forest\n", + "\n", + "As the name of the algorithm and image above suggest, this algorithm creates the forest with a number of trees. The more number of trees makes the forest robust. In the same way in random forest algorithm, the higher the number of trees in the forest, the higher is the accuray result. The main difference between Random Forest and Decision trees is that, finding the root node and splitting the feature nodes will be random. \n", + "\n", + "Let's see how Rnadom Forest Algorithm work : \n", + "Random Forest Algorithm works in two steps, first is the creation of random forest and then the prediction. Let's first see the creation : \n", + "\n", + "The first step in creation is to randomly select 'm' features out of total 'n' features. From these 'm' features calculate the node d using the best split point and then split the node into further nodes using best split. Repeat these steps until 'i' number of nodes are reached. Repeat the entire whole process to build the forest. \n", + "\n", + "Now, let's see how the prediction works\n", + "Take the test features and predict the outcome for each randomly created decision tree. Calculate the votes for each prediction and the prediction which gets the highest votes would be the final prediction.\n", + "\n", + "\n", + "### Implementation\n", + "\n", + "Below mentioned is the implementation of Random Forest Algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(RandomForest)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This algorithm creates an ensemble of decision trees using bagging and feature bagging. It takes 'm' examples randomly from the total number of examples and then perform feature bagging with probability p to retain an attribute. All the predictors are predicted from the DecisionTreeLearner and then a final prediction is made." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MNIST Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First let's load MNIST data to a `DataSet` object with predefined load function:" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "train_img, train_lbl, test_img, test_lbl = load_MNIST(path=\"../../aima-data/MNIST/Digits\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to use `load_MNIST` correctly, you need to input the correct data directory of MNIST data. Then we compose the training data and labels to a full example." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60000\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "examples = [np.append(train_img[i], train_lbl[i]) for i in range(len(train_img))]\n", + "print(len(examples))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have 60000 examples in total, we use the first 100 examples to roughly train the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "MNIST_dataset = DataSet(examples=examples[:100])\n", + "MNIST_RF = RandomForest(MNIST_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try a example in the dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAK4AAACuCAYAAACvDDbuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAFGklEQVR4nO3dvyt9cRzH8c+Vya/k94SFQTIYWKQrKaPJoO5qkPwoK5mky2Qw2JSMBoPFoEQoE4v8KBmQMokkut8/4PM+Ou659369judjfHfuuZ/h6VPnHI5EJpPJOEBM0f9eAJANwoUkwoUkwoUkwoUkwoUkwoUkwoUkwoWk4rAHJhKJfK4DcM45F/ZBLjsuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJBEuJIV+sfNfU19fb8739/e9WUlJiXlsMpn0Zjc3N5HWFWR6etqcz8/Pe7P19XXz2ImJiVwuKa/YcSGJcCGJcCGJcCGJizPnXFGR//ObSqXMY1taWrzZ9fW1eezX11e0hQXo6uryZrOzs+ax5eXl3mxhYSHnayo0dlxIIlxIIlxIIlxIIlxI4q6Cc25sbMybpdPp0J+fnJw057e3t9kuyTnnXEdHhznf2dnxZpWVleaxx8fH3uzl5SXSun4DdlxIIlxIIlxIIlxI+lMXZ01NTeZ8fHw89Dk+Pz+92cfHR9Zr+k7QuqqqqkKfw7o4e319zXpNvwU7LiQRLiQRLiQRLiQRLiQlMplMJtSBiUS+15JTxcX+DZONjQ3z2OHh4dDn3dvb82b9/f3hFxagt7fXm21tbZnH/uSuQnNzsze7u7sL/flCC5kjOy40ES4kES4kES4kxfaRb21trTf7yUVY0GPcxcXFrNfknHOlpaXmfGVlxZv95CJse3vbnD8/P4c+hxJ2XEgiXEgiXEgiXEgiXEiK7V2Furq6SJ+/uroy57u7u6HPYd1BGBkZMY8N+ovesGZmZsx5HH5p3MKOC0mEC0mEC0mEC0mxvTgbHR2N9PnGxkZzHvQ7spaamhpv1tPTk/WavtPe3m7Ord+9zddfJRcSOy4kES4kES4kES4kES4kxfauwv39faTPW/9myTnnhoaGIp03X4Ludqj9lW9Y7LiQRLiQRLiQRLiQFNtXMFVXV3uz8/Nz89iGhoZ8L+e/Ubs44xVMiDXChSTChSTChSTChaTYPvK13pmVTCbNY9va2ryZ9f99nbMfBXd3d/9scSGdnJyYc+t/8a6urprHPj095XRNvwU7LiQRLiQRLiQRLiTF9pFvvnR2dnqz09PTyOc9PDz0ZoODg+axcX2tknM88kXMES4kES4kES4kES4kxfaRb1QVFRXmfG5uLi/ft7y87M3ifPcgKnZcSCJcSCJcSCJcSOKRb4CgFyWfnZ1FOu/R0ZE5HxgY8GZvb2+RvksRj3wRa4QLSYQLSYQLSYQLSTzydfbj3XQ6nZfvWlpaMud/8Q5CFOy4kES4kES4kES4kMQjX+dca2urN7u4uIh8XusVSn19feax7+/vkb8vDnjki1gjXEgiXEgiXEgiXEjika9zbmpqKi/ntd4Hxt2D3GDHhSTChSTChSTChSQuzpxzZWVlkT7/+PhoztfW1iKdF8HYcSGJcCGJcCGJcCGJcCGJuwo5sLm5ac4vLy8LvJK/gx0XkggXkggXkggXkrg4c84dHBx4s1QqZR778PDgzXi0W3jsuJBEuJBEuJBEuJBEuJDEu8Pwq/DuMMQa4UIS4UIS4UIS4UIS4UIS4UIS4UIS4UIS4UJS6F8kD/soDigEdlxIIlxIIlxIIlxIIlxIIlxIIlxIIlxIIlxI+gegNfU4U/K/dQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(2,2))\n", + "plt.imshow(test_img[-3].reshape((28, 28)))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The prediction of our random forest model is as following:" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4, 4, 4, 1, 9]\n", + "4\n" + ] + } + ], + "source": [ + "print(MNIST_RF(test_img[-3]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Which is the same as our own perception of the figure." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Decision List Learner" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Decision list is an algorithm that applys PAC learning to a new hypothesis space. PAC is short for probably approximately correct which means any hypothesis that is consistent with a sufficiently large set of training examples is unlikely to be seriously wrong. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/Ensemble Learning.ipynb b/notebooks/chapter18/Ensemble Learning.ipynb new file mode 100644 index 000000000..371569c6e --- /dev/null +++ b/notebooks/chapter18/Ensemble Learning.ipynb @@ -0,0 +1,389 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ENSEMBLE LEARNER\n", + "\n", + "### Overview\n", + "\n", + "Ensemble Learning improves the performance of our model by combining several learners. It improvise the stability and predictive power of the model. Ensemble methods are meta-algorithms that combine several machine learning techniques into one predictive model in order to decrease variance, bias, or improve predictions. \n", + "\n", + "\n", + "\n", + "![ensemble_learner.jpg](images/ensemble_learner.jpg)\n", + "\n", + "\n", + "Some commonly used Ensemble Learning techniques are : \n", + "\n", + "1. Bagging : Bagging tries to implement similar learners on small sample populations and then takes a mean of all the predictions. It helps us to reduce variance error.\n", + "\n", + "2. Boosting : Boosting is an iterative technique which adjust the weight of an observation based on the last classification. If an observation was classified incorrectly, it tries to increase the weight of this observation and vice versa. It helps us to reduce bias error.\n", + "\n", + "3. Stacking : This is a very interesting way of combining models. Here we use a learner to combine output from different learners. It can either decrease bias or variance error depending on the learners we use.\n", + "\n", + "### Implementation\n", + "\n", + "Below mentioned is the implementation of Ensemble Learner." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(EnsembleLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This algorithm takes input as a list of learning algorithms, have them vote and then finally returns the predicted result." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## AdaBoost\n", + "\n", + "### Overview\n", + "\n", + "**AdaBoost** is an algorithm which uses **ensemble learning**. In ensemble learning the hypotheses in the collection, or ensemble, vote for what the output should be and the output with the majority votes is selected as the final answer.\n", + "\n", + "AdaBoost algorithm, as mentioned in the book, works with a **weighted training set** and **weak learners** (classifiers that have about 50%+epsilon accuracy i.e slightly better than random guessing). It manipulates the weights attached to the the examples that are showed to it. Importance is given to the examples with higher weights.\n", + "\n", + "All the examples start with equal weights and a hypothesis is generated using these examples. Examples which are incorrectly classified, their weights are increased so that they can be classified correctly by the next hypothesis. The examples that are correctly classified, their weights are reduced. This process is repeated *K* times (here *K* is an input to the algorithm) and hence, *K* hypotheses are generated.\n", + "\n", + "These *K* hypotheses are also assigned weights according to their performance on the weighted training set. The final ensemble hypothesis is the weighted-majority combination of these *K* hypotheses.\n", + "\n", + "The speciality of AdaBoost is that by using weak learners and a sufficiently large *K*, a highly accurate classifier can be learned irrespective of the complexity of the function being learned or the dullness of the hypothesis space." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation\n", + "\n", + "To view the source code of `AdaBoost`, you need to import the necessities first:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *\n", + "from utils4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then use the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

\n", + "\n", + "
def AdaBoost(L, K):\n",
+       "    """[Figure 18.34]"""\n",
+       "\n",
+       "    def train(dataset):\n",
+       "        examples, target = dataset.examples, dataset.target\n",
+       "        N = len(examples)\n",
+       "        epsilon = 1/(2*N)\n",
+       "        w = [1/N]*N\n",
+       "        h, z = [], []\n",
+       "        for k in range(K):\n",
+       "            h_k = L(dataset, w)\n",
+       "            h.append(h_k)\n",
+       "            error = sum(weight for example, weight in zip(examples, w)\n",
+       "                        if example[target] != h_k(example))\n",
+       "\n",
+       "            # Avoid divide-by-0 from either 0% or 100% error rates:\n",
+       "            error = clip(error, epsilon, 1 - epsilon)\n",
+       "            for j, example in enumerate(examples):\n",
+       "                if example[target] == h_k(example):\n",
+       "                    w[j] *= error/(1 - error)\n",
+       "            w = normalize(w)\n",
+       "            z.append(math.log((1 - error)/error))\n",
+       "        return WeightedMajority(h, z)\n",
+       "    return train\n",
+       "
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "psource(AdaBoost)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "AdaBoost takes as inputs: **L** and *K* where **L** is the learner and *K* is the number of hypotheses to be generated. The learner **L** takes in as inputs: a dataset and the weights associated with the examples in the dataset. But the input learner like `DecisionTreeLearner` doesnot handle weights and only takes a dataset as its input. \n", + "To remedy that we will give as input to the `DecisionTreeLearner` a modified dataset in which the examples will be repeated according to the weights associated to them. Intuitively, what this will do is force the learner to repeatedly learn the same example again and again until it can classify it correctly. \n", + "\n", + "To convert `DecisionTreeLearner` so that it can take weights as input too, we will have to pass it through the **`WeightedLearner`** function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(WeightedLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `WeightedLearner` function will then call the `PerceptronLearner`, during each iteration, with the modified dataset which contains the examples according to the weights associated with them." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "We will pass the `DecisionTreeLearner` through `WeightedLearner` function. Then we will create an `AdaboostLearner` classifier with number of hypotheses or *K* equal to 5." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "WeightedPerceptron = WeightedLearner(DecisionTreeLearner)\n", + "AdaboostLearner = AdaBoost(WeightedPerceptron, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'virginica'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iris2 = DataSet(name=\"iris\")\n", + "iris2.classes_to_numbers()\n", + "\n", + "adaboost = AdaboostLearner(iris2)\n", + "\n", + "adaboost([5, 3, 1, 0.1])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error ratio for adaboost: 0.0\n" + ] + } + ], + "source": [ + "print(\"Error ratio for adaboost: \", err_ratio(adaboost, iris2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generally using ensemble learning will increase the accuracy of final result as the weight voting of different learners will average the random error." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate Learners" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also offer an algorithm evaluating util function: `compare` in the source code. With this function user can compare different algorithms on multiple datasets in order to choose from them.\n", + "\n", + "The default algorithms to compare are `NearestNeighborLearner` and `DecisionTreeLearner`, and the datasets are iris, orings, zoo, restaurant and several other auto-generated test cases.\n", + "\n", + "To use the `compare` function with default settings:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " iris orings zoo restaur restaur majorit parity xor\n", + "NearestNeighbor 0.00 0.27 0.00 0.00 0.00 0.00 0.00 0.00\n", + "DecisionTree 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00\n" + ] + } + ], + "source": [ + "compare()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the datasets used here are very simple, there is no significant difference between the error rate of two algorithms except `NearestNeighborLearner` are not doing well on `orings` dataset. You can try self-defined datasets by specifying the `dataset` attribute as the list of datasets of interests such as MNIST." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/Linear and Nonparametric Models.ipynb b/notebooks/chapter18/Linear and Nonparametric Models.ipynb new file mode 100644 index 000000000..83f9318ed --- /dev/null +++ b/notebooks/chapter18/Linear and Nonparametric Models.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linear Models\n", + "Linear models are already used for hundred of years. It is a class of linear functions of continuous-valued inputs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Linear Learner\n", + "### Overview\n", + "\n", + "Linear Learner is a model that assumes a linear relationship between the input variables x and the single output variable y. More specifically, that y can be calculated from a linear combination of the input variables x. Linear learner is a quite simple model as the representation of this model is a linear equation. \n", + "\n", + "The linear equation assigns one scaler factor to each input value or column, called a coefficients or weights. One additional coefficient is also added, giving additional degree of freedom and is often called the intercept or the bias coefficient. \n", + "For example : y = ax1 + bx2 + c . \n", + "\n", + "### Implementation\n", + "\n", + "Below mentioned is the implementation of Linear Learner." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(LinearLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This algorithm first assigns some random weights to the input variables and then based on the error calculated updates the weight for each variable. Finally the prediction is made with the updated weights. \n", + "\n", + "### Example\n", + "\n", + "We will now use the Linear Learner to classify a sample with values: 5.1, 3.0, 1.1, 0.1." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path = [os.path.abspath(\"../../\")] + sys.path\n", + "from learning4e import *\n", + "from notebook4e import *\n", + "from utils4e import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the key point when applying a dataset to the linear learner is to convert the class names to numbers before feeding it into the learner:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0863712261312969\n" + ] + } + ], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "iris.classes_to_numbers()\n", + "\n", + "linear_learner = LinearLearner(iris)\n", + "print(linear_learner([5, 3, 1, 0.1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result is closer to 0 than 1 and 2, thus we can class it as class 0 which represents 'setosa'." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Logistic Linear Learner" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Logistic linear learner is different from common linear learner only in the updating rule of weights. Logistic function is continuous and derivable. Using `LogisticLinearLearner` is similar to using `LinearLearner`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.16279158793332174\n" + ] + } + ], + "source": [ + "logistic_learner = LogisticLinearLeaner(iris)\n", + "print(logistic_learner([5, 3, 1, 0.1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The prediction can also be treated as class 0." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Nonparametric Models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A nonparametric model is one that cannot be characterized by a bounded set of parameters. This usually happens when the dataset is huge and let the data speak for their own property is ensenstially good. The simplest approach is to put all examples into a lookup table. \n", + "\n", + "Here we will demonstrate a improved version of lookup table: k-nearest neighbors lookup, which finds the k examples that are nearest to the given query.\n", + "\n", + "## K-NEAREST NEIGHBOURS CLASSIFIER\n", + "\n", + "### Overview\n", + "\n", + "In this section we are going to use this to classify Iris flowers. More about kNN on [Scholarpedia](http://www.scholarpedia.org/article/K-nearest_neighbor).\n", + "\n", + "![kNN plot](images/knn_plot.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how kNN works with a simple plot shown in the above picture.\n", + "\n", + "We have co-ordinates (we call them **features** in Machine Learning) of this red star and we need to predict its class using the kNN algorithm. In this algorithm, the value of **k** is arbitrary. **k** is one of the **hyper parameters** for kNN algorithm. We choose this number based on our dataset and choosing a particular number is known as **hyper parameter tuning/optimising**. We learn more about this in coming topics.\n", + "\n", + "Let's put **k = 3**. It means you need to find 3-Nearest Neighbors of this red star and classify this new point into the majority class. Observe that smaller circle which contains three points other than **test point** (red star). As there are two violet points, which form the majority, we predict the class of red star as **violet- Class B**.\n", + "\n", + "Similarly if we put **k = 5**, you can observe that there are three yellow points, which form the majority. So, we classify our test point as **yellow- Class A**.\n", + "\n", + "In practical tasks, we iterate through a bunch of values for k (like [1, 3, 5, 10, 20, 50, 100]), see how it performs and select the best one. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation\n", + "\n", + "Below follows the implementation of the kNN algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "psource(NearestNeighborLearner)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It takes as input a dataset and k (default value is 1) and it returns a function, which we can later use to classify a new item.\n", + "\n", + "To accomplish that, the function uses a heap-queue, where the items of the dataset are sorted according to their distance from *example* (the item to classify). We then take the k smallest elements from the heap-queue and we find the majority class. We classify the item to this class." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example\n", + "\n", + "We measured a new flower with the following values: 5.1, 3.0, 1.1, 0.1. We want to classify that item/flower in a class. To do that, we write the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "setosa\n" + ] + } + ], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "\n", + "knn_model = NearestNeighborLearner(iris,k=3)\n", + "print(knn_model([5.1,3.0,1.1,0.1]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06000000000000005" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "err_ratio(knn_model, iris)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Which is the same as expected. By altering k, you can change the number of neighbors considering in the lookup procedure. Thus the classification accuracy is directly affected by k.\n", + "\n", + "In order to show the influence of k, we need to fake some data that easier for visualization first. We will use only two dimensions among the attributes of iris dataset.\n", + "\n", + "First, we load the dataset and compose a new dataset with the first two among all the attributes together with the target dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "iris = DataSet(name=\"iris\")\n", + "iris.classes_to_numbers()\n", + "examples = np.asarray(iris.examples)\n", + "reduced_iris = DataSet(examples=examples[:,[0,1,4]].tolist(), distance=euclidean_distance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we build models with different k and plot the model's decision boundaries with util function `plot_model_boundary`.\n", + "\n", + "Let's try with k=1 and assign the first attribute to x-axis and the second to y-axis." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=1)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see there are zigzag and rectangle shapes. The class of a point heavily relies on the nearest point type.\n", + "\n", + "Then we increase k to 3:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=3)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When k=3 we can see there are some areas near blue points are classified as green and the shape of each color chunk is no longer shuttered.\n", + "\n", + "Then we set k=5." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=5)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The class boundary seems more regular. Then let's double k, making k =14:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = NearestNeighborLearner(reduced_iris, k=14)\n", + "plot_model_boundary(reduced_iris,0,1, model=model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The decision boundary is smoother with larger k generally." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/chapter18/images/decisiontree_fruit.jpg b/notebooks/chapter18/images/decisiontree_fruit.jpg new file mode 100644 index 000000000..41ac4d606 Binary files /dev/null and b/notebooks/chapter18/images/decisiontree_fruit.jpg differ diff --git a/notebooks/chapter18/images/ensemble_learner.jpg b/notebooks/chapter18/images/ensemble_learner.jpg new file mode 100644 index 000000000..b1edd1ec5 Binary files /dev/null and b/notebooks/chapter18/images/ensemble_learner.jpg differ diff --git a/notebooks/chapter18/images/knn_plot.png b/notebooks/chapter18/images/knn_plot.png new file mode 100644 index 000000000..58b316fdd Binary files /dev/null and b/notebooks/chapter18/images/knn_plot.png differ diff --git a/notebooks/chapter18/images/random_forest.png b/notebooks/chapter18/images/random_forest.png new file mode 100644 index 000000000..e0ab1d658 Binary files /dev/null and b/notebooks/chapter18/images/random_forest.png differ diff --git a/utils4e.py b/utils4e.py index c66020b18..6e5915db5 100644 --- a/utils4e.py +++ b/utils4e.py @@ -360,7 +360,7 @@ def num_or_str(x): # TODO: rename as `atom` def euclidean_distance(X, Y): - return math.sqrt(sum((x - y)**2 for x, y in zip(X, Y))) + return math.sqrt(sum((x - y)**2 for x, y in zip(X, Y) if x and y)) def rms_error(X, Y): @@ -658,7 +658,6 @@ def print_table(table, header=None, sep=' ', numfmt='{}'): table = [[numfmt.format(x) if isnumber(x) else x for x in row] for row in table] - sizes = list( map(lambda seq: max(map(len, seq)), list(zip(*[map(str, row) for row in table]))))