depd-v3 1.1.0 → 1.2.0

package/astar.py

@@ -0,0 +1,93 @@
+def aStarAlgo(start_node, stop_node):
+    open_set = set(start_node)
+    closed_set = set()
+    g = {}          
+    parents = {}    
+    g[start_node] = 0
+
+    parents[start_node] = start_node
+
+    while len(open_set) > 0:
+        n = None
+
+        for v in open_set:
+            if n == None or g[v] + heuristic(v) < g[n] + heuristic(n):
+                n = v
+
+        if n == stop_node or Graph_nodes[n] == None:
+            pass
+        else:
+            for (m, weight) in get_neighbors(n):
+                if m not in open_set and m not in closed_set:
+                    open_set.add(m)
+                    parents[m] = n
+                    g[m] = g[n] + weight
+
+                else:
+                    if g[m] > g[n] + weight:
+                        g[m] = g[n] + weight
+
+                        parents[m] = n
+
+                        if m in closed_set:
+                            closed_set.remove(m)
+                            open_set.add(m)
+
+        if n == None:
+            print('Path does not exist!')
+            return None
+
+        if n == stop_node:
+            path = []
+
+            while parents[n] != n:
+                path.append(n)
+                n = parents[n]
+
+            path.append(start_node)
+            path.reverse()
+
+            print('Path found: {}'.format(path))
+            return path
+
+        open_set.remove(n)
+        closed_set.add(n)
+
+    print('Path does not exist!')
+    return None
+
+def get_neighbors(v):
+    if v in Graph_nodes:
+        return Graph_nodes[v]
+    else:
+        return None
+
+def heuristic(n):
+    H_dist = {
+        'A': 11,
+        'B': 6,
+        'C': 5,
+        'D': 7,
+        'E': 3,
+        'F': 6,
+        'G': 5,
+        'H': 3,
+        'I': 1,
+        'J': 0
+    }
+
+    return H_dist[n]
+
+Graph_nodes = {
+    'A': [('B', 6), ('F', 3)],
+    'B': [('A', 6), ('C', 3), ('D', 2)],
+    'C': [('B', 3), ('D', 1), ('E', 5)],
+    'D': [('B', 2), ('C', 1), ('E', 8)],
+    'E': [('C', 5), ('D', 8), ('I', 5), ('J', 5)],
+    'F': [('A', 3), ('G', 1), ('H', 7)],
+    'G': [('F', 1), ('I', 3)],
+    'H': [('F', 7), ('I', 2)],
+    'I': [('E', 5), ('G', 3), ('H', 2), ('J', 3)],
+}
+
+aStarAlgo('A', 'J')

package/bfs.py

@@ -0,0 +1,26 @@
+graph = {
+    'A': ['B', 'C'],
+    'B': ['D', 'E'],
+    'C': ['F'],
+    'D': [],
+    'E': ['F'],
+    'F': []
+}
+
+visited = []
+queue = []
+
+def bfs(graph, node):
+    visited.append(node)
+    queue.append(node)
+
+    while queue:
+        s = queue.pop(0)
+        print(s, end=" ")
+
+        for neighbour in graph[s]:
+            if neighbour not in visited:
+                visited.append(neighbour)
+                queue.append(neighbour)
+
+bfs(graph, 'A')

package/decisiontree.py

@@ -0,0 +1,22 @@
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score
+
+import pandas as pd
+
+sample_dataframe_df = pd.read_csv('Loan_Repay_Dataset.csv')
+
+x = sample_dataframe_df.drop(['Result'], axis=1)
+y = sample_dataframe_df['Result']
+
+train_x, test_x, train_y, test_y = train_test_split(
+    x, y, test_size=0.2, random_state=100
+)
+
+estimated = DecisionTreeClassifier().fit(train_x, train_y)
+
+predict_y = estimated.predict(test_x)
+
+print(predict_y)
+
+print(accuracy_score(test_y, predict_y))

package/dfs.py

@@ -0,0 +1,20 @@
+graph = {
+    'A': ['B', 'C'],
+    'B': ['D', 'E'],
+    'C': ['F'],
+    'D': [],
+    'E': ['F'],
+    'F': []
+}
+
+visited = set()
+
+def dfs(node):
+    if node not in visited:
+        print(node, end=" ")
+        visited.add(node)
+
+        for neighbour in graph[node]:
+            dfs(neighbour)
+
+dfs('A')

package/knn.py

@@ -0,0 +1,28 @@
+#k nearest
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.model_selection import train_test_split
+import pandas as pd
+
+sample_dataframe_df = pd.read_csv('Iris.csv')
+
+sample_dataframe_df.head(5)
+sample_dataframe_df['Species'].value_counts()
+
+x = sample_dataframe_df.drop(['Id', 'Species'], axis=1)
+y = sample_dataframe_df['Species']
+
+x.head(5)
+y.head(5)
+
+train_x, test_x, train_y, test_y = train_test_split(
+    x,
+    y,
+    train_size=0.8,
+    random_state=80
+)
+
+knn = KNeighborsClassifier(n_neighbors=5)
+
+knn.fit(train_x, train_y)
+
+knn.score(test_x, test_y)

package/lab.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "56190fb8",
    "metadata": {},
    "outputs": [
@@ -351,7 +351,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 9,
    "id": "9a277da3",
    "metadata": {},
    "outputs": [
@@ -359,16 +359,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[0 0 1 0 0 1 1 1 0 0 0 1 0 1 1 0 1 0 0 0 1 1 0 0 0 0 1 1 1 1 0 1 1 1 1 1 1\n",
+      "[0 0 1 0 0 1 1 1 0 0 0 1 0 1 1 0 1 0 0 0 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1\n",
       " 0 0 0]\n",
-      "0.725\n"
+      "0.75\n"
      ]
     }
    ],
    "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "\n",
     "from sklearn.model_selection import train_test_split\n",
     "from sklearn.tree import DecisionTreeClassifier\n",
     "from sklearn.metrics import accuracy_score\n",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "depd-v3",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "",
   "license": "ISC",
   "author": "",

package/pandas_lab.py

@@ -0,0 +1,26 @@
+import pandas as pd
+
+sample_dataframe_df = pd.read_csv('Iris.csv')
+
+type(sample_dataframe_df)
+
+sample_dataframe_df.head(5)
+
+list(sample_dataframe_df.columns)
+
+sample_dataframe_df.head(5).transpose()
+
+sample_dataframe_df.shape
+
+sample_dataframe_df[0:10]
+
+sample_dataframe_df[-5:]
+
+sample_dataframe_df['SepalLengthCm']
+
+sample_dataframe_df.SepalLengthCm.value_count
+
+sample_dataframe_df[sample_dataframe_df['PetalLengthCm']>6]
+
+sample_dataframe_df.drop('Si.no', inplace=True, axis=1)
+list(sample_dataframe_df.columns)

package/waterjug.py

@@ -0,0 +1,26 @@
+#water jug bfs - use pop() for dfs
+from collections import deque
+
+def bfs(a, b, target):
+    q = deque([(0, 0)])
+    visited = set()
+
+    while q:
+        x, y = q.popleft()
+        if (x, y) in visited:
+            continue
+
+        visited.add((x, y))
+        print(x, y)
+
+        if x == target or y == target:
+            print("target reached")
+            break
+
+        q.extend([
+            (a, y), (x, b), (0, y), (x, 0),
+            (x - min(x, b - y), y + min(x, b - y)),
+            (x + min(y, a - x), y - min(y, a - x))
+        ])
+
+bfs(4, 3, 2)