Merge pull request #31 from nancyanand2807/master

BFS

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)

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)

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) 
+  

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) 
+