diff --git a/ML Cookbook/BasicNeuralNet.py b/ML Cookbook/BasicNeuralNet.py
new file mode 100644
index 0000000..92e6d2f
--- /dev/null
+++ b/ML Cookbook/BasicNeuralNet.py
@@ -0,0 +1,23 @@
+from torch import nn
+
+class BasicNeuralNet(nn.Module):
+ def __init__(self):
+ super().__init__()
+
+ # Inputs to hidden layer linear transformation
+ self.hidden = nn.Linear(784, 256)
+ # Output layer, 10 units
+ self.output = nn.Linear(256, 10)
+
+ # Define sigmoid activation and softmax output
+ self.sigmoid = nn.Sigmoid()
+ self.softmax = nn.Softmax(dim=1)
+
+ def forward(self, x):
+ # Pass the input tensor through each of the operations
+ x = self.hidden(x)
+ x = self.sigmoid(x)
+ x = self.output(x)
+ x = self.softmax(x)
+
+ return x
\ No newline at end of file
diff --git a/ML Cookbook/CNNs/BasicCNN.py b/ML Cookbook/CNNs/BasicCNN.py
new file mode 100644
index 0000000..178ba57
--- /dev/null
+++ b/ML Cookbook/CNNs/BasicCNN.py
@@ -0,0 +1,16 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+# CNN architecture definition
+class Net(nn.Module):
+ def __init__(self):
+ super(Net, self).__init__()
+ # convolutional layer
+ self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
+ # max pooling layer
+ self.pool = nn.MaxPool2d(2, 2)
+
+ def forward(self, x):
+ # add sequence of convolutional and max pooling layers
+ x = self.pool(F.relu(self.conv1(x)))
+ return x
\ No newline at end of file
diff --git a/ML Cookbook/DecisionTree.py b/ML Cookbook/DecisionTree.py
new file mode 100644
index 0000000..312efe3
--- /dev/null
+++ b/ML Cookbook/DecisionTree.py
@@ -0,0 +1,342 @@
+"""
+:Author: James Sherratt
+:Date: 21/10/2019
+:License: MIT
+
+:name: DecisionTree.py
+
+Basic implementation of a binary decision tree algorithm, with one
+discriminant per node.
+
+Useful links:
+https://scikit-learn.org/stable/modules/tree.html
+https://en.wikipedia.org/wiki/Decision_tree
+"""
+
+import numpy as np
+from sklearn import datasets
+
+
+def proportion_k(ym):
+ """
+ Get the proportions of each class in the current set of values.
+
+ :param ym: y values (class) of the data at a given node.
+ :return: list containing the classes and the fraction of those classes present.
+ """
+ counts = list(np.unique(ym, return_counts=True))
+ counts[1] = counts[1]/(ym.shape[0])
+ return counts
+
+
+def gini(k_proportions):
+ """
+ Gini impurity function. This is used to determine the impurity of a given
+ set of data, given the proportions of the classes in the dataset.
+
+ This is equivalent to:
+ H = ∑ pk(1-pk) for all k classes.
+
+ k_proportions, in this case, is an array of pk's
+
+ :param k_proportions: array containing proportions of different classes. Proportions sum to 1.
+ :return: the impurity of the dataset.
+ """
+ return (k_proportions*(1-k_proportions)).sum()
+
+
+def node_impurity(ym):
+ """
+ Calculate the impurity of data on one side of node after split.
+
+ :param ym: Actual y data for the selected dataset.
+ :return: dict containing the impurity value of the side and the most common class on that side.
+ """
+ if ym.shape[0] == 0:
+ return {"impurity": 0, "max_class": 0}
+ k_prop = proportion_k(ym)
+ return {"impurity": gini(k_prop[1]), "max_class": k_prop[0][np.argmax(k_prop[1])]}
+
+
+def disc_val_impurity(yleft, yright):
+ """
+ Calculate the level of impurity left in the given data after splitting. This returns
+ a dict which contains:
+
+ - The impurity of the data after being split.
+ - The class of the largest proportion on the left and right side of the split.
+
+ The aim is to find a split which minimises impurity.
+
+ The impurity calculated is:
+ G = (nleft/ntot)*Hleft + (nright/ntot)*Hright
+
+ This gives the impurity of the split data.
+
+ :param yleft: Real/ training y values for the data on the left.
+ :param yright: Real/ training y values for the data on the right.
+ :return: Dict containing the data impurity after split and the most common class on the left and right of the split.
+ """
+ nleft = yleft.shape[0]
+ nright = yright.shape[0]
+ ntot = nleft + nright
+ left_imp = node_impurity(yleft)
+ right_imp = node_impurity(yright)
+
+ return {
+ "impurity": ((nleft/ntot)*left_imp["impurity"])+((nright/ntot)*right_imp["impurity"]),
+ "lmax_class": left_imp["max_class"],
+ "rmax_class": right_imp["max_class"]
+ }
+
+
+def niave_min_impurity(xm, ym):
+ """
+ Find a discriminator which minimises the impurity of the data. The discriminator
+ is used to split data at a node.
+
+ This works by:
+ 1. Selecting a data column as a discriminator.
+ 2. Splitting the possible values of the discriminator into 1000 even spaced values
+ (between the minimum and maximum value in the dataset).
+ 3. Selecting the discriminator column + value which minimises the impurity.
+
+ :param xm: Data on the left.
+ :param ym: Data on the right.
+ :return: dict containing the current niave minimum impurity.
+ """
+ minxs = xm.min(axis=0)
+ maxxs = xm.max(axis=0)
+
+ # discriminator with the smallest impurity.
+ cur_min_disc = None
+
+ # Choose a column to discriminate by.
+ for x_idx, (dmin, dmax) in enumerate(zip(minxs, maxxs)):
+ # Create a set of possibly values to use as the discriminator for that column.
+ disc_vals = np.linspace(dmin, dmax, 1000)
+ for disc_val in disc_vals:
+ selection = xm[:, x_idx] < disc_val
+ yleft = ym[selection]
+ yright = ym[selection==False]
+ # Calculate impurity.
+ imp = disc_val_impurity(yleft, yright)
+ # Choose a column with the smallest impurity.
+ try:
+ if cur_min_disc["impurity"] > imp["impurity"]:
+ imp["discriminator"] = x_idx
+ imp["val"] = disc_val
+ cur_min_disc = imp
+ except TypeError:
+ imp["discriminator"] = x_idx
+ imp["val"] = disc_val
+ cur_min_disc = imp
+
+ return cur_min_disc
+
+
+class BinaryTreeClassifier:
+
+ def __init__(self, max_depth=4, min_data=5):
+ """
+ Initialise the binary decision tree classifier. This classifier works by:
+ - Splitting the data into 2 sets at every node.
+ - These 2 sets are then split into 2 more sets at their nodes etc. until they reach a leaf.
+ - At the leaves, the data is classified into whatever class was "most common" in that leaf during training.
+
+ :param max_depth: The maximum depth the binary tree classifier goes to.
+ :param min_data: The minimum sample size of the training data before the tree stops splitting.
+ """
+ tree = dict()
+ self.depth = max_depth
+ self.min_data = min_data
+
+ def _node_mask(X, node):
+ """
+ Get the discriminator mask for the node. This splits the data into left and right components.
+
+ :param X: dataset input data.
+ :param node: the current node of the tree, with its discriminator value.
+ :return: truth array, which splits data left and right.
+ """
+ return X[:, node["discriminator"]] < node["val"]
+
+ def _apply_disc(X, y, node):
+ """
+ Apply the discriminator to the data at a given node.
+
+ :param X: dataset input.
+ :param y: dataset (observed) output.
+ :param node: The node to split data by.
+ :return: The x and y data, split left and right.
+ """
+ left_cond = BinaryTreeClassifier._node_mask(X, node)
+ right_cond = left_cond == False
+ left_X, left_y = X[left_cond], y[left_cond]
+ right_X, right_y = X[right_cond], y[right_cond]
+
+ return left_X, left_y, right_X, right_y
+
+ def _tree_node(X, y, max_depth, min_data):
+ """
+ Create a tree node. This also creates child nodes of this node recursively.
+
+ :param X: input data for the dataset at a node.
+ :param y: output (observed) data for the dataset at a node.
+ :param max_depth: The maximum depth of the tree from this node.
+ :param min_data: The minimum amount of data which can be discriminated.
+ :return: The node + its children, as a dict.
+ """
+ # Get the new node, as a dict.
+ node = niave_min_impurity(X, y)
+ # Split the data using the discriminator.
+ left_X, left_y, right_X, right_y = BinaryTreeClassifier._apply_disc(X, y, node)
+
+ if max_depth > 1:
+ if left_X.shape[0] >= min_data:
+ # Create a new node on the left (recursively) if max depth
+ # and min data have not been reached.
+ node["left"] = BinaryTreeClassifier._tree_node(left_X, left_y, max_depth-1, min_data)
+ if right_X.shape[0] >= min_data:
+ # Create a new node on the right (recursively) if max depth
+ # and min data have not been reached.
+ node["right"] = BinaryTreeClassifier._tree_node(right_X, right_y, max_depth-1, min_data)
+
+ return node
+
+ def _run_tree(X, node):
+ """
+ Run a node of the classifier, recurisively.
+
+ :param node: The node to run on the data.
+ :return: The classified y (expected) data.
+ """
+ # Setup y array.
+ y = np.zeros(X.shape[0])
+ # Get the discriminator left conditional.
+ left_cond = BinaryTreeClassifier._node_mask(X, node)
+ # Right conditional
+ right_cond = left_cond == False
+ try:
+ # Try to split the data further on the left side.
+ y[left_cond] = BinaryTreeClassifier._run_tree(X[left_cond], node["left"])
+ except KeyError:
+ # If we cannot split any further, get the class of the data on the left (as this is a leaf).
+ y[left_cond] = node["lmax_class"]
+ try:
+ # Try to split the data further on the right side.
+ y[right_cond] = BinaryTreeClassifier._run_tree(X[right_cond], node["right"])
+ except KeyError:
+ # If we cannot split any further, get the class of the data on the right (as this is a leaf).
+ y[right_cond] = node["rmax_class"]
+
+ return y
+
+ def _node_dict(node, idx=0):
+ """
+ Get a dict of all the nodes, recursively. The keys are the index of an array,
+ as if the array is a heap.
+
+ :param node: The current node to add to the dict and to get children of recursively.
+ :param idx: current index (key) of the node.
+ :return: dict containing all the nodes retrieved.
+ """
+ # Current nodes.
+ nodes = {}
+ node_data = {"lmax_class": node["lmax_class"],
+ "rmax_class": node["rmax_class"],
+ "discriminator": node["discriminator"],
+ "val": node["val"]}
+ nodes[idx] = node_data
+
+ # Try to get the left nodes.
+ try:
+ left_idx = 2 * idx + 1
+ nodes.update(BinaryTreeClassifier._node_dict(node["left"], left_idx))
+ except KeyError:
+ pass
+
+ # Try to get the right nodes.
+ try:
+ right_idx = 2 * idx + 2
+ nodes.update(BinaryTreeClassifier._node_dict(node["right"], right_idx))
+ except KeyError:
+ pass
+
+ # return the dict of nodes retrieved.
+ return nodes
+
+ def build_tree(self, X, y):
+ """
+ Build (train) the decision tree classifier.
+
+ :param X: input training data.
+ :param y: output training (observed) data.
+ :return: None
+ """
+ self.tree = BinaryTreeClassifier._tree_node(X, y, self.depth, self.min_data)
+
+ def classify(self, X):
+ """
+ Classify some data using the tree.
+
+ :param X: Input data.
+ :return: output (expected) classes of the data, or y values, for the given input.
+ """
+ return BinaryTreeClassifier._run_tree(X, self.tree)
+
+ def tree_to_heap_array(self):
+ """
+ Convert the tree to a binary heap, stored in an array with standard indexing.
+ i.e. a node at index i has children at 2i*1 and 2i+2 and a parent at (i-1)//2.
+
+ :return: list containing the tree nodes.
+ """
+ tree_dict = BinaryTreeClassifier._node_dict(self.tree)
+ return [tree_dict[key] for key in sorted(tree_dict.keys())]
+
+
+def shuffle_split(x, y, frac=0.6):
+ """
+ Shuffle and split X and y data. "frac" is the ratio of the split.
+ e.g. 0.6 means 60% of the data goes into the left fraction, 40% into the right.
+ Note X and y are shuffled the same, so row i in X data is still matched with row i in y after shuffle.
+
+ :param x: X values of the data (predictor).
+ :param y: y values of the data (observation).
+ :param frac: fraction to split data by.
+ :return: x1, y1, x2, y2 data where x1, y1 is the left fraction and x2, y2 is the right.
+ """
+ data_idx = np.arange(x.shape[0])
+ sample1 = data_idx < (data_idx.max()*frac)
+ np.random.shuffle(data_idx)
+ np.random.shuffle(sample1)
+ sample2 = sample1 == False
+ x1, y1 = x[data_idx[sample1]], y[data_idx[sample1]]
+ x2, y2 = x[data_idx[sample2]], y[data_idx[sample2]]
+ return x1, y1, x2, y2
+
+
+if __name__ == "__main__":
+ # Set the seed for expected test results.
+ np.random.seed(10)
+ # Test decision tree with iris data.
+ iris_data = datasets.load_iris()
+ X = iris_data["data"]
+ y = iris_data["target"]
+ # Split iris data into test and train.
+ X_train, y_train, X_test, y_test = shuffle_split(X, y)
+ # create the decision tree classifier.
+ classifier = BinaryTreeClassifier()
+ # Train the classifier.
+ classifier.build_tree(X_train, y_train)
+ # Get the result when the classifier is applied to to the test data.
+ result = classifier.classify(X_test)
+ # Get the accuracy of the classifier.
+ # accuracy = (number of correct results)/(total number of results)
+ print("accuracy:", (result == y_test).sum()/(result.shape[0]))
+ # convert the tree into a heap array.
+ tree_arr = classifier.tree_to_heap_array()
+ print("heap:")
+ for i, node in enumerate(tree_arr):
+ print(i, node)
diff --git a/ML Cookbook/clean_text.py b/ML Cookbook/clean_text.py
new file mode 100644
index 0000000..d5b58b6
--- /dev/null
+++ b/ML Cookbook/clean_text.py
@@ -0,0 +1,29 @@
+
+import re as clear
+
+class process():
+ def master_clean_text(text):
+ #clean up all the html tags
+ text = clear.sub(r'<.*?>','',text)
+ #remove the unwanted punctation chars
+
+ text = clear.sub(r"\\","",text)
+ text = clear.sub(r"\'","",text)
+ text = clear.sub(r"\"","",text)
+
+ # coversion to lowercase to remove complexity
+ text = text.strip().lower()
+
+ #removing unwanted expressions
+
+ unwanted = '!"\'#$%&()*+,-./:;<=>?@[\\]^_`{|}~\t\n'
+
+ convert = dict((c," ") for c in unwanted)
+
+ # str.maketrans() --->> creates a one to one mapping of a character to its translation/replacement.
+ mapping_trans = str.maketrans(convert)
+
+ text = text.translate(mapping_trans)
+
+ return text
+ #master_clean_text(" Say youre scrapping a text from you'r website !! WEll it might be swap CASE or unevened you wanna remove all the punctation's into separate WOrd !!!!").split()
diff --git a/ML Cookbook/perceptron.py b/ML Cookbook/perceptron.py
new file mode 100644
index 0000000..4900276
--- /dev/null
+++ b/ML Cookbook/perceptron.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+class Perceptron(object):
+ """Implements a perceptron network"""
+ def __init__(self, input_size, lr=1, epochs=100):
+ self.W = np.zeros(input_size+1)
+ # add one for bias
+ self.epochs = epochs
+ self.lr = lr
+
+ #activation function
+ def activation_fn(self, x):
+ #return (x >= 0).astype(np.float32)
+ return 1 if x >= 0 else 0
+
+ #we need a prediction function to run an input through the perceptron and return an output.
+ def predict(self, x):
+ z = self.W.T.dot(x)
+ a = self.activation_fn(z)
+ return a
+
+ def fit(self, X, d):
+ for _ in range(self.epochs):
+ for i in range(d.shape[0]):
+ x = np.insert(X[i], 0, 1)
+ y = self.predict(x)
+ e = d[i] - y
+ self.W = self.W + self.lr * e * x
+#the easiset set of data that we can provide is the AND gate. Given is set of inputs and outputs.
+if __name__ == '__main__':
+ X = np.array([
+ [0, 0],
+ [0, 1],
+ [1, 0],
+ [1, 1]
+ ])
+ d = np.array([0, 0, 0, 1])
+
+ perceptron = Perceptron(input_size=2)
+ perceptron.fit(X, d)
+ print(perceptron.W)
diff --git a/ML Cookbook/perceptron1.py b/ML Cookbook/perceptron1.py
new file mode 100644
index 0000000..4900276
--- /dev/null
+++ b/ML Cookbook/perceptron1.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+class Perceptron(object):
+ """Implements a perceptron network"""
+ def __init__(self, input_size, lr=1, epochs=100):
+ self.W = np.zeros(input_size+1)
+ # add one for bias
+ self.epochs = epochs
+ self.lr = lr
+
+ #activation function
+ def activation_fn(self, x):
+ #return (x >= 0).astype(np.float32)
+ return 1 if x >= 0 else 0
+
+ #we need a prediction function to run an input through the perceptron and return an output.
+ def predict(self, x):
+ z = self.W.T.dot(x)
+ a = self.activation_fn(z)
+ return a
+
+ def fit(self, X, d):
+ for _ in range(self.epochs):
+ for i in range(d.shape[0]):
+ x = np.insert(X[i], 0, 1)
+ y = self.predict(x)
+ e = d[i] - y
+ self.W = self.W + self.lr * e * x
+#the easiset set of data that we can provide is the AND gate. Given is set of inputs and outputs.
+if __name__ == '__main__':
+ X = np.array([
+ [0, 0],
+ [0, 1],
+ [1, 0],
+ [1, 1]
+ ])
+ d = np.array([0, 0, 0, 1])
+
+ perceptron = Perceptron(input_size=2)
+ perceptron.fit(X, d)
+ print(perceptron.W)
diff --git a/ML Cookbook/text_preprocessing b/ML Cookbook/text_preprocessing
new file mode 100644
index 0000000..8c10309
--- /dev/null
+++ b/ML Cookbook/text_preprocessing
@@ -0,0 +1,41 @@
+import shutil
+
+from shutil import copyfile
+
+copyfile(src = "../input/cleantext/cleantext.py", dst = "../working/cleantext.py")
+
+# import all our functions
+from cleantext import *
+
+#!pylint cleantext
+
+import pandas as pd
+from sklearn.feature_extraction.text import CountVectorizer
+
+training = [
+ " I am master of all",
+ "I am a absolute learner"
+]
+
+generalization = [
+ "I am absolute learner learner"
+]
+
+vectorization = CountVectorizer(
+ stop_words = "english",
+ preprocessor = process.master_clean_text)
+
+vectorization.fit(training)
+
+build_vocab = {
+ value:key
+ for key , value in vectorization.vocabulary_.items()
+}
+
+vocab = [build_vocab[i] for i in range(len(build_vocab))]
+
+pd.DataFrame(
+data = vectorization.transform(generalization).toarray(),
+ index=["generalization"],
+ columns=vocab
+)
diff --git a/bfs.py b/bfs.py
new file mode 100644
index 0000000..05c9639
--- /dev/null
+++ b/bfs.py
@@ -0,0 +1,63 @@
+# Python3 Program to print BFS traversal
+
+from collections import defaultdict
+
+# This class represents a directed graph
+# using adjacency list representation
+class Graph:
+
+ # Constructor
+ def __init__(self):
+
+ # default dictionary to store graph
+ self.graph = defaultdict(list)
+
+ # function to add an edge to graph
+ def addEdge(self,u,v):
+ self.graph[u].append(v)
+
+ # Function to print a BFS of graph
+ def BFS(self, s):
+
+ # Mark all the vertices as not visited
+ visited = [False] * (len(self.graph))
+
+ # Create a queue for BFS
+ queue = []
+
+ # Mark the source node as
+ # visited and enqueue it
+ queue.append(s)
+ visited[s] = True
+
+ while queue:
+
+ # Dequeue a vertex from
+ # queue and print it
+ s = queue.pop(0)
+ print (s, end = " ")
+
+ # Get all adjacent vertices of the
+ # dequeued vertex s. If a adjacent
+ # has not been visited, then mark it
+ # visited and enqueue it
+ for i in self.graph[s]:
+ if visited[i] == False:
+ queue.append(i)
+ visited[i] = True
+
+# Driver code
+
+
+g = Graph()
+g.addEdge(0, 1)
+g.addEdge(0, 2)
+g.addEdge(1, 2)
+g.addEdge(2, 0)
+g.addEdge(2, 3)
+g.addEdge(3, 3)
+
+print ("Following is Breadth First Traversal"
+ " (starting from vertex 2)")
+g.BFS(2)
+
diff --git a/config/vimrc b/config/vimrc
new file mode 100644
index 0000000..9f9f3d2
--- /dev/null
+++ b/config/vimrc
@@ -0,0 +1,120 @@
+" sets spell check to be enabled to files which
+" end with either .md or .txt
+"
+" To get auto complete type z= when you are
+" over the word.
+autocmd BufRead,BufNewFile *.md setlocal spell spelllang=en_us
+autocmd BufRead,BufNewFile *.txt setlocal spell spelllang=en_us
+
+
+""" Indentation and Tabs """
+"file based indentation
+filetype plugin indent on
+
+"copy indentation from current line when making a new line
+set autoindent
+" Smart indentation when programming: indent after {
+set smartindent
+
+set tabstop=4 " number of spaces per tab
+set expandtab " convert tabs to spaces
+set shiftwidth=4 " set a tab press equal to 4 spaces
+
+
+""" Looks and Appearance"""
+
+" Enable syntax highlighting
+syntax enable
+
+" Enable 256 colors palette in Gnome Terminal
+if $COLORTERM == 'gnome-terminal'
+ set t_Co=256
+endif
+
+try
+ colorscheme desert
+catch
+endtry
+
+set background=dark
+
+" Set extra options when running in GUI mode
+if has("gui_running")
+ set guioptions-=T
+ set guioptions-=e
+ set t_Co=256
+ set guitablabel=%M\ %t
+endif
+
+
+" File Encodings
+
+" Set utf8 as standard encoding and en_US as the standard language
+set encoding=utf8
+
+" Use Unix as the standard file type
+set ffs=unix,dos,mac
+
+
+" Productivity
+
+" Set Line Numbers to show
+set number
+
+" Highlights the current line with a underscore
+set cursorline
+
+" Displays a red bar at 80 characters
+set colorcolumn=80
+
+" Shows a auto complete tab when you are typing a command
+" like :sp
+set wildmenu
+
+" sets the size of the status bar at bottom to have a height of two
+set laststatus=2
+
+
+
+" Searching when in command mode type /words to find
+" search as characters are entered
+set incsearch
+" highlight matched characters
+set hlsearch
+
+" Ignore case when searching
+set ignorecase
+
+
+
+"Disable ding sound on error, flashes cursor instead
+set visualbell
+
+" Display ruler on bottom right -- should be there by default
+set ruler
+
+" Enables mouse support
+set mouse=a
+
+" Auto updates file if an external source edits the file
+set autoread
+
+" Improves performance by only redrawing screen when needed
+set lazyredraw
+
+
+" Copy and paste
+" Selection
+" v and arrows select characters
+" V select entire lines
+" d on something selected cuts it -- also used for delete
+" y = yank = copy
+" P paste before cursor
+" p paste after cursor
+
+
+
+" Basic Vim navigation
+" :sp file -- this will open a new file horizontally
+" :vsp file -- will open a file splitting vertically
+" ctrl-w w -- this will toggle to another open vim window
diff --git a/dfs.py b/dfs.py
new file mode 100644
index 0000000..0af865e
--- /dev/null
+++ b/dfs.py
@@ -0,0 +1,58 @@
+# Python3 program to print DFS traversal
+
+from collections import defaultdict
+
+# This class represents a directed graph using
+# adjacency list representation
+class Graph:
+
+ # Constructor
+ def __init__(self):
+
+ # default dictionary to store graph
+ self.graph = defaultdict(list)
+
+
+ def addEdge(self, u, v):
+ self.graph[u].append(v)
+
+ # A function used by DFS
+ def DFSUtil(self, v, visited):
+
+ # Mark the current node as visited
+ # and print it
+ visited[v] = True
+ print(v, end = ' ')
+
+ # Recur for all the vertices
+ # adjacent to this vertex
+ for i in self.graph[v]:
+ if visited[i] == False:
+ self.DFSUtil(i, visited)
+
+ # The function to do DFS traversal. It uses
+ # recursive DFSUtil()
+ def DFS(self, v):
+
+ # Mark all the vertices as not visited
+ visited = [False] * (len(self.graph))
+
+ # Call the recursive helper function
+ # to print DFS traversal
+ self.DFSUtil(v, visited)
+
+# Driver code
+
+# Create a graph given
+# in the above diagram
+g = Graph()
+g.addEdge(0, 1)
+g.addEdge(0, 2)
+g.addEdge(1, 2)
+g.addEdge(2, 0)
+g.addEdge(2, 3)
+g.addEdge(3, 3)
+
+print("Following is DFS from (starting from vertex 2)")
+g.DFS(2)
+
diff --git a/geneticAlgorithm/geneticAlgo.html b/geneticAlgorithm/geneticAlgo.html
new file mode 100644
index 0000000..c09a7a2
--- /dev/null
+++ b/geneticAlgorithm/geneticAlgo.html
@@ -0,0 +1,579 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Population Variables
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/graphing/basicGraph.html b/graphing/basicGraph.html
new file mode 100644
index 0000000..e75c3fc
--- /dev/null
+++ b/graphing/basicGraph.html
@@ -0,0 +1,92 @@
+
+
+
+ Graph2d | Performance
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Click the button then choose a file to graph.
+
+
+
+
+
+
+
+
+
+
+
diff --git a/graphing/ex.json b/graphing/ex.json
new file mode 100644
index 0000000..6615c8e
--- /dev/null
+++ b/graphing/ex.json
@@ -0,0 +1 @@
+[{"x": "2014-06-1", "y": -6},{"x": "2014-06-11", "y": 0},{"x": "2014-06-12", "y": 25},{"x": "2014-06-13", "y": 30},{"x": "2014-06-14", "y": 10},{"x": "2014-06-15", "y": 15},{"x": "2014-06-16", "y": 30}]
diff --git a/graphing/floyd_warshall.py b/graphing/floyd_warshall.py
new file mode 100644
index 0000000..bae93d8
--- /dev/null
+++ b/graphing/floyd_warshall.py
@@ -0,0 +1,142 @@
+class Graph:
+ def __init__(self):
+ self.vertices = {}
+
+ def add_vertex(self, key):
+ vertex = Vertex(key)
+ self.vertices[key] = vertex
+
+ def get_vertex(self, key):
+ return self.vertices[key]
+
+ def __contains__(self, key):
+ return key in self.vertices
+
+ def add_edge(self, src_key, dest_key, weight=1):
+ self.vertices[src_key].add_neighbour(self.vertices[dest_key], weight)
+
+ def does_edge_exist(self, src_key, dest_key):
+ return self.vertices[src_key].does_it_point_to(self.vertices[dest_key])
+
+ def __len__(self):
+ return len(self.vertices)
+
+ def __iter__(self):
+ return iter(self.vertices.values())
+
+
+class Vertex:
+ def __init__(self, key):
+ self.key = key
+ self.points_to = {}
+
+ def get_key(self):
+ return self.key
+
+ def add_neighbour(self, dest, weight):
+ self.points_to[dest] = weight
+
+ def get_neighbours(self):
+ return self.points_to.keys()
+
+ def get_weight(self, dest):
+ return self.points_to[dest]
+
+ def does_it_point_to(self, dest):
+ return dest in self.points_to
+
+
+def floyd_warshall(g):
+ distance = {v:dict.fromkeys(g, float('inf')) for v in g}
+ next_v = {v:dict.fromkeys(g, None) for v in g}
+
+ for v in g:
+ for n in v.get_neighbours():
+ distance[v][n] = v.get_weight(n)
+ next_v[v][n] = n
+
+ for v in g:
+ distance[v][v] = 0
+ next_v[v][v] = None
+
+ for p in g:
+ for v in g:
+ for w in g:
+ if distance[v][w] > distance[v][p] + distance[p][w]:
+ distance[v][w] = distance[v][p] + distance[p][w]
+ next_v[v][w] = next_v[v][p]
+
+ return distance, next_v
+
+
+def print_path(next_v, u, v):
+
+ p = u
+ while (next_v[p][v]):
+ print('{} -> '.format(p.get_key()), end='')
+ p = next_v[p][v]
+ print('{} '.format(v.get_key()), end='')
+
+
+g = Graph()
+print('Menu')
+print('add vertex ')
+print('add edge ')
+print('floyd-warshall')
+print('display')
+print('quit')
+
+while True:
+ do = input('What would you like to do? ').split()
+
+ operation = do[0]
+ if operation == 'add':
+ suboperation = do[1]
+ if suboperation == 'vertex':
+ key = int(do[2])
+ if key not in g:
+ g.add_vertex(key)
+ else:
+ print('Vertex already exists.')
+ elif suboperation == 'edge':
+ src = int(do[2])
+ dest = int(do[3])
+ weight = int(do[4])
+ if src not in g:
+ print('Vertex {} does not exist.'.format(src))
+ elif dest not in g:
+ print('Vertex {} does not exist.'.format(dest))
+ else:
+ if not g.does_edge_exist(src, dest):
+ g.add_edge(src, dest, weight)
+ else:
+ print('Edge already exists.')
+
+ elif operation == 'floyd-warshall':
+ distance, next_v = floyd_warshall(g)
+ print('Shortest distances:')
+ for start in g:
+ for end in g:
+ if next_v[start][end]:
+ print('From {} to {}: '.format(start.get_key(),
+ end.get_key()),
+ end = '')
+ print_path(next_v, start, end)
+ print('(distance {})'.format(distance[start][end]))
+
+ elif operation == 'display':
+ print('Vertices: ', end='')
+ for v in g:
+ print(v.get_key(), end=' ')
+ print()
+
+ print('Edges: ')
+ for v in g:
+ for dest in v.get_neighbours():
+ w = v.get_weight(dest)
+ print('(src={}, dest={}, weight={}) '.format(v.get_key(),
+ dest.get_key(), w))
+ print()
+
+ elif operation == 'quit':
+ break
diff --git a/graphing/graph.py b/graphing/graph.py
new file mode 100644
index 0000000..f4c6efa
--- /dev/null
+++ b/graphing/graph.py
@@ -0,0 +1,122 @@
+"""
+:Author: James Sherratt
+:Date: 20/10/2019
+:License: MIT
+
+:name: graph.py
+"""
+
+
+class Graph:
+
+ def __init__(self):
+ self.vertices = set()
+ self.edges = set()
+
+ def add_vertex(self, vert):
+ """
+ Add a vertex to the graph.
+
+ :param vert: name of the vertex.
+ :return: None
+ """
+ self.vertices.add(vert)
+
+ def add_edge(self, vert1, vert2, directional=False):
+ """
+ Add an edge to the graph. The edge will be defined as a simple tuple where:
+ - The first value is the initial edge.
+ - The second is the final edge.
+ - The third is whether the edge is directional.
+
+ :param vert1: the start vertex.
+ :param vert2: the end vertex.
+ :param directional: whether or not the edge has a direction. Default: False
+ :return: None
+ """
+ self.vertices.add(vert1)
+ self.vertices.add(vert2)
+ if (not directional) and (vert1 > vert2):
+ # swap if not directional to avoid duplicates in the set.
+ self.edges.add((vert2, vert1, directional))
+ else:
+ self.edges.add((vert1, vert2, directional))
+
+ def adjacency(self, vert1, vert2):
+ """
+ Check if 2 vertices are adjacent (if they exist). Note: if vert1 and vert2
+ are connected, but directionally from vert2 to vert1, False is returned.
+
+ :param vert1: The first vertex to compare.
+ :param vert2: The second vertex to compare.
+ :return: True if adjacent, False if not, None if either are not in the set.
+ """
+ if (vert1 not in self.vertices) or (vert2 not in self.vertices):
+ return None
+
+ for edge in self.edges:
+ if (vert1 == edge[0]) and (vert2 == edge[1]):
+ return True
+ if (not edge[2]) and ((vert1 == edge[1]) and (vert2 == edge[0])):
+ return True
+ return False
+
+ def neighbours(self, vert):
+ """
+ Get the neighbours of a vertex.
+ :param vert: name of the vertex.
+ :return: list of neighbours, or None if the vertex is not in the graph.
+ """
+ if vert not in self.vertices:
+ return None
+
+ neighbours = set()
+ for edge in self.edges:
+ if vert == edge[0]:
+ neighbours.add(edge[1])
+ elif (not edge[2]) and (vert == edge[1]):
+ neighbours.add(edge[0])
+ return neighbours
+
+ def as_dict(self):
+ """
+ Convert the graph to a dictionary where:
+ - Each key is a vertex.
+ - Each value is a set of neighbours you can travel to.
+
+ :return: dict representing the graph.
+ """
+ graph_dict = {v: set() for v in self.vertices}
+ for edge in self.edges:
+ graph_dict[edge[0]].add(edge[1])
+ if not edge[2]:
+ graph_dict[edge[1]].add(edge[0])
+
+ return graph_dict
+
+
+if __name__ == "__main__":
+ mygraph = Graph()
+ mygraph.add_edge("a", "b")
+ mygraph.add_edge("b", "c")
+ mygraph.add_edge("b", "d")
+ mygraph.add_edge("c", "b")
+ mygraph.add_edge("a", "e", directional=True)
+ mygraph.add_vertex("z")
+ print("b neighbours:", mygraph.neighbours("b"))
+ print("a neighbours:", mygraph.neighbours("a"))
+ print("q neighbours:", mygraph.neighbours("q"))
+ print("e neighbours:", mygraph.neighbours("e"))
+ print()
+ # Adjacency has direction.
+ print("a and e adjacent:", mygraph.adjacency("a", "e"))
+ print("e and a adjacent:", mygraph.adjacency("e", "a"))
+ print("d and b adjacent", mygraph.adjacency("d", "b"))
+ print("q and a adjacent:", mygraph.adjacency("q", "a"))
+ print("z and a adjacent:", mygraph.adjacency("z", "a"))
+ print()
+ print("as dict")
+ print(mygraph.as_dict())
+
+ # Exercise/ project: add a method "path" to find path between 2 vertices.
+ # (Hint: lookup DFS/ BFS algorithm.)
diff --git a/multiThreadedFileIO/DataCreator.java b/multiThreadedFileIO/DataCreator.java
new file mode 100644
index 0000000..e551be1
--- /dev/null
+++ b/multiThreadedFileIO/DataCreator.java
@@ -0,0 +1,71 @@
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.math.*;
+
+/**
+ * Simple class to generate random data for
+ * file IO tests.
+ *
+ * @author Jeffery Russell 1-31-19
+ */
+public class DataCreator
+{
+ /**
+ * Generates an obscure random character
+ * @return
+ */
+ private static char rndChar()
+ {
+ // or use Random or whatever
+ int rnd = (int) (Math.random() * 52);
+ char base = (rnd < 26) ? 'A' : 'a';
+ return (char) (base + rnd % 26);
+ }
+
+
+ /**
+ * Simple function to save contents to the disk
+ *
+ * @param s
+ * @param fileName
+ */
+ private static void saveToDisk(String s, String fileName)
+ {
+ BufferedWriter writer;
+ try
+ {
+ File file = new File(fileName);
+ file.createNewFile();
+ writer = new BufferedWriter(new FileWriter(file));
+ writer.write(s);
+ writer.flush();
+ writer.close();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+
+ /**
+ * Creates 5MB of random test data to use
+ */
+ public static void main(String[] arguments)
+ {
+ System.out.println("Creating Test Files");
+ for(int i = 0; i < 100; i++)
+ {
+ //10k random characters for each file
+ //each file is 10kb * 500 files, total size of 5MB
+ String s = "";
+ for(int j = 0; j < 1000000; j++)
+ {
+ s = s + rndChar();
+ }
+ saveToDisk(s, "./testData/" + i + ".txt");
+ System.out.println(s);
+ }
+ }
+}
\ No newline at end of file
diff --git a/multiThreadedFileIO/FileReader.java b/multiThreadedFileIO/FileReader.java
new file mode 100644
index 0000000..520fa81
--- /dev/null
+++ b/multiThreadedFileIO/FileReader.java
@@ -0,0 +1,44 @@
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+
+/**
+ * Simple class for reading files as strings.
+ *
+ * @author Jeffery Russell
+ */
+public class FileReader
+{
+
+ public static String readFile(String filePath)
+ {
+ String fileContent = new String();
+
+ try
+ {
+ BufferedReader br = new BufferedReader(
+ new InputStreamReader(new FileInputStream(filePath)));
+ String line;
+
+ while ((line = br.readLine()) != null)
+ {
+ fileContent = fileContent.concat(line);
+ }
+ br.close();
+ }
+ catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+ return fileContent;
+ }
+
+
+ public static void main(String[] args)
+ {
+ System.out.println("Test");
+ System.out.println(FileReader.readFile("./testData/data1.txt"));
+ }
+}
\ No newline at end of file
diff --git a/multiThreadedFileIO/MultiThreadedFileReadTest.java b/multiThreadedFileIO/MultiThreadedFileReadTest.java
new file mode 100644
index 0000000..32c63df
--- /dev/null
+++ b/multiThreadedFileIO/MultiThreadedFileReadTest.java
@@ -0,0 +1,40 @@
+import java.util.*;
+
+/**
+ * File to test the performance of multi threaded file
+ * io by reading a large quantity of files in parallel
+ * using a different amount of threads.
+ *
+ * @author Jeffery Russell 1-31-19
+ */
+public class MultiThreadedFileReadTest
+{
+ public static void main(String[] args)
+ {
+ List x = new ArrayList<>();
+ List y = new ArrayList<>();
+ for(int i = 1; i <= 64; i++)
+ {
+ long threadTotal = 0;
+ for(int w = 0; w < 20; w++)
+ {
+ TaskManager boss = new TaskManager(i);
+
+ for(int j = 0; j < 500; j++)
+ {
+ boss.addTask(new ReadTask("./testData/" + i + ".txt"));
+ }
+ long startTime = System.nanoTime();
+ boss.runTasks();
+ long endTime = System.nanoTime();
+ long durationMS = (endTime - startTime)/1000000;
+ threadTotal+= durationMS;
+ }
+
+ x.add(i);
+ y.add(threadTotal/20.0); //finds average
+ }
+ System.out.println(x);
+ System.out.println(y);
+ }
+}
\ No newline at end of file
diff --git a/multiThreadedFileIO/ReadTask.java b/multiThreadedFileIO/ReadTask.java
new file mode 100644
index 0000000..249f608
--- /dev/null
+++ b/multiThreadedFileIO/ReadTask.java
@@ -0,0 +1,20 @@
+/**
+ * Simple method to be used by the task manager to do
+ * file io.
+ *
+ * @author Jeffery Russell
+ */
+public class ReadTask
+{
+ private String fileName;
+
+ public ReadTask(String fileName)
+ {
+ this.fileName = fileName;
+ }
+
+ public void runTask()
+ {
+ FileReader.readFile(fileName);
+ }
+}
\ No newline at end of file
diff --git a/multiThreadedFileIO/TaskManager.java b/multiThreadedFileIO/TaskManager.java
new file mode 100644
index 0000000..2929b31
--- /dev/null
+++ b/multiThreadedFileIO/TaskManager.java
@@ -0,0 +1,87 @@
+import java.util.List;
+import java.util.Vector;
+
+/**
+ * A class which enables user to run a large chunk of
+ * tasks in parallel efficiently.
+ *
+ * @author Jeffery 1-29-19
+ */
+public class TaskManager
+{
+ /** Number of threads to use at once */
+ private int threadCount;
+
+ /** Meaningless tasks to run in parallel */
+ private List tasks;
+
+
+ public TaskManager(int threadCount)
+ {
+ this.threadCount = threadCount;
+ //using vectors because they are thread safe
+ this.tasks = new Vector<>();
+ }
+
+
+ public void addTask(ReadTask t)
+ {
+ tasks.add(t);
+ }
+
+
+ /**
+ * This is the fun method.
+ *
+ * This will run all of the tasks in parallel using the
+ * desired amount of threads untill all of the jobs are
+ * complete.
+ */
+ public void runTasks()
+ {
+ int desiredThreads = threadCount > tasks.size() ?
+ tasks.size() : threadCount;
+
+ Thread[] runners = new Thread[desiredThreads];
+
+ for(int i = 0; i < desiredThreads; i++)
+ {
+ runners[i] = new Thread(()->
+ {
+ ReadTask t = null;
+ while(true)
+ {
+ //need synchronized block to prevent
+ //race condition
+ synchronized (tasks)
+ {
+ if(!tasks.isEmpty())
+ t = tasks.remove(0);
+ }
+ if(t == null)
+ {
+ break;
+ }
+ else
+ {
+ t.runTask();
+ t = null;
+ }
+ }
+ });
+ runners[i].start();
+ }
+
+ for(int i = 0; i < desiredThreads; i++)
+ {
+ try
+ {
+ runners[i].join();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/multiThreadedFileIO/graph.py b/multiThreadedFileIO/graph.py
new file mode 100644
index 0000000..469f90b
--- /dev/null
+++ b/multiThreadedFileIO/graph.py
@@ -0,0 +1,13 @@
+import matplotlib.pyplot as plt
+
+
+xList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]
+yList = [230.5, 124.0, 84.65, 63.9, 51.6, 44.2, 39.15, 34.9, 31.9, 28.7, 27.2, 25.05, 24.25, 22.8, 21.25, 20.45, 19.8, 19.4, 18.6, 17.45, 17.0, 16.95, 16.4, 24.15, 15.2, 15.2, 15.0, 14.3, 14.7, 14.65, 14.65, 14.75, 13.85, 15.1, 14.35, 35.75, 15.3, 14.45, 14.25, 13.65, 14.45, 14.6, 13.95, 14.65, 14.5, 14.3, 14.85, 14.15, 15.0, 16.25, 14.25, 14.4, 14.15, 14.45, 14.25, 14.85, 14.3, 14.35, 15.35, 13.6, 14.3, 14.2, 14.3, 13.95]
+
+
+
+plt.plot(xList, yList)
+plt.xlabel('Number of Threads')
+plt.ylabel('Execution Time (MS)')
+
+plt.show()
\ No newline at end of file
diff --git a/notebooks/8-bit/8-bit.ipynb b/notebooks/8-bit/8-bit.ipynb
new file mode 100644
index 0000000..b047660
--- /dev/null
+++ b/notebooks/8-bit/8-bit.ipynb
@@ -0,0 +1,306 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Open cv library\n",
+ "import cv2\n",
+ "\n",
+ "# matplotlib for displaying the images \n",
+ "from matplotlib import pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "img = cv2.imread('dolphin.jpg')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "