From 997588c3ae0f07192db1646a315ea5398b0f3ead Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 19:51:58 +0530 Subject: [PATCH 01/25] water_jug.ipynb --- .../TASK_6 - Water Jug Problem.ipynb | 142 ++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_6 - Water Jug Problem.ipynb diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_6 - Water Jug Problem.ipynb b/Manasvi Vashishtha-4th yr-Section C/TASK_6 - Water Jug Problem.ipynb new file mode 100644 index 0000000..e8d6fbd --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_6 - Water Jug Problem.ipynb @@ -0,0 +1,142 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled5.ipynb", + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "GZoQhDk-Zu7d" + }, + "source": [ + "## Task_6 - Water Jug Problem" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QXgKoCT9Z0pf" + }, + "source": [ + "Objective: Write a program to implement water jug problem with two jugs the capacity of both the jugs should be entered by user. The quantity of the water to be stored should also be dynamic. The output will show all the steps to get the final state." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YKGraWV4aDnR", + "outputId": "b909f570-d9de-4f4a-bb0c-2c5e34f64491" + }, + "source": [ + "n1=int(input(\"Enter the capacity of first jug: \"))\n", + "n2=int(input(\"Enter the capacity of second jug: \"))\n", + "n3=int(input(\"In which jug to be filled :\"))\n", + "n4=int(input(\"How much to be filled: \"))\n", + "class Waterjug:\n", + " def __init__(self,am,bm,a,b,g):\n", + " self.a_max = am;\n", + " self.b_max = bm;\n", + " self.a = a;\n", + " self.b = b;\n", + " self.goal = g;\n", + " def fillA(self):\n", + " self.a = self.a_max;\n", + " print ('(', self.a, ',',self.b, ')')\n", + " def fillB(self):\n", + " self.b = self.b_max;\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def emptyA(self):\n", + " self.a = 0;\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def emptyB(self):\n", + " self.b = 0;\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def transferAtoB(self):\n", + " while (True):\n", + " self.a = self.a - 1\n", + " self.b = self.b + 1\n", + " if (self.a == 0 or self.b == self.b_max):\n", + " break\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def main(self):\n", + " while (True):\n", + " if (self.a == self.goal or self.b == self.goal):\n", + " break\n", + " if (self.a == 0):\n", + " self.fillA()\n", + " elif (self.a > 0 and self.b != self.b_max):\n", + " self.transferAtoB()\n", + " elif (self.a > 0 and self.b == self.b_max):\n", + " self.emptyB()\n", + "def pour(jug1, jug2):\n", + " max1, max2, fill = n1, n2, n4 \n", + " print(\"%d\\t%d\" % (jug1, jug2))\n", + " if jug2 is fill:\n", + " return \n", + " elif jug2 is max2:\n", + "\n", + " pour(0, jug1)\n", + " elif jug1 != 0 and jug2 is 0: \n", + " pour(0, jug1)\n", + " elif jug1 is fill: \n", + " pour(jug1, 0)\n", + " elif jug1 < max1: \n", + " pour(max1, jug2)\n", + " elif jug1 < (max2-jug2): \n", + " pour(0, (jug1+jug2))\n", + " else: \n", + " pour(jug1-(max2-jug2), (max2-jug2)+jug2) \n", + "print(\"JUG1\\tJUG2\")\n", + "if(n3==2):\n", + " pour(0, 0)\n", + "elif(n3==1):\n", + " print ('(', '0',',', '0', ')')\n", + " waterjug=Waterjug(n1,n2,0,0,n4);\n", + " waterjug.main();\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Enter the capacity of first jug: 5\n", + "Enter the capacity of second jug: 7\n", + "In which jug to be filled :2\n", + "How much to be filled: 2\n", + "JUG1\tJUG2\n", + "0\t0\n", + "5\t0\n", + "0\t5\n", + "5\t5\n", + "3\t7\n", + "0\t3\n", + "5\t3\n", + "1\t7\n", + "0\t1\n", + "5\t1\n", + "0\t6\n", + "5\t6\n", + "4\t7\n", + "0\t4\n", + "5\t4\n", + "2\t7\n", + "0\t2\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file From c3edff3adec2f58ce42cca5939d028739b6754d0 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 19:53:43 +0530 Subject: [PATCH 02/25] Missionary & cannibal --- .../TASK_7 - Missionary Cannibal Problem | 145 ++++++++++++++++++ 1 file changed, 145 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_7 - Missionary Cannibal Problem diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_7 - Missionary Cannibal Problem b/Manasvi Vashishtha-4th yr-Section C/TASK_7 - Missionary Cannibal Problem new file mode 100644 index 0000000..9491ae1 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_7 - Missionary Cannibal Problem @@ -0,0 +1,145 @@ +import math + +#______________________________________________________________________________ +# Missionaries and Cannibals Problem + +class State(): + def __init__(self, cannibalLeft, missionaryLeft, boat, cannibalRight, missionaryRight): + self.cannibalLeft = cannibalLeft + self.missionaryLeft = missionaryLeft + self.boat = boat + self.cannibalRight = cannibalRight + self.missionaryRight = missionaryRight + self.parent = None + + def is_goal(self): + if self.cannibalLeft == 0 and self.missionaryLeft == 0: + return True + else: + return False + + def is_valid(self): + if self.missionaryLeft >= 0 and self.missionaryRight >= 0 \ + and self.cannibalLeft >= 0 and self.cannibalRight >= 0 \ + and (self.missionaryLeft == 0 or self.missionaryLeft >= self.cannibalLeft) \ + and (self.missionaryRight == 0 or self.missionaryRight >= self.cannibalRight): + return True + else: + return False + + def __eq__(self, other): + return self.cannibalLeft == other.cannibalLeft and self.missionaryLeft == other.missionaryLeft \ + and self.boat == other.boat and self.cannibalRight == other.cannibalRight \ + and self.missionaryRight == other.missionaryRight + + def __hash__(self): + return hash((self.cannibalLeft, self.missionaryLeft, self.boat, self.cannibalRight, self.missionaryRight)) + +def successors(cur_state): + children = []; + if cur_state.boat == 'left': + new_state = State(cur_state.cannibalLeft, cur_state.missionaryLeft - 2, 'right', + cur_state.cannibalRight, cur_state.missionaryRight + 2) + ## Two missionaries cross left to right. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft - 2, cur_state.missionaryLeft, 'right', + cur_state.cannibalRight + 2, cur_state.missionaryRight) + ## Two cannibals cross left to right. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft - 1, cur_state.missionaryLeft - 1, 'right', + cur_state.cannibalRight + 1, cur_state.missionaryRight + 1) + ## One missionary and one cannibal cross left to right. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft, cur_state.missionaryLeft - 1, 'right', + cur_state.cannibalRight, cur_state.missionaryRight + 1) + ## One missionary crosses left to right. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft - 1, cur_state.missionaryLeft, 'right', + cur_state.cannibalRight + 1, cur_state.missionaryRight) + ## One cannibal crosses left to right. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + else: + new_state = State(cur_state.cannibalLeft, cur_state.missionaryLeft + 2, 'left', + cur_state.cannibalRight, cur_state.missionaryRight - 2) + ## Two missionaries cross right to left. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft + 2, cur_state.missionaryLeft, 'left', + cur_state.cannibalRight - 2, cur_state.missionaryRight) + ## Two cannibals cross right to left. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft + 1, cur_state.missionaryLeft + 1, 'left', + cur_state.cannibalRight - 1, cur_state.missionaryRight - 1) + ## One missionary and one cannibal cross right to left. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft, cur_state.missionaryLeft + 1, 'left', + cur_state.cannibalRight, cur_state.missionaryRight - 1) + ## One missionary crosses right to left. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + new_state = State(cur_state.cannibalLeft + 1, cur_state.missionaryLeft, 'left', + cur_state.cannibalRight - 1, cur_state.missionaryRight) + ## One cannibal crosses right to left. + if new_state.is_valid(): + new_state.parent = cur_state + children.append(new_state) + return children + +def breadth_first_search(): + initial_state = State(3,3,'left',0,0) + if initial_state.is_goal(): + return initial_state + frontier = list() + explored = set() + frontier.append(initial_state) + while frontier: + state = frontier.pop(0) + if state.is_goal(): + return state + explored.add(state) + children = successors(state) + for child in children: + if (child not in explored) or (child not in frontier): + frontier.append(child) + return None + +def print_solution(solution): + path = [] + path.append(solution) + parent = solution.parent + while parent: + path.append(parent) + parent = parent.parent + + for t in range(len(path)): + state = path[len(path) - t - 1] + print "(" + str(state.cannibalLeft) + "," + str(state.missionaryLeft) \ + + "," + state.boat + "," + str(state.cannibalRight) + "," + \ + str(state.missionaryRight) + ")" + +def main(): + solution = breadth_first_search() + print "Missionaries and Cannibals solution:" + print "(cannibalLeft,missionaryLeft,boat,cannibalRight,missionaryRight)" + print_solution(solution) + +# if called from the command line, call main() +if __name__ == "__main__": + main() + From 0c0f842eb01eeafcca89e17c091604756f9701ca Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 19:57:19 +0530 Subject: [PATCH 03/25] Create TASK_8 - BFS --- .../TASK_8 - BFS | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_8 - BFS diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_8 - BFS b/Manasvi Vashishtha-4th yr-Section C/TASK_8 - BFS new file mode 100644 index 0000000..8ef812d --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_8 - BFS @@ -0,0 +1,18 @@ +import collections + +def bfs(graph, root): + seen, queue = set([root]), collections.deque([root]) + while queue: + vertex = queue.popleft() + visit(vertex) + for node in graph[vertex]: + if node not in seen: + seen.add(node) + queue.append(node) + +def visit(n): + print(n) + +if __name__ == '__main__': + graph = {0: [1, 2], 1: [2, 0], 2: []} + bfs(graph, 0) From a1404f663ed9242e3c3ffa17f23cbd80bab0ddc1 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 19:59:08 +0530 Subject: [PATCH 04/25] Create TASK_9 - DFS --- .../TASK_9 - DFS | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_9 - DFS diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_9 - DFS b/Manasvi Vashishtha-4th yr-Section C/TASK_9 - DFS new file mode 100644 index 0000000..147be28 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_9 - DFS @@ -0,0 +1,20 @@ +# DFS algorithm +def dfs(graph, start, visited=None): + if visited is None: + visited = set() + visited.add(start) + + print(start) + + for next in graph[start] - visited: + dfs(graph, next, visited) + return visited + + +graph = {'0': set(['1', '2']), + '1': set(['0', '3', '4']), + '2': set(['0']), + '3': set(['1']), + '4': set(['2', '3'])} + +dfs(graph,'0') From 5542eee51078bec8f8d1a32441cb23a615e4d8b8 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 19:59:50 +0530 Subject: [PATCH 05/25] Create TASK_10 - Depth Limited Search --- .../TASK_10 - Depth Limited Search | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_10 - Depth Limited Search diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_10 - Depth Limited Search b/Manasvi Vashishtha-4th yr-Section C/TASK_10 - Depth Limited Search new file mode 100644 index 0000000..013f136 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_10 - Depth Limited Search @@ -0,0 +1,35 @@ +from collections import defaultdict +class Graph: + def __init__(self,vertices): + self.V = vertices + self.graph = defaultdict(list) + def addEdge(self,u,v): + self.graph[u].append(v) + def DLS(self,src,target,maxDepth): + if src == target : return True + if maxDepth <= 0 : return False + for i in self.graph[src]: + if(self.DLS(i,target,maxDepth-1)): + return True + return False + def IDDFS(self,src, target, maxDepth): + for i in range(maxDepth): + if (self.DLS(src, target, i)): + return True + return False +g = Graph (7); +g.addEdge(0, 1) +g.addEdge(0, 2) +g.addEdge(1, 3) +g.addEdge(1, 4) +g.addEdge(2, 5) +g.addEdge(2, 6) +target = int(input("enter the node to be searched")); +maxDepth = int(input("enter the depth")); +src = 0 +if g.IDDFS(src, target, maxDepth) == True: + print ("Target is reachable from source " + + "within max depth") +else : + print ("Target is NOT reachable from source " + + "within max depth") From 07c05250e207948cf3481031279f680b98476c79 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:00:55 +0530 Subject: [PATCH 06/25] Create TASK_11 - Iterative Deepening Search --- .../TASK_11 - Iterative Deepening Search | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_11 - Iterative Deepening Search diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_11 - Iterative Deepening Search b/Manasvi Vashishtha-4th yr-Section C/TASK_11 - Iterative Deepening Search new file mode 100644 index 0000000..b09d1de --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_11 - Iterative Deepening Search @@ -0,0 +1,46 @@ +from collections import defaultdict + +class Graph: + + def __init__(self,vertices): + + self.V = vertices + self.graph = defaultdict(list) + def addEdge(self,u,v): + self.graph[u].append(v) + + def DLS(self,src,target,maxDepth): + if src == target : return True + if maxDepth <= 0 : return False + + for i in self.graph[src]: + if(self.DLS(i,target,maxDepth-1)): + return True + return False + def IDDFS(self,src, target, maxDepth): + for i in range(maxDepth): + if (self.DLS(src, target, i)): + return True + return False + + +g = Graph (7); +g.addEdge(0, 1) +g.addEdge(0, 2) +g.addEdge(1, 3) +g.addEdge(1, 4) +g.addEdge(2, 5) +g.addEdge(2, 6) + +target = int(input("enter the node to be searched")); +maxDepth = int(input("enter the depth")); +src = 0 +found = 1 +while(found): + if g.IDDFS(src, target, maxDepth) == True: + print ("Target is reachable from source " + + "within max depth : ") + print(maxDepth) + found = 0 + else : + maxDepth = maxDepth +1 From d25c257b02956598f0c727d8936ed0e0d455812d Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:03:38 +0530 Subject: [PATCH 07/25] Create TASK_12 - A* Algorithm --- .../TASK_12 - A* Algorithm | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_12 - A* Algorithm diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_12 - A* Algorithm b/Manasvi Vashishtha-4th yr-Section C/TASK_12 - A* Algorithm new file mode 100644 index 0000000..1bb793c --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_12 - A* Algorithm @@ -0,0 +1,79 @@ +grid = [[0, 1, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0]] + +heuristic = [[9, 8, 7, 6, 5, 4], + [8, 7, 6, 5, 4, 3], + [7, 6, 5, 4, 3, 2], + [6, 5, 4, 3, 2, 1], + [5, 4, 3, 2, 1, 0]] + +init = [0, 0] +goal = [len(grid)-1, len(grid[0])-1] +cost = 1 + +delta = [[-1, 0 ], # go up + [ 0, -1], # go left + [ 1, 0 ], # go down + [ 0, 1 ]] # go right + +delta_name = ['^', '<', 'v', '>'] + +def search(grid,init,goal,cost,heuristic): + # ---------------------------------------- + # modify the code below + # ---------------------------------------- + closed = [[0 for col in range(len(grid[0]))] for row in range(len(grid))] + closed[init[0]][init[1]] = 1 + + expand = [[-1 for col in range(len(grid[0]))] for row in range(len(grid))] + action = [[-1 for col in range(len(grid[0]))] for row in range(len(grid))] + + x = init[0] + y = init[1] + g = 0 + f = g + heuristic[x][y] + + open = [[f, g, x, y]] + + found = False # flag that is set when search is complete + resign = False # flag set if we can't find expand + count = 0 + + while not found and not resign: + if len(open) == 0: + resign = True + return "Fail" + else: + open.sort() + open.reverse() + next = open.pop() + f = next[0] + g = next[1] + x = next[2] + y = next[3] + + expand[x][y] = count + count += 1 + + if x == goal[0] and y == goal[1]: + found = True + else: + for i in range(len(delta)): + x2 = x + delta[i][0] + y2 = y + delta[i][1] + if x2 >= 0 and x2 < len(grid) and y2 >=0 and y2 < len(grid[0]): + if closed[x2][y2] == 0 and grid[x2][y2] == 0: + g2 = g + cost + f = g2 + heuristic[x2][y2] + open.append([f, g2, x2, y2]) + closed[x2][y2] = 1 + + return expand + +result = search(grid,init,goal,cost,heuristic) + +for el in result: + print (el) From b080717011e21b6cb099fc4bb959b2e3dfd03484 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:06:06 +0530 Subject: [PATCH 08/25] Create TASK_13 - AO* Algorithm --- .../TASK_13 - AO* Algorithm | 183 ++++++++++++++++++ 1 file changed, 183 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_13 - AO* Algorithm diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_13 - AO* Algorithm b/Manasvi Vashishtha-4th yr-Section C/TASK_13 - AO* Algorithm new file mode 100644 index 0000000..3d946c7 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_13 - AO* Algorithm @@ -0,0 +1,183 @@ +#include +#include +using namespace std; +struct node +{ + int data; + vector< vector* >v; + bool mark; + bool solved; +}; +int edge_cost=0; +void insert(node* root) +{ + cout<<"Enter data of node :"<>root->data; + //vector >vec=root->v; + cout<<"Enter number of OR nodes for value "<data<<" :"<>or_no; + for(int i=0;i* ans=new vector; + cout<<"Enter number of AND nodes for "<data<<" :"<>and_no; + for(int j=0;jsolved=false; + n->mark=false; + insert(n); + (*ans).push_back(n); + //cout<<"inserted node with value"<data<v.push_back(ans); + } + +} +void aostar(node* root) +{ + vector* min_ans=new vector; + (*min_ans).push_back(root); + while(!root->solved) + { + node* next_node=root; + stackst; + while(next_node && next_node->mark) + { + if((next_node->v).size()==0) + { + root->solved=true; + return; + } + int cost=INT_MAX; + st.push(next_node); + for(unsigned int i=0;iv.size();i++) + { + vector*ans=(next_node->v)[i]; + vector ans_v=*ans; + int temp_cost=0; + for(unsigned int j=0;j<(ans_v.size());j++) + { + node* n=ans_v[j]; + temp_cost+=n->data; + } + if(temp_cost min_ans_v=*min_ans; + next_node=NULL; + for(unsigned int j=0;jmark) + { + next_node=min_ans_v[j]; + break; + } + } + + } + + vector min_ans_v=*min_ans; + for(unsigned int j=0;jdata<v.size()==0) + { + n->mark=true; + } + else{ + for(unsigned int i=0;iv.size();i++) + { + vector*ans=(n->v)[i]; + vector ans_v=*ans; + int temp_cost=0; + for(unsigned int j=0;j<(ans_v.size());j++) + { + node* n=ans_v[j]; + temp_cost+=n->data; + temp_cost+=edge_cost; + } + if(temp_costdata=final_cost; + n->mark=true; + } + cout<<"Marked : "<data<v.size();i++) + { + vector*ans=(n->v)[i]; + vector ans_v=*ans; + int temp_cost=0; + for(unsigned int j=0;j<(ans_v.size());j++) + { + node* n=ans_v[j]; + temp_cost+=n->data; + temp_cost+=edge_cost; + } + if(temp_costdata=final_cost; + } + cout<data<<" "; + vector* >vec=root->v; + for(unsigned int i=0;i<(root->v).size();i++) + { + vector* ans=(root->v)[i]; + vector ans_v=*ans; + for(unsigned int j=0;jsolved=false; + root->mark=false; + insert(root);cout<>edge_cost;cout<data< Date: Sun, 6 Dec 2020 20:08:35 +0530 Subject: [PATCH 09/25] Create TASK_14 - MP Neuron for Logic Gates --- .../TASK_14 - MP Neuron for Logic Gates | 265 ++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_14 - MP Neuron for Logic Gates diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_14 - MP Neuron for Logic Gates b/Manasvi Vashishtha-4th yr-Section C/TASK_14 - MP Neuron for Logic Gates new file mode 100644 index 0000000..1503e94 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_14 - MP Neuron for Logic Gates @@ -0,0 +1,265 @@ +import pandas as pd +from IPython.display import display, HTML, clear_output +from tkinter import * +import turtle +import webbrowser +from tempfile import NamedTemporaryFile +#import dfgui + +global gate_sel +import time + + +def df_window(df): + with NamedTemporaryFile(delete=False, suffix='.html') as f: + df.to_html(f) + webbrowser.open(f.name) + + + +def make_truth_table(w1,w2,th): + + t = pd.DataFrame(index = None) + + t['Input 1']=[0,0,1,1] + t['Input 2']=[0,1,0,1] + t['Response']=[1 if 0*w1+0*w2>=th else 0,1 if 0*w1+1*w2>=th else 0,1 if 1*w1+0*w2>=th else 0,1 if 1*w1+1*w2>=th else 0] + + print(t) + #dfgui.shw(t) + #df_window(t) + #display(HTML(t.to_html())) + +def get_output(w1,w2,x1,x2,th): + if w1*x1 + w2*x2 >= th: + return 1 + else : + return 0 + +def get_weights(): + + root = Tk() + root.title('Pick Weights') + root.geometry("500x250") #You want the size of the app to be 500x500 + #root.resizable(1500, 1500) + root.option_add("*Label.Font", "courier 24 bold") + Label(root, text = "Enter Weight 1").grid(row = 0, sticky = W) + Label(root, text = "Enter Weight 2").grid(row = 1, sticky = W) + Label(root, text = "Enter Threshold").grid(row = 2, sticky = W) + # Label(root, text = "Childs Year of Birth").grid(row = 2, sticky = W) + # Label(root, text = "Childs Month of Birth").grid(row = 3, sticky = W) + # Label(root, text = "Childs Day of Birth").grid(row = 4, sticky = W) + + wt1 = Entry(root) + wt2 = Entry(root) + thr = Entry(root) + + wt1.grid(row = 0, column = 1) + wt2.grid(row = 1, column = 1) + thr.grid(row = 2, column = 1) + + def getInput(): + + a = wt1.get() + b = wt2.get() + c = thr.get() + root.destroy() + + global weights + weights = [a,b,c] + + + Button(root, text = "Submit", + command = getInput).grid(row = 5, sticky = W) + mainloop() + + + +def set_val(v): + gate_sel=v + +def draw_network(w1,w2,th,x1,x2,gate,close=False): + + output = get_output(w1,w2,x1,x2,th) + + screen=turtle.Screen() + turtle.TurtleScreen._RUNNING = True + trtl = turtle.Turtle() + screen.reset() #making a turtle object of Turtle class for drawing + #making a canvas for drawing + screen.setup(520,420) #choosing the screen size + screen.bgcolor('white') #making canvas black + trtl.pencolor('black') #making colour of the pen red + + trtl.pensize(4) #choosing the size of pen nib + trtl.speed(1) #choosing the speed of drawing + trtl.shape('turtle') #choosing the shape of pen nib + trtl.hideturtle() + + trtl.penup() + trtl.goto(-100,150) + trtl.pendown() + trtl.write("{0} GATE".format(gate), font=("Arial", 24, "bold")) + + trtl.penup() + trtl.goto(-150,90) + trtl.pendown() + trtl.forward(120) #top line + trtl.penup() + + + trtl.goto(-130,110) + trtl.pendown() + trtl.write("w1 = {0}".format(w1), font=("Arial", 16, "normal")) + trtl.penup() #moving the pen up + + trtl.goto(-150,50) + trtl.pendown() + trtl.forward(120) #top line + trtl.penup() #moving the pen down + + trtl.goto(-130,20) + trtl.pendown() + trtl.write("w2 = {0}".format(w2), font=("Arial", 16, "normal")) + + trtl.penup() + trtl.goto(-220,80) + trtl.pendown() + trtl.write("x1 = {0}".format(x1), font=("Arial", 16, "normal")) + trtl.penup() + trtl.goto(-220,40) + trtl.pendown() + trtl.write("x2 = {0}".format(x2), font=("Arial", 16, "normal")) + + + if output == 1: + trtl.fillcolor("green") + else: + trtl.fillcolor("red") + + trtl.penup() + trtl.goto(5,-20) + trtl.pendown() + trtl.write("\u03F4 = {0}".format(th), font=("Arial", 16, "normal")) + trtl.penup() #moving the pen up + trtl.begin_fill() + trtl.penup() #moving the pen up + trtl.goto(30,10) + trtl.pendown() + trtl.circle(60) #drawing circle with radius 60 pixels + trtl.end_fill() + + + trtl.penup() #moving the pen down + + trtl.goto(90,70) + trtl.pendown() + trtl.forward(120) + + trtl.penup() + trtl.goto(110,90) + trtl.pendown() + trtl.write("output={0}".format(output), font=("Arial", 16, "normal")) + + time.sleep(3) + + #turtle.bye() + + screen.clear() + #screen.mainloop() + + if(close): + screen.bye() + + +onceMore = True +while(onceMore==True): + #clear_output() + + master = Tk() + var = IntVar() + var.set(1) + + def quit_loop(): + #print("Selection:",var.get()) + global selection + selection = var.get() + master.destroy() + + def quit_loop_2(): + #print("Selection:",var.get()) + global selection2 + selection2 = var1.get() + nextOne.destroy() + + master.title("CHOOSE AN OPTION") + master.geometry("500x250") + master.option_add("*Label.Font", "courier 24 bold") + Label(master, text = "CHOOSE A GATE TO IMPLEMENT:").grid(row=0, sticky=W) + Radiobutton(master, text = "AND", font="courier 24 bold",variable=var, value = 1).grid(row=1, sticky=W) + Radiobutton(master, text = "OR", font="courier 24 bold", variable=var, value = 2).grid(row=2, sticky=W) + Radiobutton(master, text = "AND-NOT", font="courier 24 bold", variable=var, value = 3).grid(row=3, sticky=W) + Radiobutton(master, text = "CUSTOM", font="courier 24 bold", variable=var, value = 4).grid(row=4, sticky=W) + Button(master, text = "SUBMIT", font="courier 24 bold", command=quit_loop).grid(row=5, sticky=W) + #Button(master, text = "OK", command=quit_loop).grid(row=5, sticky=W) + #button = Button(master, text="Okay", command=master.destroy) + #button.pack() + master.mainloop() + + if selection == 1: + #print ("My Value is equal to one.") + gate_sel=1 + print("AND Gate") + draw_network(1,1,2,0,0,'AND') + draw_network(1,1,2,0,1,'AND') + draw_network(1,1,2,1,0,'AND') + draw_network(1,1,2,1,1,'AND',close=True) + make_truth_table(1,1,2) + elif selection == 2: + gate_sel=2 + print("OR Gate") + draw_network(2,2,2,0,0,'OR') + draw_network(2,2,2,0,1,'OR') + draw_network(2,2,2,1,0,'OR') + draw_network(2,2,2,1,1,'OR',close=True) + make_truth_table(2,2,2) + #print ("My value is equal to two.") + elif selection == 3: + gate_sel=3 + print("AND-NOT Gate") + draw_network(2,-1,2,0,0,'AND-NOT') + draw_network(2,-1,2,0,1,'AND-NOT') + draw_network(2,-1,2,1,0,'AND-NOT') + draw_network(2,-1,2,1,1,'AND-NOT',close=True) + make_truth_table(2,-1,2) + elif selection == 4: + gate_sel=4 + get_weights() + weights=[int(x) for x in weights] + print("CUSTOM Gate") + draw_network(weights[0],weights[1],weights[2],0,0,'CUSTOM') + draw_network(weights[0],weights[1],weights[2],0,1,'CUSTOM') + draw_network(weights[0],weights[1],weights[2],1,0,'CUSTOM') + draw_network(weights[0],weights[1],weights[2],1,1,'CUSTOM',close=True) + make_truth_table(weights[0],weights[1],weights[2]) + + + + nextOne = Tk() + var1 = IntVar() + var1.set(1) + nextOne.title("Would you like to try again?") + nextOne.geometry("500x250") + nextOne.option_add("*Label.Font", "courier 24 bold") + + Radiobutton(nextOne, text = "YES", font="courier 24 bold", variable=var1, value = 1).grid(row=1, sticky=W) + Radiobutton(nextOne, text = "NO", font="courier 24 bold", variable=var1, value = 2).grid(row=2, sticky=W) + Button(nextOne, text = "SUBMIT", command=quit_loop_2).grid(row=3, sticky=W) + nextOne.mainloop() + + if(selection2==1): + print("\n") + onceMore=True + else: + print("\nHope you liked this :)") + onceMore=False From 627df6251cd45c8da45ef9f4c9bd8176bc6149bc Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:10:00 +0530 Subject: [PATCH 10/25] Create TASK_15 - Single Layer Perceptron for AND --- .../TASK_15 - Single Layer Perceptron for AND | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_15 - Single Layer Perceptron for AND diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_15 - Single Layer Perceptron for AND b/Manasvi Vashishtha-4th yr-Section C/TASK_15 - Single Layer Perceptron for AND new file mode 100644 index 0000000..69b7b7a --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_15 - Single Layer Perceptron for AND @@ -0,0 +1,44 @@ +import numpy as np +x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]]) +t=np.array([[1],[1],[1],[-1]]) +w=np.array([[0],[0]]) +b=0 +theta=float(input("Enter new theta:")) +alpha=float(input("Enter new alpha:")) +yin=np.zeros(shape=(4,1)) +y=np.zeros(shape=(4,1)) +i=0 +found=0 +while(found==0): + yin=x[i][0]*w[0]+x[i][1]*w[1] + yin = yin+b + if(yin>theta): + y[i] = 1 + elif(yin<=theta and yin>=-theta): + y[i]=0 + else: + y[i]=-1 + if (y[i]==t[i]): + print("NO UPDATION REQUIRED") + print(y[i]) + if(i<3): + i=i+1 + else: + i=0 + else: + print("MODEL IS NOT TRAINED") + print("The value of output is") + print(y) + w[0]=w[0]+alpha*x[i][0]*t[i] + w[1]=w[1]+alpha*x[i][1]*t[i] + b = b+alpha*t[i] + if(i<3): + i=i+1 + else: + i=0 + if(y==t).all(): + found=1 +print("The final weight matrix is:") +print(w) +print("The final output is:") +print(y) From dcf9bf1f8b17b07ffa7dfd1e59095329931963e5 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:10:41 +0530 Subject: [PATCH 11/25] Create TASK_16 - Single Layer Perceptron for AND-NOT --- ...K_16 - Single Layer Perceptron for AND-NOT | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_16 - Single Layer Perceptron for AND-NOT diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_16 - Single Layer Perceptron for AND-NOT b/Manasvi Vashishtha-4th yr-Section C/TASK_16 - Single Layer Perceptron for AND-NOT new file mode 100644 index 0000000..3465a6b --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_16 - Single Layer Perceptron for AND-NOT @@ -0,0 +1,44 @@ +import numpy as np +x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]]) +t=np.array([[-1],[1],[-1],[-1]]) +w=np.array([[0],[0]]) +b=0 +theta=float(input("Enter new theta:")) +alpha=float(input("Enter new alpha:")) +yin=np.zeros(shape=(4,1)) +y=np.zeros(shape=(4,1)) +i=0 +found=0 +while(found==0): + yin=x[i][0]*w[0]+x[i][1]*w[1] + yin = yin+b + if(yin>theta): + y[i] = 1 + elif(yin<=theta and yin>=-theta): + y[i]=0 + else: + y[i]=-1 + if (y[i]==t[i]): + print("NO UPDATION REQUIRED") + print(y[i]) + if(i<3): + i=i+1 + else: + i=0 + else: + print("MODEL IS NOT TRAINED") + print("The value of output is") + print(y) + w[0]=w[0]+alpha*x[i][0]*t[i] + w[1]=w[1]+alpha*x[i][1]*t[i] + b = b+alpha*t[i] + if(i<3): + i=i+1 + else: + i=0 + if(y==t).all(): + found=1 +print("The final weight matrix is ") +print(w) +print("The final output is:") +print(y) From 11dea73c25aa2817c4c62b5e69b8848c42fb45f0 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:21:41 +0530 Subject: [PATCH 12/25] Add files via upload --- ...ing of Various Activation Functions .ipynb | 334 ++++++++++++++++++ 1 file changed, 334 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_17 - Plotting of Various Activation Functions .ipynb diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_17 - Plotting of Various Activation Functions .ipynb b/Manasvi Vashishtha-4th yr-Section C/TASK_17 - Plotting of Various Activation Functions .ipynb new file mode 100644 index 0000000..dabc81e --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_17 - Plotting of Various Activation Functions .ipynb @@ -0,0 +1,334 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled6.ipynb", + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "xCqt9RSLgZSs" + }, + "source": [ + "## TASK_17 - Plotting various Activation Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "z7Mq4kwdgl9T" + }, + "source": [ + "### 1. y={1 x<10 0 else " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + }, + "id": "VjK9KtvngsCh", + "outputId": "c041e1dc-6e5d-48c7-b9d0-b2b0b7d1258d" + }, + "source": [ + "import matplotlib.pyplot as plt \n", + "x=[num for num in range(0,20)]\n", + "y=[]\n", + "for i in x:\n", + " if i>=10:\n", + " y.append(1)\n", + " else:\n", + " y.append(0)\n", + "plt.plot(x,y)\n", + "plt.xlabel(\"x axis\")\n", + "plt.ylabel(\"y axis\")\n", + "plt.title(\"y=1 if x>=10 else y=0\")\n", + "plt.show()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4HQ6u5JcgwsP" + }, + "source": [ + "### 2. .y=eaxfor different values of a." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + }, + "id": "EHwLZwMqgyam", + "outputId": "5db1ecfb-e5a7-4645-958e-5a1132d03582" + }, + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "num=[num for num in range(0,10)]\n", + "a=2 #constant value\n", + "x=np.array(num)*2\n", + "y=np.exp(x)\n", + "plt.plot(x,y)\n", + "plt.xlabel(\"x axis\")\n", + "plt.ylabel(\"y axis\")\n", + "plt.title(\"y=e**ax\")\n", + "plt.show()" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AfXAZbvnhA-r" + }, + "source": [ + "### 3.y=7x2+3x+10 for 2x5" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + }, + "id": "fdWNKou6hCt2", + "outputId": "a798edf6-bc3e-46fc-bde6-71c8c0bc8078" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "x=[x for x in range(2,6)]\n", + "y=[]\n", + "for i in x:\n", + " y.append(7*pow(i,2)+3*i+10)\n", + "plt.plot(x,y)\n", + "plt.xlabel('x axis')\n", + "plt.ylabel('y axis')\n", + "plt.title('y=7x^2+3x+10')\n", + "plt.show()" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9eydFb2FhHuD" + }, + "source": [ + "### 4.y=11+e-x" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "id": "B_9j_hzWhKEs", + "outputId": "3733e7f0-163b-4803-84e2-67b5d4cfd37e" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "x=[x for x in range(0,20)]\n", + "p=np.array(x)\n", + "p=1+np.exp(-p)\n", + "y=1/p\n", + "plt.plot(x,y)\n", + "plt.xlabel('x axis')\n", + "plt.ylabel('y axis')\n", + "plt.show()" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nf2mCQQohQdr" + }, + "source": [ + "### 5. y=1-e-ax1+e-axfor different values of a." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "id": "Kn-0HqC8hSsO", + "outputId": "1ea6bc65-1c9e-4b7e-a6ef-90fdd4a32abb" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "num=[num for num in range(0,21)]\n", + "num=np.array(num)\n", + "a=2\n", + "p=1-np.exp(-num*a)\n", + "q=1+np.exp(-num*a)\n", + "y=p/q\n", + "plt.plot(num,y)\n", + "plt.xlabel('x axis')\n", + "plt.ylabel('y axis')\n", + "plt.show()" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uX1yuPYnhWs_" + }, + "source": [ + "### 6. y=tan hx " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 397 + }, + "id": "q6J2KchfhYs2", + "outputId": "72141c1b-d3d3-4f7f-c556-3545b6d7b546" + }, + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "in_array = np.linspace(0, np.pi, 12)\n", + "h=2\n", + "out_array =h*np.tan(in_array)\n", + "print(\"in_array : \", in_array)\n", + "print(\"\\nout_array : \",out_array)\n", + "# red for numpy.tan()\n", + "plt.plot(in_array, out_array, color='red', marker=\"o\")\n", + "plt.title(\"numpy.tan()\")\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.show()" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "text": [ + "in_array : [0. 0.28559933 0.57119866 0.856798 1.14239733 1.42799666\n", + " 1.71359599 1.99919533 2.28479466 2.57039399 2.85599332 3.14159265]\n", + "\n", + "out_array : [ 0.00000000e+00 5.87252986e-01 1.28532195e+00 2.30812304e+00\n", + " 4.37938913e+00 1.39103055e+01 -1.39103055e+01 -4.37938913e+00\n", + " -2.30812304e+00 -1.28532195e+00 -5.87252986e-01 -2.44929360e-16]\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file From f358f1c07627251844d1942fe6dc08cdba34ebf6 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:22:49 +0530 Subject: [PATCH 13/25] Create TASK_18 - Linear Separability AND --- .../TASK_18 - Linear Separability AND | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_18 - Linear Separability AND diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_18 - Linear Separability AND b/Manasvi Vashishtha-4th yr-Section C/TASK_18 - Linear Separability AND new file mode 100644 index 0000000..71679a9 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_18 - Linear Separability AND @@ -0,0 +1,13 @@ +import numpy as np +import matplotlib as plt +x = np.array([0,1,0]) +y = np.array([0,0,1]) +plt.pyplot.scatter(x,y,c='red') +plt.pyplot.scatter(1,1,c="blue") +plt.pyplot.xlabel('Input 1') +plt.pyplot.ylabel('Input 2') +w=-1 +b=1.5 +x = np.linspace(0,1.5) +plt.pyplot.plot(x,w*x+b,c='black') +plt.pyplot.show() From 34989f124698bd00124a296579b7274ce5d79e8c Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:24:06 +0530 Subject: [PATCH 14/25] Create TASK_19 - Linear Separability OR --- .../TASK_19 - Linear Separability OR | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_19 - Linear Separability OR diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_19 - Linear Separability OR b/Manasvi Vashishtha-4th yr-Section C/TASK_19 - Linear Separability OR new file mode 100644 index 0000000..1031073 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_19 - Linear Separability OR @@ -0,0 +1,15 @@ +import numpy as np +import matplotlib as plt +x = np.array([0,1]) +y = np.array([0,1]) +plt.pyplot.scatter(x,y,c='red') +x = np.array([1,0]) +y = np.array([0,1]) +plt.pyplot.scatter(x,y,c="blue") +plt.pyplot.xlabel('Input 1') +plt.pyplot.ylabel('Input 2') +w=-1 +b=1.5 +x = np.linspace(0,1.5) +plt.pyplot.plot(x,w*x+b,c='black') +plt.pyplot.show() From 65e3d2a1239502e4055efeced23d8d5e91b2b96b Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:25:12 +0530 Subject: [PATCH 15/25] Create TASK_20 - Adaline Algorithm --- .../TASK_20 - Adaline Algorithm | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_20 - Adaline Algorithm diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_20 - Adaline Algorithm b/Manasvi Vashishtha-4th yr-Section C/TASK_20 - Adaline Algorithm new file mode 100644 index 0000000..d744d18 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_20 - Adaline Algorithm @@ -0,0 +1,51 @@ +importnumpy as np +x1=np.array([[1,1,-1,-1]]) +x2=np.array([[1,-1,1,-1]]) +t=np.array([[1],[1],[1],[-1]]) +w11=0.1 +w21=0.1 +w01=0.1 +alpha=0.1 +i=0 +bias=1 +w1=np.zeros((4,1)) +w2=np.zeros((4,1)) +w0=np.zeros((4,1)) +Yin=np.zeros((4,1)) +y=np.zeros((4,1)) +error=np.zeros((4,1)) +count=0 +while(count!=3): + i=0 +if(count!=0): + w11=w1[3] + w21=w2[3] + w01=w0[3] +while(i!=4): +if(i==0): + Yin[i]= (x1[0][i]*w11)+(x2[0][i]*w21)+(bias*w01) +y[i]=t[i][0]-Yin[i] +w1[i]=w11+(alpha*y[i]*x1[0][i]) +w2[i]=w21+(alpha*y[i]*x2[0][i]) +w0[i]=w01+(alpha*y[i]*bias) +else: +if(i>0 & i<=4): + Yin[i]= (x1[0][i]*w1[i-1])+(x2[0][i]*w2[i-1])+(bias*w0[i-1]) +y[i]=t[i][0]-Yin[i] +w1[i]=w1[i-1]+(alpha*y[i]*x1[0][i]) +w2[i]=w2[i-1]+(alpha*y[i]*x2[0][i]) +w0[i]=w0[i-1]+(alpha*y[i]*bias) + +error[i]=(y[i])**2 + i=i+1 +print('EPOCH',(count+1),':') +print('\n') +print('w1:',w1) +print('\n') +print('w2:',w2) +print('\n') +print('w0:',w0) +print('\n') +print('error',error) +print('\n\n') +count=count+1 From a053ce05c845f30fd19a1d7e7ce3d55583cb5b3e Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:27:37 +0530 Subject: [PATCH 16/25] Create TASK_21 - --- Manasvi Vashishtha-4th yr-Section C/TASK_21 - | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_21 - diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_21 - b/Manasvi Vashishtha-4th yr-Section C/TASK_21 - new file mode 100644 index 0000000..36b535c --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_21 - @@ -0,0 +1,45 @@ +import numpy as np +x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]]) +t=np.array([[1],[1],[1],[-1]]) +w=np.array([[0],[0]]) +b=0 +theta=float(input("enter new theta")) +alpha=float(input("enter new alpha")) +yin=np.zeros(shape=(4,1)) +y=np.zeros(shape=(4,1)) +i=0 +found=0 +while(found==0): + yin=x[i][0]*w[0]+x[i][1]*w[1] + yin = yin+b + if(yin>theta): + y[i] = 1 + elif(yin<=theta and yin>=-theta): + y[i]=0 + else: + y[i]=-1 + if (y[i]==t[i]): + print("NO UPDATION REQUIRED") + print(y[i]) + if(i<3): + i=i+1 + else: + i=0 + else: + print("MODEL IS NOT TRAINED") + print("The value of output is") + print(y) + + w[0]=w[0]+alpha*x[i][0]*t[i] + w[1]=w[1]+alpha*x[i][1]*t[i] + b = b+alpha*t[i] + if(i<3): + i=i+1 + else: + i=0 + if(y==t).all(): + found=1 +print("The final weight matrix is ") +print(w) +print("The final output is:") +print(y) From 89ad1c98389438ff19a8cc41ed65ccbb2c2782c7 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:28:26 +0530 Subject: [PATCH 17/25] Rename TASK_21 - to TASK_21 - Madaline Neural Network --- .../{TASK_21 - => TASK_21 - Madaline Neural Network} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Manasvi Vashishtha-4th yr-Section C/{TASK_21 - => TASK_21 - Madaline Neural Network} (100%) diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_21 - b/Manasvi Vashishtha-4th yr-Section C/TASK_21 - Madaline Neural Network similarity index 100% rename from Manasvi Vashishtha-4th yr-Section C/TASK_21 - rename to Manasvi Vashishtha-4th yr-Section C/TASK_21 - Madaline Neural Network From 7bccd2d9aae236ef32f80da3f7bcaf6428ff19f3 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:29:28 +0530 Subject: [PATCH 18/25] Create TASK_22 - Back Propagation --- .../TASK_22 - Back Propagation | 109 ++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_22 - Back Propagation diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_22 - Back Propagation b/Manasvi Vashishtha-4th yr-Section C/TASK_22 - Back Propagation new file mode 100644 index 0000000..f337d6c --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_22 - Back Propagation @@ -0,0 +1,109 @@ +import math +import random +import string +class NN: +def __init__(self, NI, NH, NO): + # number of nodes in layers + self.ni = NI + 1 # +1 for bias +self.nh = NH + self.no = NO + self.ai, self.ah, self.ao = [],[], [] + self.ai = [1.0]*self.ni +self.ah = [1.0]*self.nh + self.ao = [1.0]*self.no +self.wi = makeMatrix (self.ni, self.nh) +self.wo = makeMatrix (self.nh, self.no) + # initialize node weights to random vals +randomizeMatrix ( self.wi, -0.2, 0.2 ) +randomizeMatrix ( self.wo, -2.0, 2.0 ) + self.ci = makeMatrix (self.ni, self.nh) + self.co = makeMatrix (self.nh, self.no) + +defrunNN (self, inputs): +iflen(inputs) != self.ni-1: +print('incorrect number of inputs') +for i in range(self.ni-1): + self.ai[i] = inputs[i] +for j in range(self.nh): +sum = 0.0 +for i in range(self.ni): +sum +=( self.ai[i] * self.wi[i][j] ) +self.ah[j] = sigmoid (sum) +for k in range(self.no): +sum = 0.0 +for j in range(self.nh): +sum +=( self.ah[j] * self.wo[j][k] ) + self.ao[k] = sigmoid (sum) +return self.ao +defbackPropagate (self, targets, N, M): +output_deltas = [0.0] * self.no +for k in range(self.no): +error = targets[k] - self.ao[k] +output_deltas[k] = error * dsigmoid(self.ao[k]) +for j in range(self.nh): +for k in range(self.no): +change = output_deltas[k] * self.ah[j] +self.wo[j][k] += N*change + M*self.co[j][k] + self.co[j][k] = change +hidden_deltas = [0.0] * self.nh +for j in range(self.nh): +error = 0.0 +for k in range(self.no): +error += output_deltas[k] * self.wo[j][k] +hidden_deltas[j] = error * dsigmoid(self.ah[j]) +for i in range (self.ni): +for j in range (self.nh): +change= hidden_deltas[j] * self.ai[i] +self.wi[i][j] += N*change + M*self.ci[i][j] + self.ci[i][j] = change +error = 0.0 +for k in range(len(targets)): +error = 0.5 * (targets[k]-self.ao[k])**2 +return error +def weights(self): +print('Input weights:') +for i in range(self.ni): +print (self.wi[i]) +print() +print('Output weights:') +for j in range(self.nh): +print (self.wo[j]) +print ('') +def test(self, patterns): +for p in patterns: +inputs = p[0] +print('Inputs:', p[0], '-->', self.runNN(inputs), '\tTarget', p[1]) +def train (self, patterns, max_iterations = 1000, N=0.5, M=0.1): +for i in range(max_iterations): +for p in patterns: +inputs = p[0] +targets = p[1] +self.runNN(inputs) +error = self.backPropagate(targets, N, M) +if i % 50 == 0: +print('Combined error', error) +self.test(patterns) +def sigmoid (x): +returnmath.tanh(x) +defdsigmoid (y): +return 1 - y**2 +defmakeMatrix ( I, J, fill=0.0): + m = [] +for i in range(I): +m.append([fill]*J) +return m +defrandomizeMatrix ( matrix, a, b): +for i in range ( len (matrix) ): +for j in range ( len (matrix[0]) ): +matrix[i][j] = random.uniform(a,b) +def main (): +pat = [ + [[0,0], [1]], + [[0,1], [1]], + [[1,0], [1]], + [[1,1], [0]] + ] +myNN = NN ( 2, 2, 1) +myNN.train(pat) +if __name__ == "__main__": +main() From bcb6fd1ac26e1116aa16791c7d37e8aaf7a79132 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:33:44 +0530 Subject: [PATCH 19/25] Create TASK_23 - Bidirectional Association Memory Network --- ...- Bidirectional Association Memory Network | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_23 - Bidirectional Association Memory Network diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_23 - Bidirectional Association Memory Network b/Manasvi Vashishtha-4th yr-Section C/TASK_23 - Bidirectional Association Memory Network new file mode 100644 index 0000000..ef7a089 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_23 - Bidirectional Association Memory Network @@ -0,0 +1,79 @@ +class BAM(object): + def __init__(self, data): + self.AB = [] + # store associations in bipolar form to the array + for item in data: + self.AB.append( + [self.__l_make_bipolar(item[0]), + self.__l_make_bipolar(item[1])] + ) + self.len_x = len(self.AB[0][1]) + self.len_y = len(self.AB[0][0]) + # create empty BAM matrix + self.M = [[0 for x in range(self.len_x)] for x in range(self.len_y)] + # compute BAM matrix from associations + self.__create_bam() + + def __create_bam(self): + '''Bidirectional associative memory''' + for assoc_pair in self.AB: + X = assoc_pair[0] + Y = assoc_pair[1] + # calculate M + for idx, xi in enumerate(X): + for idy, yi in enumerate(Y): + self.M[idx][idy] += xi * yi + + def get_assoc(self, A): + '''Return association for input vector A''' + A = self.__mult_mat_vec(A) + return self.__threshold(A) + + def get_bam_matrix(self): + '''Return BAM matrix''' + return self.M + + def __mult_mat_vec(self, vec): + '''Multiply imput vector with BAM matrix''' + v_res = [0] * self.len_x + for x in range(self.len_x): + for y in range(self.len_y): + v_res[x] += vec[y] * self.M[y][x] + return v_res + + def __threshold(self, vec): + '''Transform vector to [0, 1]''' + ret_vec = [] + for i in vec: + if i < 0: + ret_vec.append(0) + else: + ret_vec.append(1) + return ret_vec + + def __l_make_bipolar(self, vec): + '''Transform vector to bipolar form [-1, 1]''' + ret_vec = [] + for item in vec: + if item == 0: + ret_vec.append(-1) + else: + ret_vec.append(1) + return ret_vec + + + +if __name__ == "__main__": + data_pairs = [ + [[1, 0, 1, 0, 1, 0], [1, 1, 0, 0]], + [[1, 1, 1, 0, 0, 0], [1, 0, 1, 0]] + ] + b = BAM(data_pairs) + + import pprint + pp = pprint.PrettyPrinter(indent=4) + print 'Matrix: ' + pp.pprint(b.get_bam_matrix()) + print '\n' + print '[1, 0, 1, 0, 1, 0] ---> ', b.get_assoc([1, 0, 1, 0, 1, 0]) + print '[1, 1, 1, 0, 0, 0] ---> ', b.get_assoc([1, 1, 1, 0, 0, 0]) From 2a4069b68089846265fc8d9a7f628c70fada334f Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:34:27 +0530 Subject: [PATCH 20/25] Create TASK_24 - Hopfield Network --- .../TASK_24 - Hopfield Network | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_24 - Hopfield Network diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_24 - Hopfield Network b/Manasvi Vashishtha-4th yr-Section C/TASK_24 - Hopfield Network new file mode 100644 index 0000000..4dd8f23 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_24 - Hopfield Network @@ -0,0 +1,71 @@ +importnumpy as np +x=np.array([[1,1,1,1,1],[1,-1,-1,1,-1],[-1,1,-1,-1,-1]]) +x1=np.transpose(x) +t1=np.array([[1,1,1,-1,1]]) +t2=np.array([[1,-1,-1,-1,-1]]) +t3=np.array([[1,1,-1,-1,-1]]) +w=np.zeros((5,5)) +i=0 +j=0 +k=0 +for i in range(len(x1)): +for j in range(len(x[0])): +for k in range(len(x)): +w[i][j] += x1[i][k] * x[k][j] +print('Weight Matrix:\n') +for r in w: +print(r) +print('\n\nWeight Matrix with no self connection:\n') +i=0 +j=0 +for i in range(int(5)): +for j in range(int(5)): +if(i==j): +w[i][j]=0 +for r in w: +print(r) +E1=0 +E2=0 +E3=0 +x11= x[0].reshape(5,1) +x12=x[1].reshape(5,1) +x13=x[2].reshape(5,1) +E1= -0.5 * np.matmul(x[0],np.matmul(w,x11)) +print('\n\nEnergy Calculations for pattern [1,1,1,1,1]:',E1) + +E2= -0.5 * np.matmul(x[1],np.matmul(w,x12)) +print('\n\nEnergy Calculations for pattern [1,-1,-1,1,-1]:',E2) + +E3= -0.5 * np.matmul(x[2],np.matmul(w,x13)) +print('\n\nEnergy Calculations for pattern [-1,1,-1,1,-1]:',E3) + +print('\n\nTESTING PHASE') +w_dash=np.transpose(w) +Yin1=t1[0][3]+ np.matmul(x[0],w_dash[3]) +if(Yin1>0): +t1[0][3]=1 +else: +t1[0][3]=-1 +if((t1==x).any()): +print('\nPattern [1,1,1,-1,1] Recognized ') +else: +print('\nPattern [1,1,1,-1,1] not Recognized ') +Yin2=t2[0][3]+ np.matmul(x[1],w_dash[3]) +if(Yin2>0): +t2[0][3]=1 +else: +t2[0][3]=-1 +if((t2==x).any()): +print('\nPattern [1,-1,-1,-1,-1] Recognized ') +else: +print('\nPattern [1,-1,-1,-1,-1] not Recognized ') +Yin3=t3[0][0]+ np.matmul(x[2],w_dash[0]) +if(Yin3>0): +t3[0][0]=1 +else: +t3[0][0]=-1 +if((t3==x).any()): +print('\nPattern [1,1,-1,-1,-1] Recognized ') +else: +print('\nPattern [1,1,-1,-1,-1] not Recognized ') + From 4188141cf28b09e8f2dd6b5ed46064c22207fd96 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:46:46 +0530 Subject: [PATCH 21/25] Create TASK_25 - Fuzzy Set Operations --- .../TASK_25 - Fuzzy Set Operations | 105 ++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_25 - Fuzzy Set Operations diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_25 - Fuzzy Set Operations b/Manasvi Vashishtha-4th yr-Section C/TASK_25 - Fuzzy Set Operations new file mode 100644 index 0000000..2e44f01 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_25 - Fuzzy Set Operations @@ -0,0 +1,105 @@ +import numpy as np + + +class FuzzySet: + def __init__(self, iterable: any): + self.f_set = set(iterable) + self.f_list = list(iterable) + self.f_len = len(iterable) + for elem in self.f_set: + if not isinstance(elem, tuple): + raise TypeError("No tuples in the fuzzy set") + if not isinstance(elem[1], float): + raise ValueError("Probabilities not assigned to elements") + + def __or__(self, other): + # fuzzy set union + if len(self.f_set) != len(other.f_set): + raise ValueError("Length of the sets is different") + f_set = [x for x in self.f_set] + other = [x for x in other.f_set] + return FuzzySet([f_set[i] if f_set[i][1] > other[i][1] else other[i] for i in range(len(self))]) + + def __and__(self, other): + # fuzzy set intersection + if len(self.f_set) != len(other.f_set): + raise ValueError("Length of the sets is different") + f_set = [x for x in self.f_set] + other = [x for x in other.f_set] + + return FuzzySet([f_set[i] if f_set[i][1] < other[i][1] else other[i] for i in range(len(self))]) + + def __invert__(self): + f_set = [x for x in self.f_set] + for indx, elem in enumerate(f_set): + f_set[indx] = (elem[0], float(round(1 - elem[1], 2))) + return FuzzySet(f_set) + + def __sub__(self, other): + if len(self) != len(other): + raise ValueError("Length of the sets is different") + return self & ~other + + def __mul__(self, other): + if len(self) != len(other): + raise ValueError("Length of the sets is different") + return FuzzySet([(self[i][0], self[i][1] * other[i][1]) for i in range(len(self))]) + + def __mod__(self, other): + # cartesian product + print(f'The size of the relation will be: {len(self)}x{len(other)} ') + mx = self + mi = other + tmp = [[] for i in range(len(mx))] + i = 0 + for x in mx: + for y in mi: + tmp[i].append(min(x[1], y[1])) + i += 1 + return np.array(tmp) + + @staticmethod + def max_min(array1: np.ndarray, array2: np.ndarray): + tmp = np.zeros((array1.shape[0], array2.shape[1])) + t = list() + for i in range(len(array1)): + for j in range(len(array2[0])): + for k in range(len(array2)): + t.append(round(min(array1[i][k], array2[k][j]), 2)) + tmp[i][j] = max(t) + t.clear() + return tmp + + def __len__(self): + self.f_len = sum([1 for i in self.f_set]) + return self.f_len + + def __str__(self): + return f'{[x for x in self.f_set]}' + + def __getitem__(self, item): + return self.f_list[item] + + def __iter__(self): + for i in range(len(self)): + yield self[i] + + +a = FuzzySet({('x1', 0.5), ('x2', 0.7), ('x3', 0.0)}) +b = FuzzySet({('x1', 0.8), ('x2', 0.2), ('x3', 1.0)}) +c = FuzzySet({('x', 0.3), ('y', 0.3), ('z', 0.5)}) +x = FuzzySet({('a', 0.5), ('b', 0.3), ('c', 0.7)}) +y = FuzzySet({('a', 0.6), ('b', 0.4)}) +print(f'a -> {a}') +print(f'b -> {b}') +print(f'Fuzzy union: \n{a | b}') +print(f'Fuzzy intersection: \n{a & b}') +print(f'Fuzzy inversion of b: \n{~b}') +print(f"Fuzzy inversion of a: \n {~a}") +print(f'Fuzzy Subtraction: \n{a - b}') + +r = np.array([[0.6, 0.6, 0.8, 0.9], [0.1, 0.2, 0.9, 0.8], [0.9, 0.3, 0.4, 0.8], [0.9, 0.8, 0.1, 0.2]]) +s = np.array([[0.1, 0.2, 0.7, 0.9], [1.0, 1.0, 0.4, 0.6], [0.0, 0.0, 0.5, 0.9], [0.9, 1.0, 0.8, 0.2]]) +print(f"Max Min: of \n{r} \nand \n{s}\n:\n\n") + +print(FuzzySet.max_min(r, s)) From 0aede52768332be5e43b28d339f8d4adfcb7ba44 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 20:55:42 +0530 Subject: [PATCH 22/25] Create TASK_26 - Fuzzy Relations and Operations --- .../TASK_26 - Fuzzy Relations and Operations | 799 ++++++++++++++++++ 1 file changed, 799 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_26 - Fuzzy Relations and Operations diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_26 - Fuzzy Relations and Operations b/Manasvi Vashishtha-4th yr-Section C/TASK_26 - Fuzzy Relations and Operations new file mode 100644 index 0000000..552b9a3 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_26 - Fuzzy Relations and Operations @@ -0,0 +1,799 @@ +import numpy as np + + +def cartadd(x, y): + """ + Cartesian addition of fuzzy membership vectors using the algebraic method. + Parameters + ---------- + x : 1D array or iterable + First fuzzy membership vector, of length M. + y : 1D array or iterable + Second fuzzy membership vector, of length N. + Returns + ------- + z : 2D array + Cartesian addition of ``x`` and ``y``, of shape (M, N). + """ + # Ensure rank-1 input + x, y = np.asarray(x).ravel(), np.asarray(y).ravel() + b, a = np.meshgrid(y, x, sparse=True) + return a + b + + +def cartprod(x, y): + """ + Cartesian product of two fuzzy membership vectors. Uses ``min()``. + Parameters + ---------- + x : 1D array or iterable + First fuzzy membership vector, of length M. + y : 1D array or iterable + Second fuzzy membership vector, of length N. + Returns + ------- + z : 2D array + Cartesian product of ``x`` and ``y``, of shape (M, N). + """ + # Ensure rank-1 input + x, y = np.asarray(x).ravel(), np.asarray(y).ravel() + b, a = np.meshgrid(y, x, sparse=True) + return np.fmin(a, b) + + +def classic_relation(a, b): + """ + Determine the classic relation matrix, ``R``, between two fuzzy sets. + Parameters + ---------- + a : 1D array or iterable + First fuzzy membership vector, of length M. + b : 1D array or iterable + Second fuzzy membership vector, of length N. + Returns + ------- + R : 2D array + Classic relation matrix between ``a`` and ``b``, shape (M, N) + Notes + ----- + The classic relation is defined as:: + r = [a x b] U [(1 - a) x ones(1, N)], + where ``x`` represents a cartesian product and ``N`` is len(``b``). + """ + a = np.asarray(a) + return np.fmax(cartprod(a, b), cartprod(1 - a, np.ones_like(b))) + + +def contrast(arr, amount=0.2, split=0.5, normalize=True): + """ + General contrast booster or diffuser of normalized array-like data. + Parameters + ---------- + arr : ndarray + Input array (of floats on range [0, 1] if ``normalize=False``). If + values exist outside this range, with ``normalize=True`` the image + will be normalized for calculation. + amount : float or length-2 iterable of floats + Controls the exponential contrast mechanism for values above and below + ``split`` in ``I``. If positive, the curve provides added contrast; + if negative, the curve provides reduced contrast. + If provided as a lenth-2 iterable of floats, they control the regions + (below, above) ``split`` separately. + split : float + Positive scalar, on range [0, 1], determining the midpoint of the + exponential contrast. Default of 0.5 is reasonable for well-exposed + images. + normalize : bool, default True + Controls normalization to the range [0, 1]. + Returns + ------- + focused : ndarray + Contrast adjusted, normalized, floating-point image on range [0, 1]. + Notes + ----- + The result of this algorithm is like applying a Curves adjustment in the + GIMP or Photoshop. + Algorithm for curves adjustment at a given pixel, x, is given by:: + | split * (x/split)^below, 0 <= x <= split + y(x) = | + | 1 - (1-split) * ((1-x) / (1-split))^above, split < x <= 1.0 + See Also + -------- + skfuzzy.fuzzymath.sigmoid + """ + split = float(split) + im = arr.astype(float) + amount_ = np.asarray(amount, dtype=np.float64).ravel() + + if len(amount_) == 1: + # One argument -> Equal amount applied on either side of `split` + above = below = amount_[0] + else: + # Two arguments -> Control contrast separately in light/dark regions + below = amount_[0] + above = amount_[1] + + # Normalize if required + if im.max() > 1. and normalize is True: + ma = float(im.max()) + im /= float(im.max()) + else: + ma = 1. + + focused = np.zeros_like(im, dtype=np.float64) + + # Simplified array-wise algorithm using fancy indexing rather than looping + focused[im <= split] = split * (im[im <= split] / split) ** below + focused[im > split] = (1 - (1. - split) * + ((1 - im[im > split]) / (1. - split)) ** above) + + # Reapply multiplicative factor + return focused * ma + + +def fuzzy_op(x, a, y, b, op): + """Operation of two fuzzy sets. + Operate fuzzy set ``a`` with fuzzy set ``b``, + using +, * or any other binary operator. + Parameters + ---------- + x : 1d array, length N + Universe variable for fuzzy set ``a``. + a : 1d array, length N + Fuzzy set for universe ``x``. + y : 1d array, length M + Universe variable for fuzzy set ``b``. + b : 1d array, length M + Fuzzy set for universe ``y``. + op: Function, pointwise binary operator on two matrices + (pointwise version of) +, -, *, /, min, max etc. + Returns + ------- + z : 1d array + Output variable. + mfz : 1d array + Fuzzy membership set for variable ``z``. + Notes + ----- + Uses Zadeh's Extension Principle as described in Ross, Fuzzy Logic with + Engineering Applications (2010), pp. 414, Eq. 12.17. + If these results are unexpected and your membership functions are convex, + consider trying the ``skfuzzy.dsw_*`` functions for fuzzy mathematics + using interval arithmetic via the restricted Dong, Shah, and Wong method. + """ + # a and x, and b and y, are formed into (MxN) matrices. The former has + # identical rows; the latter identical identical columns. + + yy, xx = np.meshgrid(y, x, sparse=True) # consider broadcasting rules + bb, aa = np.meshgrid(b, a, sparse=True) + + # Do the operation + zz = op(xx, yy).ravel() + zz_index = np.argsort(zz) + zz = np.sort(zz) + + # Array min() operation + c = np.fmin(aa, bb).ravel() + c = c[zz_index] + + # Initialize loop + z, mfz = np.zeros(0), np.zeros(0) + idx = 0 + + for _ in range(len(c)): + index = np.nonzero(zz == zz[idx])[0] + z = np.hstack((z, zz[idx])) + mfz = np.hstack((mfz, c[index].max())) + idx = index[-1] + 1 + if idx >= len(zz): + break + + return z, mfz + + +def fuzzy_add(x, a, y, b): + """ + Add fuzzy set ``a`` to fuzzy set ``b``. + Parameters + ---------- + x : 1d array, length N + Universe variable for fuzzy set ``a``. + a : 1d array, length N + Fuzzy set for universe ``x``. + y : 1d array, length M + Universe variable for fuzzy set ``b``. + b : 1d array, length M + Fuzzy set for universe ``y``. + Returns + ------- + z : 1d array + Output variable. + mfz : 1d array + Fuzzy membership set for variable ``z``. + Notes + ----- + Uses Zadeh's Extension Principle as described in Ross, Fuzzy Logic with + Engineering Applications (2010), pp. 414, Eq. 12.17. + If these results are unexpected and your membership functions are convex, + consider trying the ``skfuzzy.dsw_*`` functions for fuzzy mathematics + using interval arithmetic via the restricted Dong, Shah, and Wong method. + """ + return fuzzy_op(x, a, y, b, op=np.add) + + +def fuzzy_compare(q): + """ + Determine the comparison matrix, ``c``, based on the fuzzy pairwise + comparison matrix, ``q``, using Shimura's special relativity formula. + Parameters + ---------- + q : 2d array, (N, N) + Fuzzy pairwise comparison matrix. + Returns + ------- + c : 2d array, (N, N) + Comparison matrix. + """ + return q.T / np.fmax(q, q.T).astype(np.float) + + +def fuzzy_div(x, a, y, b): + """ + Divide fuzzy set ``b`` into fuzzy set ``a``. + Parameters + ---------- + x : 1d array, length N + Universe variable for fuzzy set ``a``. + a : 1d array, length N + Fuzzy set for universe ``x``. + y : 1d array, length M (excluding zero array) + Universe variable for fuzzy set ``b``. + b : 1d array, length M + Fuzzy set for universe ``y``. + Returns + ------- + z : 1d array + Output variable. + mfz : 1d array + Fuzzy membership set for variable z. + Notes + ----- + Uses Zadeh's Extension Principle from Ross, Fuzzy Logic w/Engineering + Applications, (2010), pp.414, Eq. 12.17. + If these results are unexpected and your membership functions are convex, + consider trying the ``skfuzzy.dsw_*`` functions for fuzzy mathematics + using interval arithmetic via the restricted Dong, Shah, and Wong method. + """ + # a and x, and b and y, are formed into (MxN) matrices. The former has + # identical rows; the latter identical identical columns. + if np.all(np.asarray(y) == 0): + Warning('The 0 value(s) will never be used in the calculation!') + index = np.where(y == 0)[0] + np.delete(y, index) + np.delete(b, index) + return fuzzy_op(x, a, y, b, op=np.divide) + + +def fuzzy_min(x, a, y, b): + """ + Find minimum between fuzzy set ``a`` fuzzy set ``b``. + Parameters + ---------- + x : 1d array, length N + Universe variable for fuzzy set ``a``. + a : 1d array, length N + Fuzzy set for universe ``x``. + y : 1d array, length M + Universe variable for fuzzy set ``b``. + b : 1d array, length M + Fuzzy set for universe ``y``. + Returns + ------- + z : 1d array + Output variable. + mfz : 1d array + Fuzzy membership set for variable z. + Notes + ----- + Uses Zadeh's Extension Principle from Ross, Fuzzy Logic w/Engineering + Applications, (2010), pp.414, Eq. 12.17. + If these results are unexpected and your membership functions are convex, + consider trying the ``skfuzzy.dsw_*`` functions for fuzzy mathematics + using interval arithmetic via the restricted Dong, Shah, and Wong method. + """ + return fuzzy_op(x, a, y, b, op=np.fmin) + + +def fuzzy_mult(x, a, y, b): + """ + Multiplies fuzzy set ``a`` and fuzzy set ``b``. + Parameters + ---------- + x : 1d array, length N + Universe variable for fuzzy set ``a``. + A : 1d array, length N + Fuzzy set for universe ``x``. + y : 1d array, length M + Universe variable for fuzzy set ``b``. + b : 1d array, length M + Fuzzy set for universe ``y``. + Returns + ------- + z : 1d array + Output variable. + mfz : 1d array + Fuzzy membership set for variable z. + Notes + ----- + Uses Zadeh's Extension Principle from Ross, Fuzzy Logic w/Engineering + Applications, (2010), pp.414, Eq. 12.17. + If these results are unexpected and your membership functions are convex, + consider trying the ``skfuzzy.dsw_*`` functions for fuzzy mathematics + using interval arithmetic via the restricted Dong, Shah, and Wong method. + """ + return fuzzy_op(x, a, y, b, op=np.multiply) + + +def fuzzy_sub(x, a, y, b): + """ + Subtract fuzzy set ``b`` from fuzzy set ``a``. + Parameters + ---------- + x : 1d array, length N + Universe variable for fuzzy set ``a``. + A : 1d array, length N + Fuzzy set for universe ``x``. + y : 1d array, length M + Universe variable for fuzzy set ``b``. + b : 1d array, length M + Fuzzy set for universe ``y``. + Returns + ------- + z : 1d array + Output variable. + mfz : 1d array + Fuzzy membership set for variable z. + Notes + ----- + Uses Zadeh's Extension Principle from Ross, Fuzzy Logic w/Engineering + Applications, (2010), pp.414, Eq. 12.17. + If these results are unexpected and your membership functions are convex, + consider trying the ``skfuzzy.dsw_*`` functions for fuzzy mathematics + using interval arithmetic via the restricted Dong, Shah, and Wong method. + """ + return fuzzy_op(x, a, y, b, op=np.subtract) + + +def inner_product(a, b): + """ + Inner product (dot product) of two fuzzy sets. + Parameters + ---------- + a : 1d array or iterable + Fuzzy membership function. + b : 1d array or iterable + Fuzzy membership function. + Returns + ------- + y : float + Fuzzy inner product value, on range [0, 1] + """ + return np.max(np.fmin(np.r_[a], np.r_[b])) + + +def interp10(x): + """ + Utility function which conducts linear interpolation of any rank-1 array. + Result will have 10x resolution. + Parameters + ---------- + x : 1d array, length N + Input array to be interpolated. + Returns + ------- + y : 1d array, length 10 * N + 1 + Linearly interpolated output. + """ + L = len(x) + return np.interp(np.r_[0:L - 0.9:0.1], range(L), x) + + +def maxmin_composition(s, r): + """ + The max-min composition ``t`` of two fuzzy relation matrices. + Parameters + ---------- + s : 2d array, (M, N) + Fuzzy relation matrix #1. + r : 2d array, (N, P) + Fuzzy relation matrix #2. + Returns + ------- + T ; 2d array, (M, P) + Max-min composition, defined by ``T = s o r``. + """ + if s.ndim < 2: + s = np.atleast_2d(s) + if r.ndim < 2: + r = np.atleast_2d(r).T + m = s.shape[0] + p = r.shape[1] + t = np.zeros((m, p)) + + for pp in range(p): + for mm in range(m): + t[mm, pp] = (np.fmin(s[mm, :], r[:, pp].T)).max() + + return t + + +def maxprod_composition(s, r): + """ + The max-product composition ``t`` of two fuzzy relation matrices. + Parameters + ---------- + s : 2d array, (M, N) + Fuzzy relation matrix #1. + r : 2d array, (N, P) + Fuzzy relation matrix #2. + Returns + ------- + t : 2d array, (M, P) + Max-product composition matrix. + """ + if s.ndim < 2: + s = np.atleast_2d(s) + if r.ndim < 2: + r = np.atleast_2d(r).T + m = s.shape[0] + p = r.shape[1] + t = np.zeros((m, p)) + + for mm in range(m): + for pp in range(p): + t[mm, pp] = (s[mm, :] * r[:, pp].T).max() + + return t + + +def interp_membership(x, xmf, xx, zero_outside_x=True): + """ + Find the degree of membership ``u(xx)`` for a given value of ``x = xx``. + Parameters + ---------- + x : 1d array + Independent discrete variable vector. + xmf : 1d array + Fuzzy membership function for ``x``. Same length as ``x``. + xx : float or array of floats + Value(s) on universe ``x`` where the interpolated membership is + desired. + zero_outside_x : bool, optional + Defines the behavior if ``xx`` contains value(s) which are outside the + universe range as defined by ``x``. If `True` (default), all + extrapolated values will be zero. If `False`, the first or last value + in ``x`` will be what is returned to the left or right of the range, + respectively. + Returns + ------- + xxmf : float or array of floats + Membership function value at ``xx``, ``u(xx)``. If ``xx`` is a single + value, this will be a single value; if it is an array or iterable the + result will be returned as a NumPy array of like shape. + Notes + ----- + For use in Fuzzy Logic, where an interpolated discrete membership function + u(x) for discrete values of x on the universe of ``x`` is given. Then, + consider a new value x = xx, which does not correspond to any discrete + values of ``x``. This function computes the membership value ``u(xx)`` + corresponding to the value ``xx`` using linear interpolation. + """ + # Not much beats NumPy's built-in interpolation + if not zero_outside_x: + kwargs = (None, None) + else: + kwargs = (0.0, 0.0) + return np.interp(xx, x, xmf, left=kwargs[0], right=kwargs[1]) + + +def interp_universe(x, xmf, y): + """ + Find interpolated universe value(s) for a given fuzzy membership value. + Parameters + ---------- + x : 1d array + Independent discrete variable vector. + xmf : 1d array + Fuzzy membership function for ``x``. Same length as ``x``. + y : float + Specific fuzzy membership value. + Returns + ------- + xx : list + List of discrete singleton values on universe ``x`` whose + membership function value is y, ``u(xx[i])==y``. + If there are not points xx[i] such that ``u(xx[i])==y`` + it returns an empty list. + Notes + ----- + For use in Fuzzy Logic, where a membership function level ``y`` is given. + Consider there is some value (or set of values) ``xx`` for which + ``u(xx) == y`` is true, though ``xx`` may not correspond to any discrete + values on ``x``. This function computes the value (or values) of ``xx`` + such that ``u(xx) == y`` using linear interpolation. + """ + # Special case required or zero-level cut does not work with faster method + if y == 0.: + idx = np.where(np.diff(xmf > y))[0] + else: + idx = np.where(np.diff(xmf >= y))[0] + xx = (x[idx] + + (y - xmf[idx]) + * (x[idx + 1] - x[idx]) + / (xmf[idx + 1] - xmf[idx])) + + # The above method is fast, but duplicates point values where + # y == peak of a membership function. Ducking briefly into a set + # eliminates this. Benchmarked multiple ways; this is by far the fastest. + # Speed penalty approximately 10%, worth it. + return [n for n in set(xx.tolist())] + + +def _interp_universe_fast(x, xmf, y): + """ + Find interpolated universe value(s) for a given fuzzy membership value. + Fast version, with possible duplication. + Parameters + ---------- + x : 1d array + Independent discrete variable vector. + xmf : 1d array + Fuzzy membership function for ``x``. Same length as ``x``. + y : float + Specific fuzzy membership value. + Returns + ------- + xx : list + List of discrete singleton values on universe ``x`` whose + membership function value is y, ``u(xx[i])==y``. + If there are not points xx[i] such that ``u(xx[i])==y`` + it returns an empty list. + Notes + ----- + For use in Fuzzy Logic, where a membership function level ``y`` is given. + Consider there is some value (or set of values) ``xx`` for which + ``u(xx) == y`` is true, though ``xx`` may not correspond to any discrete + values on ``x``. This function computes the value (or values) of ``xx`` + such that ``u(xx) == y`` using linear interpolation. + """ + # Special case required or zero-level cut does not work with faster method + if y == 0.: + idx = np.where(np.diff(xmf > y))[0] + else: + idx = np.where(np.diff(xmf >= y))[0] + + # This method is fast, but duplicates point values where + # y == peak of a membership function. + return (x[idx] + + (y - xmf[idx]) + * (x[idx+1] - x[idx]) + / (xmf[idx+1] - xmf[idx])) + + +def modus_ponens(a, b, ap, c=None): + """ + Generalized *modus ponens* deduction to make approximate reasoning in a + rules-base system. + Parameters + ---------- + a : 1d array + Fuzzy set ``a`` on universe ``x`` + b : 1d array + Fuzzy set ``b`` on universe ``y`` + ap : 1d array + New fuzzy fact a' (a prime, not transpose) + c : 1d array, OPTIONAL + Keyword argument representing fuzzy set ``c`` on universe ``y``. + Default = None, which will use ``np.ones()`` instead. + Returns + ------- + R : 2d array + Full fuzzy relation. + bp : 1d array + Fuzzy conclusion b' (b prime) + """ + if c is None: + c = np.ones_like(b) + r = np.fmax(cartprod(a, b), cartprod(1 - a, c)) + bp = maxmin_composition(ap, r) + return r, bp.squeeze() + + +def outer_product(a, b): + """ + Outer product of two fuzzy sets. + Parameters + ---------- + a : 1d array or iterable + Fuzzy membership function. + b : 1d array or iterable + Fuzzy membership function. + Returns + ------- + y : float + Fuzzy outer product value, on range [0, 1] + """ + return np.min(np.fmax(np.r_[a], np.r_[b])) + + +def relation_min(a, b): + """ + Determine fuzzy relation matrix ``R`` using Mamdani implication for the + fuzzy antecedent ``a`` and consequent ``b`` inputs. + Parameters + ---------- + a : 1d array + Fuzzy antecedent variable of length M. + b : 1d array + Fuzzy consequent variable of length N. + Returns + ------- + R : 2d array + Fuzzy relation between ``a`` and ``b``, of shape (M, N). + """ + bb, aa = np.meshgrid(b, a, sparse=True) + return np.fmin(aa, bb) + + +def relation_product(a, b): + """ + Determine the fuzzy relation matrix, ``R``, using product implication for + the fuzzy antecedent ``a`` and the fuzzy consequent ``b``. + Parameters + ---------- + a : 1d array + Fuzzy antecedent variable of length M. + b : 1d array + Fuzzy consequent variable of length N. + Returns + ------- + R : 2d array + Fuzzy relation between ``a`` and ``b``, of shape (M, N). + """ + bb, aa = np.meshgrid(b, a, sparse=True) + return aa * bb + + +def fuzzy_similarity(ai, b, mode='min'): + """ + The fuzzy similarity between set ``ai`` and observation set ``b``. + Parameters + ---------- + ai : 1d array + Fuzzy membership function of set ``ai``. + b : 1d array + Fuzzy membership function of set ``b``. + mode : string + Controls the method of similarity calculation. + * ``'min'`` : Computed by array minimum operation. + * ``'avg'`` : Computed by taking the array average. + Returns + ------- + s : float + Fuzzy similarity. + """ + if 'min' in mode.lower(): + return min(inner_product(ai, b), 1 - outer_product(ai, b)) + else: + return (inner_product(ai, b) + (1 - outer_product(ai, b))) / 2. + + +def partial_dmf(x, mf_name, mf_parameter_dict, partial_parameter): + """ + Calculate the *partial derivative* of a specified membership function. + Parameters + ---------- + x : float + input variable. + mf_name : string + Membership function name as a string. The following are supported: + * ``'gaussmf'`` : parameters ``'sigma'`` or ``'mean'`` + * ``'gbellmf'`` : parameters ``'a'``, ``'b'``, or ``'c'`` + * ``'sigmf'`` : parameters ``'b'`` or ``'c'`` + mf_parameter_dict : dict + A dictionary of ``{param : key-value, ...}`` pairs for a particular + membership function as defined above. + partial_parameter : string + Name of the parameter against which we take the partial derivative. + Returns + ------- + d : float + Partial derivative of the membership function with respect to the + chosen parameter, at input point ``x``. + Notes + ----- + Partial derivatives of fuzzy membership functions are only meaningful for + continuous functions. Triangular, trapezoidal designs have no partial + derivatives to calculate. The following + """ + + if mf_name == 'gaussmf': + + sigma = mf_parameter_dict['sigma'] + mean = mf_parameter_dict['mean'] + + if partial_parameter == 'sigma': + result = ((2. / sigma**3) * + np.exp(-(((x - mean)**2) / (sigma)**2)) * (x - mean)**2) + elif partial_parameter == 'mean': + result = ((2. / sigma**2) * + np.exp(-(((x - mean)**2) / (sigma)**2)) * (x - mean)) + + elif mf_name == 'gbellmf': + + a = mf_parameter_dict['a'] + b = mf_parameter_dict['b'] + c = mf_parameter_dict['c'] + + # Partial result for speed and conciseness in derived eqs below + d = np.abs((c - x) / a) + + if partial_parameter == 'a': + result = ((2. * b * (c - x)**2.) * d**((2 * b) - 2) / + (a**3. * (d**(2. * b) + 1)**2.)) + + elif partial_parameter == 'b': + result = (-1 * (2 * d**(2. * b) * np.log(d)) / + ((d**(2. * b) + 1)**2.)) + + elif partial_parameter == 'c': + result = ((2. * b * (x - c) * d**((2. * b) - 2)) / + (a**2. * (d**(2. * b) + 1)**2.)) + + elif mf_name == 'sigmf': + + b = mf_parameter_dict['b'] + c = mf_parameter_dict['c'] + + if partial_parameter == 'b': + # Partial result for speed and conciseness + d = np.exp(c * (b + x)) + result = -1 * (c * d) / (np.exp(b * c) + np.exp(c * x))**2. + + elif partial_parameter == 'c': + # Partial result for speed and conciseness + d = np.exp(c * (x - b)) + result = ((x - b) * d) / (d + 1)**2. + + return result + + +def sigmoid(x, power, split=0.5): + """ + Intensify grayscale values in an array using a sigmoid function. + Parameters + ---------- + x : ndarray + Input vector or image array. Should be pre-normalized to range [0, 1] + p : float + Power of the intensification (p > 0). Experiment with small, decimal + values and increase as necessary. + split : float + Threshold for intensification. Values above ``split`` will be + intensified, while values below `split` will be deintensified. Note + range for ``split`` is (0, 1). Default of 0.5 is reasonable for many + well-exposed images. + Returns + ------- + y : ndarray, same size as x + Output vector or image with contrast adjusted. + Notes + ----- + The sigmoid used herein is defined as:: + y = 1 / (1 + exp(- exp(- power * (x-split)))) + See Also + -------- + skfuzzy.fuzzymath.contrast + """ + + return 1. / (1. + np.exp(- power * (x - split))) From 45ec04d4183e7d3b8dcb640fde2dad86d72e589c Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 21:28:41 +0530 Subject: [PATCH 23/25] Add files via upload --- .../TASK_27 - Fuzzy Inference System.ipynb | 909 ++++++++++++++++++ 1 file changed, 909 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_27 - Fuzzy Inference System.ipynb diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_27 - Fuzzy Inference System.ipynb b/Manasvi Vashishtha-4th yr-Section C/TASK_27 - Fuzzy Inference System.ipynb new file mode 100644 index 0000000..b1537e4 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_27 - Fuzzy Inference System.ipynb @@ -0,0 +1,909 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled7.ipynb", + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "code", + "metadata": { + "id": "nNw_8E_5pRff" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from matplotlib import cm\n", + "from matplotlib.ticker import LinearLocator, FormatStrFormatter" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "MHZGAH3kvABO" + }, + "source": [ + "#sigmoid\n", + "def sigmoidMF(x,a,c):\n", + " return (1/(1+(np.e**(-a*(x-c)))))\n", + "\n", + "#Gauss\n", + "def gaussMF(x,a,c):\n", + " return np.e**(-(x-c)**2/(2*a**2))\n", + "\n", + "#bell\n", + "def bellMF(x,a,b,c):\n", + " return 1/(1+(np.absolute((x-c)/a))**(2*b))\n", + "\n", + "#triangular\n", + "def triangularMF(x,a,b,c):\n", + " return np.maximum(np.minimum((x-a)/(b-a),(c-x)/(c-b)),0)\n", + "\n", + "#trapzoidal\n", + "def trapMF(x,a,b,c,d):\n", + " #return np.maximum(np.minimum((x-a/b-a),1,(d-x/d-c)),0)\n", + " #return np.maximum(np.minimum(np.minimum((x-a/b-a),1),np.minimum(1,(d-x/d-c))),0)\n", + " \n", + " y = np.ones(len(x))\n", + "\n", + " idx = np.nonzero(x <= b)\n", + " y[idx] = triangularMF(x[idx],a,b,b)\n", + "\n", + " idx = np.nonzero(x >= c)\n", + " y[idx] = triangularMF(x[idx],c,c,d)\n", + "\n", + " idx = np.nonzero(x < a)\n", + " y[idx] = np.zeros(len(idx))\n", + "\n", + " idx = np.nonzero(x > d)\n", + " y[idx] = np.zeros(len(idx))\n", + " \n", + " return y" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "QNsRTFU_vFS_" + }, + "source": [ + "#TESTS\n", + "#ig = plt.figure(figsize=(10, 10), dpi= 80, facecolor='w', edgecolor='k')\n", + "#x = fig.gca(projection='3d')\n", + "\n", + "# = np.arange(-10, 10, 0.01)\n", + "# = np.arange(-10, 10, 0.01)\n", + "#, Y = np.meshgrid(X, Y)\n", + "# = np.sqrt(X**2 + Y**2)\n", + "# = np.sin(R)/R\n", + "\n", + "#urf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,linewidth=0, antialiased=False)\n", + "\n", + "# Customize the z axis.\n", + "#x.set_zlim(-1.01, 1.01)\n", + "#x.zaxis.set_major_locator(LinearLocator(10))\n", + "#x.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))\n", + "\n", + "# Add a color bar which maps values to colors.\n", + "#ig.colorbar(surf, shrink=0.5, aspect=5)\n", + "\n", + "#lt.show()" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "62hD12A5vK3X" + }, + "source": [ + "#indx = -1\n", + "#ind = 0\n", + "#for x in FlagIn:\n", + "# indx = indx + 1\n", + "# indy = -1\n", + "# for y in GenPos:\n", + "# indy = indy +1\n", + "# indz = -1\n", + "# for z in Output:\n", + "# indz = indz + 1\n", + "# ind = ind + 1\n", + "# print(indx)\n", + "# print(indy)\n", + "# print(indz)\n", + "# print(ind)\n", + "# print('\\n')" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "KkFX12ZavQ67" + }, + "source": [ + "\n", + "#(figsize=(15, 200), dpi= 80, facecolor='w', edgecolor='k')\n", + "#\n", + "#\n", + "\n", + "#\n", + "#\n", + "#lagIn:\n", + "#ndx + 1\n", + "#1\n", + "# GenPos:\n", + "# indy +1\n", + "# -1\n", + "#in Output:\n", + "# = indz + 1\n", + "#= ind + 1\n", + "#\n", + "#ndz == 0:\n", + "#t.subplot(125,5,ind)\n", + "#t.plot(X,flagin[indx],'r')\n", + "#t.plot(ev1,flagin[indx][ev1],'o')\n", + "#t.grid(True)\n", + "#t.gca().legend((FlagIn[indx],))\n", + "# = flagin[indx][ev1]\n", + "#\n", + "#ndz == 1:\n", + "#t.subplot(125,5,ind)\n", + "#t.plot(X,genpos[indy],'g')\n", + "#t.plot(ev2,genpos[indy][ev2],'o')\n", + "#t.grid(True)\n", + "#t.gca().legend((FlagIn[indy],))\n", + "# = genpos[indy][ev2]\n", + "#\n", + "#ndz == 2:\n", + "#t.subplot(125,5,ind)\n", + "#t.plot(Y,Output[indx,indy][0],'b')\n", + "#t.plot(5,np.minimum(a1,a2),'o')\n", + "#t.grid(True)\n", + "#t.gca().legend((output[indx,indy][0],))\n", + "#\n", + "#ndz == 3:\n", + "#t.subplot(125,5,ind)\n", + "#t.plot(Z,Output[indx,indy][1],'m')\n", + "#t.plot(5,np.minimum(a1,a2),'o')\n", + "#t.grid(True)\n", + "#t.gca().legend((output[indx,indy][1],))" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "NQQfxfUzvZ0M" + }, + "source": [ + "#ev1= 0\n", + "#ev2= 30\n", + "\n", + "#indx = -1\n", + "#ind= 0\n", + "#outl = []\n", + "#for x in FlagIn:\n", + "#indx = indx + 1\n", + "#indy = -1\n", + "#= []\n", + "#r y in GenPos:\n", + "#indy = indy +1\n", + "#indz = -1\n", + "#\n", + "#for z in Output:\n", + "# indz = indz + 1\n", + "# ind = ind + 1\n", + "# \n", + "# if indz == 0:\n", + "# a1 = flagin[indx][ev1]\n", + "# \n", + "# if indz == 1:\n", + "# a2 = genpos[indy][ev2]\n", + "# \n", + "# if indz == 2:\n", + "# c1 = np.minimum(a1,a2)\n", + "# \n", + "# if indz == 3:\n", + "# c2 = np.minimum(a1,a2)\n", + "# else:\n", + "# c1 = 0\n", + "# c2 = 0\n", + "# Outline = np.maximum(c1,c2)\n", + "# a = np.full(len(Y),Outline)\n", + "# outL.append(np.minimum(a,Output[indx,indy][0]))\n", + "#FinalCutLine = np.amax(outL,axis = 0)\n", + "#plt.plot(Y,FinalCutLine)\n", + "#length = FinalCutLine.shape[0]\n", + "#sum_x = np.nansum(FinalCutLine*Y)\n", + "#sum_y = np.nansum(FinalCutLine)\n", + "#CentroidX = sum_x/length\n", + "#CentroidY = sum_y/length\n", + "#plt.plot(CentroidX,CentroidY,'o')\n", + "##print(CentroidX)\n", + "#" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "qEey7fyoviqx" + }, + "source": [ + "#dx = -1\n", + "#d = 0\n", + "#tL = []\n", + "#r x in FlagIn:\n", + "#indx = indx + 1\n", + "#indy = -1\n", + "#c = []\n", + "#for y in GenPos:\n", + "# indy = indy +1\n", + "# indz = -1\n", + "# \n", + "# for z in Output:\n", + "# indz = indz + 1\n", + "# ind = ind + 1\n", + "# \n", + "# if indz == 0:\n", + "# a1 = flagin[indx][ev1]\n", + "# \n", + "# if indz == 1:\n", + "# a2 = genpos[indy][ev2]\n", + "# \n", + "# if indz == 2:\n", + "# c1 = np.minimum(a1,a2)\n", + "# \n", + "# if indz == 3:\n", + "# c2 = np.minimum(a1,a2)\n", + "# else:\n", + "# c1 = 0\n", + "# c2 = 0\n", + "# Outline = np.maximum(c1,c2)\n", + "# a = np.full(len(Y),Outline)\n", + "# outL.append(np.minimum(a,Output[indx,indy][1]))\n", + "# FinalCutLine = np.amax(outL,axis = 0)\n", + "# plt.plot(Y,FinalCutLine)\n", + "# length = FinalCutLine.shape[0]\n", + "# sum_x = np.nansum(FinalCutLine*Y)\n", + "# sum_y = np.nansum(FinalCutLine)\n", + "# CentroidX = sum_x/length\n", + "# CentroidY = sum_y/length\n", + "# plt.plot(CentroidX,CentroidY,'o')\n", + "# #print(CentroidX)" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PVIHJwBmv01B" + }, + "source": [ + "## Definitions" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 920 + }, + "id": "kSpwkzLTvpoE", + "outputId": "643bb8d1-ddfa-4cf1-f508-84fc453694a6" + }, + "source": [ + "x = np.linspace(0,359,100) #flag/generator\n", + "y = np.linspace(0,100,100) #speed\n", + "z = np.linspace(0,5,100) #direction\n", + "\n", + "#Membership Functions\n", + "#Flag position\n", + "EN = trapMF(x,0,0,10,80)\n", + "N = trapMF(x,10,80,100,170)\n", + "W = trapMF(x,100,170,190,260)\n", + "S = trapMF(x,190,260,280,350)\n", + "E = trapMF(x,280,350,359,359)\n", + "\n", + "#Generator position\n", + "ENg = trapMF(x,0,0,10,80)\n", + "Ng = trapMF(x,10,80,100,170)\n", + "Wg = trapMF(x,100,170,190,260)\n", + "Sg = trapMF(x,190,260,280,350)\n", + "Eg = trapMF(x,280,350,359,359)\n", + "\n", + "#Speed\n", + "L = trapMF(y,0,0,10,35)\n", + "M = trapMF(y,15,40,60,85)\n", + "H = trapMF(y,65,90,100,100) \n", + "\n", + "#Direction\n", + "CW = triangularMF(z,0,0,2.4)\n", + "DM = triangularMF(z,2.3,2.5,2.7)\n", + "CCW = triangularMF(z,2.6,5,5)\n", + "#Plot\n", + "plt.figure(figsize=(8, 13), dpi= 80, facecolor='w', edgecolor='k')\n", + "\n", + "#Figure 1\n", + "plt.subplot(4,1,1)\n", + "plt.plot(x,EN)\n", + "plt.plot(x,N)\n", + "plt.plot(x,W)\n", + "plt.plot(x,S)\n", + "plt.plot(x,E)\n", + "plt.title('Flag input')\n", + "plt.gca().legend(('EN','N','W','S','E'))\n", + "plt.grid(True)\n", + "\n", + "#Figure 2\n", + "plt.subplot(4,1,2)\n", + "plt.plot(x,ENg)\n", + "plt.plot(x,Ng)\n", + "plt.plot(x,Wg)\n", + "plt.plot(x,Sg)\n", + "plt.plot(x,Eg)\n", + "plt.title('Generator position')\n", + "plt.gca().legend(('EN','N','W','S','E'))\n", + "plt.grid(True)\n", + "\n", + "#Figure 3\n", + "plt.subplot(4,1,3)\n", + "plt.plot(y,L,'r')\n", + "plt.plot(y,M,'g')\n", + "plt.plot(y,H,'b')\n", + "plt.title('Speed')\n", + "plt.gca().legend(('Low','Med','High'))\n", + "plt.grid(True)\n", + "\n", + "#Figure 4\n", + "plt.subplot(4,1,4)\n", + "plt.plot(z,CW,'r')\n", + "plt.plot(z,DM,'g')\n", + "plt.plot(z,CCW,'b')\n", + "plt.title('Direction')\n", + "plt.gca().legend(('Clock Wise','Dont Move','Counter Clock Wise'))\n", + "plt.grid(True)\n", + "\n", + "plt.show()" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:15: RuntimeWarning: invalid value encountered in true_divide\n", + " from ipykernel import kernelapp as app\n", + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:15: RuntimeWarning: divide by zero encountered in true_divide\n", + " from ipykernel import kernelapp as app\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q0eAswoyv5AO" + }, + "source": [ + "## Rules" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c7gDEIcjwAUi", + "outputId": "908c4ce5-5bc9-411d-e1df-3e5262f5b34d" + }, + "source": [ + "FlagIn = ['EN','N','W','S','E']\n", + "GenPos = ['EN','N','W','S','E']\n", + "\n", + "Output = np.empty((5,5),dtype='object')\n", + "indx = -1\n", + "for x in FlagIn:\n", + " indx = indx + 1\n", + " indy = -1\n", + " for y in GenPos:\n", + " indy = indy +1\n", + " if x == y:\n", + " Output[indx][indy] = L,DM\n", + " \n", + " if x == 'N' and y == 'S' or x == 'S' and y == 'N':\n", + " Output[indx][indy] = H,CCW\n", + " \n", + " if x == 'E' and y == 'W' or x == 'W' and y == 'E':\n", + " Output[indx][indy] = H,CW\n", + " \n", + " if x == 'EN' and y == 'W' or x == 'W' and y == 'EN':\n", + " Output[indx][indy] = H,CCW\n", + " \n", + " if x == 'EN' and y == 'N'or x == 'N' and y == 'EN':\n", + " Output[indx][indy] = H,CW\n", + " \n", + " if x == 'S' and y == 'EN' or x == 'EN' and y == 'S':\n", + " Output[indx][indy] = M,CCW\n", + " \n", + " if x == 'W' and y == 'N' or x == 'N' and y == 'W':\n", + " Output[indx][indy] = M,CCW\n", + " \n", + " if x == 'EN' and y == 'E' or x == 'E' and y == 'EN':\n", + " Output[indx][indy] = L,CCW\n", + " \n", + " if x == 'N' and y == 'E' or x == 'E' and y == 'N':\n", + " Output[indx][indy] = M,CCW\n", + " \n", + " if x == 'S' and y == 'W' or x == 'W' and y == 'S':\n", + " Output[indx][indy] = M,CW\n", + " \n", + " if x == 'E' and y == 'S' or x == 'S' and y == 'E':\n", + " Output[indx][indy] = M,CCW\n", + "\n", + "output = np.empty((5,5),dtype='object')\n", + "indx = -1\n", + "for x in FlagIn:\n", + " indx = indx + 1\n", + " indy = -1\n", + " for y in GenPos:\n", + " indy = indy +1\n", + " if x == y:\n", + " output[indx][indy] = 'L','DM'\n", + " \n", + " if x == 'N' and y == 'S' or x == 'S' and y == 'N':\n", + " output[indx][indy] = 'H','CCW'\n", + " \n", + " if x == 'E' and y == 'W' or x == 'W' and y == 'E':\n", + " output[indx][indy] = 'H','CW'\n", + " \n", + " if x == 'EN' and y == 'W' or x == 'W' and y == 'EN':\n", + " output[indx][indy] = 'H','CCW'\n", + " \n", + " if x == 'EN' and y == 'N'or x == 'N' and y == 'EN':\n", + " output[indx][indy] = 'H','CW'\n", + " \n", + " if x == 'S' and y == 'EN' or x == 'EN' and y == 'S':\n", + " output[indx][indy] = 'M','CCW'\n", + " \n", + " if x == 'W' and y == 'N' or x == 'N' and y == 'W':\n", + " output[indx][indy] = 'M','CCW'\n", + " \n", + " if x == 'EN' and y == 'E' or x == 'E' and y == 'EN':\n", + " output[indx][indy] = 'L','CCW'\n", + " \n", + " if x == 'N' and y == 'E' or x == 'E' and y == 'N':\n", + " output[indx][indy] = 'M','CCW'\n", + " \n", + " if x == 'S' and y == 'W' or x == 'W' and y == 'S':\n", + " output[indx][indy] = 'M','CW'\n", + "\n", + " if x == 'E' and y == 'S' or x == 'S' and y == 'E':\n", + " output[indx][indy] = 'M','CCW'\n", + "\n", + "print(output)" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[[('L', 'DM') ('H', 'CW') ('H', 'CCW') ('M', 'CCW') ('L', 'CCW')]\n", + " [('H', 'CW') ('L', 'DM') ('M', 'CCW') ('H', 'CCW') ('M', 'CCW')]\n", + " [('H', 'CCW') ('M', 'CCW') ('L', 'DM') ('M', 'CW') ('H', 'CW')]\n", + " [('M', 'CCW') ('H', 'CCW') ('M', 'CW') ('L', 'DM') ('M', 'CCW')]\n", + " [('L', 'CCW') ('M', 'CCW') ('H', 'CW') ('M', 'CCW') ('L', 'DM')]]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "c2OuEOiowYIu", + "outputId": "46c4c7ec-4292-4a77-fa50-c3827af902f4" + }, + "source": [ + "#Printing Rules(?)\n", + "plt.figure(figsize=(15, 200), dpi= 80, facecolor='w', edgecolor='k')\n", + "\n", + "indx = -1\n", + "ind = 0\n", + "flagin = [EN,N,W,S,E]\n", + "genpos = [ENg,Ng,Wg,Sg,Eg]\n", + "\n", + "\n", + "#Universe(s)\n", + "X = np.linspace(0,359,100) #flag/generator\n", + "Y = np.linspace(0,100,100) #speed\n", + "Z = np.linspace(0,5,100) #direction\n", + "\n", + "indx = -1\n", + "ind = 0\n", + "for x in FlagIn:\n", + " indx = indx + 1\n", + " indy = -1\n", + " for y in GenPos:\n", + " indy = indy +1\n", + " indz = -1\n", + " for z in Output:\n", + " indz = indz + 1\n", + " ind = ind + 1\n", + " if indz == 0:\n", + " plt.subplot(125,5,ind)\n", + " plt.plot(X,flagin[indx],'r')\n", + " plt.grid(True)\n", + " plt.gca().legend((FlagIn[indx],))\n", + " \n", + " if indz == 1:\n", + " plt.subplot(125,5,ind)\n", + " plt.plot(X,genpos[indy],'g')\n", + " plt.grid(True)\n", + " plt.gca().legend((FlagIn[indy],))\n", + " \n", + " if indz == 2:\n", + " plt.subplot(125,5,ind)\n", + " plt.plot(Y,Output[indx,indy][0],'b')\n", + " plt.grid(True)\n", + " plt.gca().legend((output[indx,indy][0],))\n", + " \n", + " if indz == 3:\n", + " plt.subplot(125,5,ind)\n", + " plt.plot(Z,Output[indx,indy][1],'m')\n", + " plt.grid(True)\n", + " plt.gca().legend((output[indx,indy][1],))\n", + " \n", + "plt.show()" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "c4sqgur7wjmw" + }, + "source": [ + "Ze = np.empty((len(X),len(X)),dtype='object')\n", + "\n", + "for ev1,t in enumerate(X):\n", + " for ev2,s in enumerate(X):\n", + " indx = -1\n", + " ind = 0\n", + " outL = []\n", + " for x in FlagIn:\n", + " indx = indx + 1\n", + " indy = -1\n", + " c = []\n", + " for y in GenPos:\n", + " indy = indy +1\n", + " indz = -1\n", + "\n", + " for z in Output:\n", + " indz = indz + 1\n", + " ind = ind + 1\n", + "\n", + " if indz == 0:\n", + " a1 = flagin[indx][ev1]\n", + "\n", + " if indz == 1:\n", + " a2 = genpos[indy][ev2]\n", + "\n", + " if indz == 2:\n", + " c1 = np.minimum(a1,a2)\n", + "\n", + " if indz == 3:\n", + " c2 = np.minimum(a1,a2)\n", + " else:\n", + " c1 = 0\n", + " c2 = 0\n", + "\n", + " Outline = np.maximum(c1,c2)\n", + " a = np.full(len(Z),Outline)\n", + " outL.append(np.minimum(a,Output[indx,indy][0]))\n", + "\n", + " FinalCutLine = np.amax(outL,axis = 0)\n", + " sum_x = np.nansum(FinalCutLine*Y)\n", + " sum_y = np.nansum(FinalCutLine) + 1\n", + " CentroidX = (sum_x/sum_y)\n", + " Ze[ev1,ev2] = CentroidX" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "qyzoNpjHw32A" + }, + "source": [ + "Z2 = np.empty((len(X),len(X)),dtype='object')\n", + "\n", + "for ev1,t in enumerate(X):\n", + " for ev2,s in enumerate(X):\n", + " indx = -1\n", + " ind = 0\n", + " outL = []\n", + " for x in FlagIn:\n", + " indx = indx + 1\n", + " indy = -1\n", + " c = []\n", + " for y in GenPos:\n", + " indy = indy +1\n", + " indz = -1\n", + "\n", + " for z in Output:\n", + " indz = indz + 1\n", + " ind = ind + 1\n", + "\n", + " if indz == 0:\n", + " a1 = flagin[indx][ev1]\n", + "\n", + " if indz == 1:\n", + " a2 = genpos[indy][ev2]\n", + " \n", + " if indz == 2:\n", + " c1 = np.minimum(a1,a2)\n", + "\n", + " if indz == 3:\n", + " c2 = np.minimum(a1,a2)\n", + " else:\n", + " c1 = 0\n", + " c2 = 0\n", + "\n", + " Outline = np.maximum(c1,c2)\n", + " a = np.full(len(Y),Outline)\n", + " outL.append(np.minimum(a,Output[indx,indy][1]))\n", + " \n", + " FinalCutLine = np.amax(outL,axis = 0)\n", + " length = FinalCutLine.shape[0]\n", + " sum_x = np.nansum(FinalCutLine*Z)\n", + " sum_y = np.nansum(FinalCutLine) + 1\n", + " CentroidX = (sum_x/sum_y)\n", + " #print(CentroidX)\n", + " Z2[ev1,ev2] = CentroidX" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 987 + }, + "id": "yI7qxOufxByu", + "outputId": "daf43d2e-eb46-400d-b4f9-78ad01aeadd1" + }, + "source": [ + "fig = plt.figure(figsize=(12, 10), dpi= 80, facecolor='w', edgecolor='k')\n", + "ax = fig.gca(projection='3d')\n", + "\n", + "X = np.linspace(0,359,100) \n", + "X = X\n", + "Y = X\n", + "X, Y = np.meshgrid(X, Y)\n", + "\n", + "surf = ax.plot_surface(X, Y, Ze,cmap=cm.RdGy)\n", + "fig.colorbar(surf, shrink=0.5, aspect=5)\n", + "ax.set_ylabel('Generator position')\n", + "ax.set_xlabel('Flag position')\n", + "ax.set_zlabel('Speed')\n", + "\n", + "ax.view_init(40, 60)\n", + "#plt.draw()\n", + "\n", + "\n", + "plt.show()" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmeshgrid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0msurf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_surface\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mZe\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRdGy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolorbar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msurf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshrink\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maspect\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_ylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Generator position'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/mpl_toolkits/mplot3d/axes3d.py\u001b[0m in \u001b[0;36mplot_surface\u001b[0;34m(self, X, Y, Z, norm, vmin, vmax, lightsource, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1496\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mZ\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1497\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Argument Z must be 2-dimensional.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1498\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misnan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1499\u001b[0m cbook._warn_external(\n\u001b[1;32m 1500\u001b[0m \u001b[0;34m\"Z contains NaN values. This may result in rendering \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: ufunc 'isnan' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 987 + }, + "id": "Dx6W-6F1xFuE", + "outputId": "eed9348e-7cd9-4408-c22b-d86994a623fd" + }, + "source": [ + "fig = plt.figure(figsize=(12, 10), dpi= 80, facecolor='w', edgecolor='k')\n", + "ax = fig.gca(projection='3d')\n", + "\n", + "X = np.linspace(0,359,100) #flag/generator\n", + "\n", + "surf = ax.plot_surface(X, Y, Z2,cmap=cm.RdGy)\n", + "fig.colorbar(surf, shrink=0.5, aspect=5)\n", + "ax.set_ylabel('Generator position')\n", + "ax.set_xlabel('Flag position')\n", + "ax.set_zlabel('Direction')\n", + "ax.view_init(40, 60)\n", + "\n", + "plt.show()" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m359\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#flag/generator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0msurf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_surface\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mZ2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRdGy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolorbar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msurf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshrink\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maspect\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_ylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Generator position'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/mpl_toolkits/mplot3d/axes3d.py\u001b[0m in \u001b[0;36mplot_surface\u001b[0;34m(self, X, Y, Z, norm, vmin, vmax, lightsource, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1496\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mZ\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1497\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Argument Z must be 2-dimensional.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1498\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misnan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1499\u001b[0m cbook._warn_external(\n\u001b[1;32m 1500\u001b[0m \u001b[0;34m\"Z contains NaN values. This may result in rendering \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: ufunc 'isnan' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "CAZuSMWyxJOH" + }, + "source": [ + "plt.figure(figsize=(12, 5), dpi= 80, facecolor='w', edgecolor='k')\n", + "\n", + "X = np.linspace(0,359,100) \n", + "X = X\n", + "Y = X\n", + "X, Y = np.meshgrid(X, Y)\n", + "plt.subplot(1,2,1)\n", + "plt.contourf(X, Y, Ze,cmap=cm.coolwarm)\n", + "#plt.colorbar(plt.contourf(X, Y, Ze,cmap=cm.coolwarm), shrink=0.5, aspect=5)\n", + "#plt.Normalize(vmin=0, vmax=100)\n", + "plt.title('Speed')\n", + "#plt.grid(True)\n", + "\n", + "plt.subplot(1,2,2)\n", + "X = np.linspace(0,359,100) \n", + "\n", + "X = X\n", + "Y = X\n", + "X, Y = np.meshgrid(X, Y)\n", + "plt.contourf(X, Y, Z2,cmap=cm.coolwarm)\n", + "#plt.grid(True)\n", + "plt.title('Direction')\n", + "#plt.colorbar(plt.contourf(X, Y, Z2,cmap=cm.coolwarm), shrink=0.5, aspect=5)\n", + "\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YT-EvMZpxN3K", + "outputId": "db588429-9997-43ef-bec0-24e463d8f2d9" + }, + "source": [ + "#Values\n", + "print(\"insert value for Flag position: \")\n", + "ev1 = int(int(input())*100/359)\n", + "print(\"insert value for Generator position: \")\n", + "ev2 = int(int(input())*100/359)\n", + "\n", + "\n", + "print(\"Speed: \")\n", + "print(Ze[ev1,ev2])\n", + "\n", + "\n", + "print(\"Direction: \")\n", + "print(Z2[ev1,ev2])" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "text": [ + "insert value for Flag position: \n", + "200\n", + "insert value for Generator position: \n", + "150\n", + "Speed: \n", + "35.874510527975886\n", + "Direction: \n", + "2.8150570694531374\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file From ccac999a3fd32b78c6e0d07a46ba5bc110c3c30d Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 21:32:28 +0530 Subject: [PATCH 24/25] Create TASK_28 - Genetic Algorithm --- .../TASK_28 - Genetic Algorithm | 169 ++++++++++++++++++ 1 file changed, 169 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_28 - Genetic Algorithm diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_28 - Genetic Algorithm b/Manasvi Vashishtha-4th yr-Section C/TASK_28 - Genetic Algorithm new file mode 100644 index 0000000..0690aa7 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_28 - Genetic Algorithm @@ -0,0 +1,169 @@ +import random + +class GeneticAlgorithm(object): + def __init__(self, genetics): + self.genetics = genetics + pass + + def run(self): + population = self.genetics.initial() + while True: + fits_pops = [(self.genetics.fitness(ch), ch) for ch in population] + if self.genetics.check_stop(fits_pops): break + population = self.next(fits_pops) + pass + return population + + def next(self, fits): + parents_generator = self.genetics.parents(fits) + size = len(fits) + nexts = [] + while len(nexts) < size: + parents = next(parents_generator) + cross = random.random() < self.genetics.probability_crossover() + children = self.genetics.crossover(parents) if cross else parents + for ch in children: + mutate = random.random() < self.genetics.probability_mutation() + nexts.append(self.genetics.mutation(ch) if mutate else ch) + pass + pass + return nexts[0:size] + pass + +class GeneticFunctions(object): + def probability_crossover(self): + r"""returns rate of occur crossover(0.0-1.0)""" + return 1.0 + + def probability_mutation(self): + r"""returns rate of occur mutation(0.0-1.0)""" + return 0.0 + + def initial(self): + r"""returns list of initial population + """ + return [] + + def fitness(self, chromosome): + r"""returns domain fitness value of chromosome + """ + return len(chromosome) + + def check_stop(self, fits_populations): + r"""stop run if returns True + - fits_populations: list of (fitness_value, chromosome) + """ + return False + + def parents(self, fits_populations): + r"""generator of selected parents + """ + gen = iter(sorted(fits_populations)) + while True: + f1, ch1 = next(gen) + f2, ch2 = next(gen) + yield (ch1, ch2) + pass + return + + def crossover(self, parents): + r"""breed children + """ + return parents + + def mutation(self, chromosome): + r"""mutate chromosome + """ + return chromosome + pass + +if __name__ == "__main__": + """ + example: Mapped guess prepared Text + """ + class GuessText(GeneticFunctions): + def __init__(self, target_text, + limit=200, size=400, + prob_crossover=0.9, prob_mutation=0.2): + self.target = self.text2chromo(target_text) + self.counter = 0 + + self.limit = limit + self.size = size + self.prob_crossover = prob_crossover + self.prob_mutation = prob_mutation + pass + + # GeneticFunctions interface impls + def probability_crossover(self): + return self.prob_crossover + + def probability_mutation(self): + return self.prob_mutation + + def initial(self): + return [self.random_chromo() for j in range(self.size)] + + def fitness(self, chromo): + # larger is better, matched == 0 + return -sum(abs(c - t) for c, t in zip(chromo, self.target)) + + def check_stop(self, fits_populations): + self.counter += 1 + if self.counter % 10 == 0: + best_match = list(sorted(fits_populations))[-1][1] + fits = [f for f, ch in fits_populations] + best = max(fits) + worst = min(fits) + ave = sum(fits) / len(fits) + print( + "[G %3d] score=(%4d, %4d, %4d): %r" % + (self.counter, best, ave, worst, + self.chromo2text(best_match))) + pass + return self.counter >= self.limit + + def parents(self, fits_populations): + while True: + father = self.tournament(fits_populations) + mother = self.tournament(fits_populations) + yield (father, mother) + pass + pass + + def crossover(self, parents): + father, mother = parents + index1 = random.randint(1, len(self.target) - 2) + index2 = random.randint(1, len(self.target) - 2) + if index1 > index2: index1, index2 = index2, index1 + child1 = father[:index1] + mother[index1:index2] + father[index2:] + child2 = mother[:index1] + father[index1:index2] + mother[index2:] + return (child1, child2) + + def mutation(self, chromosome): + index = random.randint(0, len(self.target) - 1) + vary = random.randint(-5, 5) + mutated = list(chromosome) + mutated[index] += vary + return mutated + + # internals + def tournament(self, fits_populations): + alicef, alice = self.select_random(fits_populations) + bobf, bob = self.select_random(fits_populations) + return alice if alicef > bobf else bob + + def select_random(self, fits_populations): + return fits_populations[random.randint(0, len(fits_populations)-1)] + + def text2chromo(self, text): + return [ord(ch) for ch in text] + def chromo2text(self, chromo): + return "".join(chr(max(1, min(ch, 255))) for ch in chromo) + + def random_chromo(self): + return [random.randint(1, 255) for i in range(len(self.target))] + pass + + GeneticAlgorithm(GuessText("Hello World!")).run() + pass From 6a26ab1f5d41e3529069cd6b833c6772b0a8b6c9 Mon Sep 17 00:00:00 2001 From: Manasvi Vashishtha Date: Sun, 6 Dec 2020 21:36:00 +0530 Subject: [PATCH 25/25] Create TASK_29 - Counter Propagation Algorithm --- .../TASK_29 - Counter Propagation Algorithm | 263 ++++++++++++++++++ 1 file changed, 263 insertions(+) create mode 100644 Manasvi Vashishtha-4th yr-Section C/TASK_29 - Counter Propagation Algorithm diff --git a/Manasvi Vashishtha-4th yr-Section C/TASK_29 - Counter Propagation Algorithm b/Manasvi Vashishtha-4th yr-Section C/TASK_29 - Counter Propagation Algorithm new file mode 100644 index 0000000..9f4d968 --- /dev/null +++ b/Manasvi Vashishtha-4th yr-Section C/TASK_29 - Counter Propagation Algorithm @@ -0,0 +1,263 @@ +#include "counterpropagation.h" + +double CounterpropNetwork::random() +{ + double random_value; + + random_value = ( (double)( rand() % 100 ) ) / 101.0; + + return random_value; +} + +CounterpropNetwork::CounterpropNetwork() +{ + m_dbGrossbergLearningRate = 0.05; + m_dbKohonenLearningRate = 0.2; + m_dbKohonenDecayRate = 2.0; + m_dbTolerance = .2; + m_dbGrossbergDecayRate = 0.1; + m_dbKohonenInitRange = 1.0; + m_dbInhibitingFactor = 0.9; + m_dbNoiseFactor = .001; + m_dwInputSize = INPUT; + m_dwOutputSize = OUTPUT; + m_dwHiddenSize = HIDDEN; + m_dwNumberOfWinnersAllowed = 1; + m_dwNumberOfIterations = 1; + + DWORD i = 0, j = 0; + + unsigned int init = static_cast( time(NULL) ); + srand( init ); + + m_vvdKohonenMatrix.resize(m_dwHiddenSize); + + double random_value = CounterpropNetwork::random(); + + for( i = 0; i < m_dwHiddenSize; i++ ) + { + for ( j = 0; j < m_dwInputSize; j++ ) + { + m_vvdKohonenMatrix[i].push_back( random_value ); + } + } + + // initialize hidden neuron "wins" counters + for( i = 0; i < m_dwHiddenSize; i++ ) + { + m_viNumberOfWins.push_back( 0 ); + } + + // initialize Grossberg Matrix weights to 0 + m_vvdGrossbergMatrix.resize( m_dwOutputSize ); + + for( i = 0; i < m_dwOutputSize; i++ ) + { + for( j = 0; j < m_dwHiddenSize; j++ ) + { + m_vvdGrossbergMatrix[i].push_back( 0.0 ); + } + } +}; + +CounterpropNetwork::~CounterpropNetwork() +{ + +} + +// Training input vectors until all input vectors have been learned +void CounterpropNetwork::training( vector> vvd_trainingInputVector, vector> vvd_trainingOutputVector ) +{ + DWORD dw_winningHiddenIndex, + dwTrainingInputVectorSize; + unsigned int i; + vector res; + + int x = 0; + int epochs = EPOCHS; + double error = 0.0; + + bool bFirst = TRUE; + + dwTrainingInputVectorSize = vvd_trainingInputVector.size(); + + while( epochs && ( error > PRECISION || bFirst ) ) + { + error = 0.0; + bFirst = FALSE; + + for( i = 0; i < dwTrainingInputVectorSize; i++ ) + { + dw_winningHiddenIndex = trainingVector( vvd_trainingInputVector[i] ); + + m_viNumberOfWins[dw_winningHiddenIndex]++; + + updateGrossbergWeights( dw_winningHiddenIndex, 0, vvd_trainingOutputVector[i] ); + + res = testing(vvd_trainingInputVector[i]); + + for( x = 0; x < OUTPUT; ++x ) + { + error += pow( res[x] - vvd_trainingOutputVector[i][x], 2 ); + } + } + + error /= OUTPUT; + + epochs--; + } + + +} + +// training of a single vector +int CounterpropNetwork::trainingVector( vector& inputVector ) +{ + // Normalize the input vector x + //normalize( inputVector ); + + // Determine winning node in the Kohonen layer + int winningHiddenIndex = getWinningHiddenIndex( inputVector ); + + // Update winning node's weight vector + updateKohonenWeights( winningHiddenIndex, inputVector ); + + return winningHiddenIndex; +} + +vector CounterpropNetwork::testing( vector& inputVector ) +{ + DWORD i, j; + + vector outputVector( m_dwOutputSize ); + + // present input vector and calculate hidden layer activations + vector hiddenActivations( m_dwHiddenSize ); + + for( i = 0; i < m_dwHiddenSize; i++ ) + { + for( j = 0; j < m_dwInputSize; j++ ) + { + hiddenActivations[i] += m_vvdKohonenMatrix[i][j] * inputVector[j]; + } + } + + // determine the winning hidden layer neuron + // (the one with the maximum activation) + int winningIndex = 0; + double maxActivation = hiddenActivations[0]; + + for( i = 0; i < m_dwHiddenSize; i++ ) + { + if(hiddenActivations[i] > maxActivation ) + { + maxActivation = hiddenActivations[i]; + winningIndex = i; + } + } + + // calculate the output vector + // (the synaptic connections from the winning hidden neuron + // to the output layer) + for( i = 0; i < m_dwOutputSize; i++ ) + { + outputVector[i] = m_vvdGrossbergMatrix[i][winningIndex]; + } + + return outputVector; +} + +void CounterpropNetwork::printMatrix() +{ + DWORD i, j; + // print Kohonen weights + printf("Kohonen matrix:"); + for( i = 0; i < m_dwHiddenSize; i++ ) + { + for( j = 0; j < m_dwInputSize; j++ ) + printf( "%f ", m_vvdKohonenMatrix[i][j] ); + + printf("\n"); + } + + // print Grossberg weights + for( i = 0; i < m_dwOutputSize; i++ ) + { + for( j = 0; j < m_dwHiddenSize; j++ ) + { + printf( "%f ", m_vvdGrossbergMatrix[i][j] ); + } + printf("\n"); + } +} + + +void CounterpropNetwork::updateKohonenWeights( int hiddenIndex, vector& inputVector ) +{ + DWORD i; + + for( i = 0; i < m_dwInputSize; i++ ) + { + m_vvdKohonenMatrix[hiddenIndex][i] += m_dbKohonenLearningRate * (inputVector[i] - m_vvdKohonenMatrix[hiddenIndex][i]); + } +} + + +void CounterpropNetwork::updateGrossbergWeights( DWORD hiddenIndex, double hiddenActivation, vector& outputVector ) +{ + DWORD i; + + for( i = 0; i < m_dwOutputSize; i++ ) + { + m_vvdGrossbergMatrix[i][hiddenIndex] += m_dbGrossbergLearningRate * ( outputVector[i] - m_vvdGrossbergMatrix[i][hiddenIndex] ); + } +} + +int CounterpropNetwork::getWinningHiddenIndex(vector& vd_inputVector) +{ + int theWinningIndex = -1; + double minimumDistance = DBL_MAX; + double distance; + DWORD i, j; + + for( i = 0; i < m_dwHiddenSize; i++ ) + { + + // compute the distance between the synaptic weights and + // the input vector + distance = 0.0; + + for( j = 0; j < m_dwInputSize; j++) + { + distance += pow( ( m_vvdKohonenMatrix[i][j] - vd_inputVector[j] ), 2 ); + } + + distance = pow(distance, .5); + + // scale this distance to inhibit the neuron from winning again + distance *= fabs( 1 + ( (double)m_viNumberOfWins[i] * m_dbInhibitingFactor ) ); + + if( distance < minimumDistance ) + { + minimumDistance = distance; + theWinningIndex = i; + } + } + + return theWinningIndex; +} + +void CounterpropNetwork::normalize( vector& vd_inputVector ) +{ + unsigned int i; + double sum = 0; + double norm; + + for( i = 0; i < vd_inputVector.size(); i++ ) + sum += pow( vd_inputVector[i], 2 ); + + norm = pow( sum, 0.5 ); + + for( i = 0; i < vd_inputVector.size(); i++ ) + vd_inputVector[i] /= norm; +}