sickittit-learno 3.0.1__tar.gz

sickittit-learno-3.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include sickittit_learno/data/*.csv
+recursive-include sickittit_learno/practicals *.py

sickittit-learno-3.0.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: sickittit-learno
+Version: 3.0.1
+Summary: AI Practicals cheatsheet (print code + fetch ready-made data files)
+Home-page: UNKNOWN
+Author: Anant Prajapati
+License: UNKNOWN
+Platform: UNKNOWN
+Requires-Python: >=3.9
+
+UNKNOWN
+

sickittit-learno-3.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sickittit-learno-3.0.1/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="sickittit-learno",
+    version="3.0.1",
+    author="Anant Prajapati",
+    description="AI Practicals cheatsheet (print code + fetch ready-made data files)",
+    packages=find_packages(),
+    python_requires=">=3.9",
+    entry_points={
+        "console_scripts": [
+            "sickittit-learno=sickittit_learno.practs:main",
+            "sickittit_learno=sickittit_learno.practs:main",
+        ],
+    },
+    include_package_data=True,
+    package_data={
+        "sickittit_learno.practicals": ["*.py"],
+        "sickittit_learno.data": ["*.csv"],
+    },
+    install_requires=[],
+)

sickittit-learno-3.0.1/sickittit_learno/__init__.py

@@ -0,0 +1,4 @@
+from .practs import list_all, show, get_data, list_data
+
+__all__ = ["list_all", "show", "get_data", "list_data"]
+__version__ = "3.0.1"

sickittit-learno-3.0.1/sickittit_learno/data/student.csv

@@ -0,0 +1,21 @@
+Hours,Attendance,Result
+1,55,Fail
+2,60,Fail
+2,50,Fail
+3,65,Fail
+3,70,Fail
+4,60,Fail
+4,75,Pass
+5,80,Pass
+5,72,Pass
+6,78,Pass
+6,85,Pass
+7,88,Pass
+7,80,Pass
+8,90,Pass
+8,95,Pass
+9,92,Pass
+9,98,Pass
+10,99,Pass
+2,45,Fail
+3,58,Fail

sickittit-learno-3.0.1/sickittit_learno/data/student_marks.csv

@@ -0,0 +1,21 @@
+Hours,Marks
+1,18
+2,25
+3,33
+4,41
+5,50
+6,56
+7,64
+8,70
+9,78
+10,86
+2,22
+3,30
+4,38
+5,47
+6,58
+7,62
+8,73
+9,80
+1,15
+10,88

sickittit-learno-3.0.1/sickittit_learno/practicals/p01_reflex_vacuum.py

@@ -0,0 +1,34 @@
+# ============================================================
+# Practical 1: Simple Reflex Agent — Table-Driven Vacuum Cleaner Agent
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p01_reflex_vacuum.py
+#   NOTE: this program asks for keyboard input while it runs.
+# ============================================================
+
+rooms = {}
+rooms['A'] = input("Enter status of Room A (Clean/Dirty): ")
+rooms['B'] = input("Enter status of Room B (Clean/Dirty): ")
+
+if rooms['A'] == "Clean" and rooms['B'] == "Clean":
+    print("\nAll rooms are already clean. Task completed.")
+else:
+    if rooms['A'] == "Dirty":
+        print("\nRoom A is Dirty")
+        print("Action: Suck")
+        rooms['A'] = "Clean"
+        print("Room A cleaned")
+    else:
+        print("\nRoom A is already Clean")
+
+    if rooms['B'] == "Dirty":
+        print("\nRoom B is Dirty")
+        print("Action: Suck")
+        rooms['B'] = "Clean"
+        print("Room B cleaned")
+    else:
+        print("\nRoom B is already Clean")
+
+    if rooms['A'] == "Clean" and rooms['B'] == "Clean":
+        print("\nAll rooms are clean. Task completed.")

sickittit-learno-3.0.1/sickittit_learno/practicals/p02_bfs_8puzzle.py

@@ -0,0 +1,92 @@
+# ============================================================
+# Practical 2: BFS — 8-Puzzle Solver
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p02_bfs_8puzzle.py
+# ============================================================
+
+from collections import deque
+
+def print_state(state):
+    for i in range(0, 9, 3):
+        print(state[i], state[i+1], state[i+2])
+    print()
+
+def get_blank_index(state):
+    return state.index(0)
+
+def get_neighbors(state):
+    neighbors = []
+    blank_index = state.index(0)
+
+    moves = {
+        "Up": -3,
+        "Down": 3,
+        "Left": -1,
+        "Right": 1
+    }
+
+    for move, position_change in moves.items():
+        if move == "Up" and blank_index < 3:
+            continue
+        if move == "Down" and blank_index > 5:
+            continue
+        if move == "Left" and blank_index % 3 == 0:
+            continue
+        if move == "Right" and blank_index % 3 == 2:
+            continue
+
+        new_index = blank_index + position_change
+
+        new_state = list(state)
+        new_state[blank_index], new_state[new_index] = new_state[new_index], new_state[blank_index]
+        neighbors.append((tuple(new_state), move))
+
+    return neighbors
+
+def bfs(initial_state, goal_state):
+    queue = deque()
+    queue.append((initial_state, []))
+    visited = set()
+    visited.add(initial_state)
+
+    while queue:
+        current_state, path = queue.popleft()
+
+        if current_state == goal_state:
+            return path
+
+        for neighbor, move in get_neighbors(current_state):
+            if neighbor not in visited:
+                visited.add(neighbor)
+                queue.append((neighbor, path + [(move, neighbor)]))
+
+    return None
+
+initial_state = (1, 2, 3,
+                  4, 0, 6,
+                  7, 5, 8)
+goal_state = (1, 2, 3,
+              4, 5, 6,
+              7, 8, 0)
+
+print("Initial State:")
+print_state(initial_state)
+
+print("Goal State:")
+print_state(goal_state)
+
+solution = bfs(initial_state, goal_state)
+
+if solution:
+    print("Shortest sequence of moves:")
+    current_step = 1
+    for move, state in solution:
+        print(f"Step {current_step} - Move: {move}")
+        print_state(state)
+        current_step += 1
+    print("Goal reached successfully.")
+    print("Total number of moves:", len(solution))
+else:
+    print("No solution found.")

sickittit-learno-3.0.1/sickittit_learno/practicals/p03_dfs_waterjug.py

@@ -0,0 +1,47 @@
+# ============================================================
+# Practical 3: DFS — Water Jug Problem (4L and 3L jugs)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p03_dfs_waterjug.py
+#   NOTE: this program asks for keyboard input while it runs.
+# ============================================================
+
+j1 = int(input("Enter capacity of Jug 1: "))
+j2 = int(input("Enter capacity of Jug 2: "))
+goal = int(input("Enter target amount: "))
+
+visited = set()
+path = []
+
+def dfs(x, y):
+    if (x, y) in visited:
+        return False
+    visited.add((x, y))
+    path.append((x, y))
+
+    if x == goal or y == goal:
+        print("\nGoal Achieved Successfully!")
+        print("Solution Path:")
+        for state in path:
+            print(state)
+        return True
+
+    next_states = [
+        (j1, y),
+        (x, j2),
+        (0, y),
+        (x, 0),
+        (x - min(x, j2 - y), y + min(x, j2 - y)),
+        (x + min(y, j1 - x), y - min(y, j1 - x)),
+    ]
+
+    for (nx, ny) in next_states:
+        if dfs(nx, ny):
+            return True
+
+    path.pop()
+    return False
+
+if not dfs(0, 0):
+    print("No solution found")

sickittit-learno-3.0.1/sickittit_learno/practicals/p04_ucs_citygraph.py

@@ -0,0 +1,40 @@
+# ============================================================
+# Practical 4: Uniform Cost Search (UCS) — Weighted City Graph
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p04_ucs_citygraph.py
+# ============================================================
+
+import heapq
+
+graph = {
+    'Mumbai': [('Pune', 150), ('Hyderabad', 710)],
+    'Pune': [('Mumbai', 150), ('Bangalore', 840)],
+    'Hyderabad': [('Mumbai', 710), ('Bangalore', 570)],
+    'Bangalore': []
+}
+
+def ucs(start, goal):
+    queue = [(0, start, [start])]
+    visited = []
+
+    while queue:
+        cost, city, path = heapq.heappop(queue)
+
+        if city == goal:
+            return cost, path
+
+        if city not in visited:
+            visited.append(city)
+            for neighbor, distance in graph[city]:
+                if neighbor not in visited:
+                    heapq.heappush(queue, (cost + distance, neighbor, path + [neighbor]))
+
+    return None
+
+cost, path = ucs("Mumbai", "Bangalore")
+
+print("Least-cost path:")
+print("Path:", " -> ".join(path))
+print("Total Distance:", cost, "km")

sickittit-learno-3.0.1/sickittit_learno/practicals/p05_greedy_8puzzle.py

@@ -0,0 +1,83 @@
+# ============================================================
+# Practical 5: Greedy Best-First Search — 8-Puzzle (Manhattan Heuristic)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p05_greedy_8puzzle.py
+# ============================================================
+
+import heapq
+
+def heuristic(state, goal):
+    distance = 0
+    for num in range(1, 9):
+        current = state.index(num)
+        target = goal.index(num)
+        x1, y1 = current // 3, current % 3
+        x2, y2 = target // 3, target % 3
+        distance += abs(x1 - x2) + abs(y1 - y2)
+    return distance
+
+def print_state(state):
+    for i in range(0, 9, 3):
+        print(state[i], state[i+1], state[i+2])
+    print()
+def get_neighbors(state):
+    neighbors = []
+    blank = state.index(0)
+    moves = [-3, 3, -1, 1]
+
+    for move in moves:
+        new = blank + move
+        if new < 0 or new >= 9:
+            continue
+        if blank % 3 == 0 and move == -1:
+            continue
+        if blank % 3 == 2 and move == 1:
+            continue
+
+        new_state = list(state)
+        new_state[blank], new_state[new] = new_state[new], new_state[blank]
+        neighbors.append(tuple(new_state))
+
+    return neighbors
+
+def greedy(initial, goal):
+    queue = []
+    heapq.heappush(queue, (heuristic(initial, goal), initial, []))
+    visited = set()
+
+    while queue:
+        h, state, path = heapq.heappop(queue)
+
+        if state == goal:
+            return path + [state]
+
+        if state not in visited:
+            visited.add(state)
+            for next_state in get_neighbors(state):
+                heapq.heappush(queue, (heuristic(next_state, goal), next_state, path + [state]))
+
+    return None
+
+initial = (1, 2, 3,
+           7, 5, 8,
+           4, 0, 6)
+goal = (1, 2, 3,
+        4, 5, 6,
+        7, 8, 0)
+
+print("Initial State:")
+print_state(initial)
+print("Goal State:")
+print_state(goal)
+
+solution = greedy(initial, goal)
+
+if solution:
+    for step, state in enumerate(solution):
+        print(f"Step {step}")
+        print_state(state)
+    print("Goal reached successfully.")
+else:
+    print("No solution found.")

sickittit-learno-3.0.1/sickittit_learno/practicals/p06_astar_8puzzle.py

@@ -0,0 +1,91 @@
+# ============================================================
+# Practical 6: A* Search — 8-Puzzle (Manhattan Heuristic)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p06_astar_8puzzle.py
+# ============================================================
+
+import heapq
+
+def heuristic(state, goal):
+    distance = 0
+    for num in range(1, 9):
+        current = state.index(num)
+        target = goal.index(num)
+        x1, y1 = current // 3, current % 3
+        x2, y2 = target // 3, target % 3
+        distance += abs(x1 - x2) + abs(y1 - y2)
+    return distance
+
+def print_state(state):
+    for i in range(0, 9, 3):
+        print(state[i], state[i+1], state[i+2])
+    print()
+
+def get_neighbors(state):
+    neighbors = []
+    blank = state.index(0)
+    moves = [-3, 3, -1, 1]
+
+    for move in moves:
+        new = blank + move
+        if new < 0 or new >= 9:
+            continue
+        if blank % 3 == 0 and move == -1:
+            continue
+        if blank % 3 == 2 and move == 1:
+            continue
+
+        new_state = list(state)
+        new_state[blank], new_state[new] = new_state[new], new_state[blank]
+        neighbors.append(tuple(new_state))
+
+    return neighbors
+
+def astar(initial, goal):
+    queue = []
+    heapq.heappush(queue, (heuristic(initial, goal), 0, initial, [initial]))
+    visited = set()
+
+    while queue:
+        f, g, state, path = heapq.heappop(queue)
+
+        if state == goal:
+            return path
+
+        if state not in visited:
+            visited.add(state)
+            for next_state in get_neighbors(state):
+                if next_state not in visited:
+                    new_g = g + 1
+                    new_f = new_g + heuristic(next_state, goal)
+                    heapq.heappush(queue, (new_f, new_g, next_state, path + [next_state]))
+
+    return None
+
+initial = (1, 2, 3,
+           7, 5, 8,
+           4, 0, 6)
+goal = (1, 2, 3,
+        4, 5, 6,
+        7, 8, 0)
+
+print("Initial State:")
+print_state(initial)
+print("Goal State:")
+print_state(goal)
+
+solution = astar(initial, goal)
+
+if solution:
+    print("Shortest Path using A* Search:")
+    step = 1
+    for state in solution[1:]:
+        print(f"Step {step}")
+        print_state(state)
+        step += 1
+    print("Goal reached successfully.")
+    print("Total number of moves:", len(solution) - 1)
+else:
+    print("No solution found.")

sickittit-learno-3.0.1/sickittit_learno/practicals/p07_astar_romania.py

@@ -0,0 +1,58 @@
+# ============================================================
+# Practical 7: A* Search — Weighted Graph (Arad to Bucharest, Straight-Line Heuristic)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p07_astar_romania.py
+# ============================================================
+
+import heapq
+
+graph = {
+    'Arad': [('Zerind', 75), ('Sibiu', 140), ('Timisoara', 118)],
+    'Zerind': [('Arad', 75), ('Oradea', 71)],
+    'Oradea': [('Zerind', 71), ('Sibiu', 151)],
+    'Sibiu': [('Arad', 140), ('Oradea', 151), ('Fagaras', 99), ('Rimnicu Vilcea', 80)],
+    'Timisoara': [('Arad', 118), ('Lugoj', 111)],
+    'Lugoj': [('Timisoara', 111), ('Mehadia', 70)],
+    'Mehadia': [('Lugoj', 70), ('Drobeta', 75)],
+    'Drobeta': [('Mehadia', 75), ('Craiova', 120)],
+    'Craiova': [('Drobeta', 120), ('Rimnicu Vilcea', 146), ('Pitesti', 138)],
+    'Rimnicu Vilcea': [('Sibiu', 80), ('Craiova', 146), ('Pitesti', 97)],
+    'Fagaras': [('Sibiu', 99), ('Bucharest', 211)],
+    'Pitesti': [('Rimnicu Vilcea', 97), ('Craiova', 138), ('Bucharest', 101)],
+    'Bucharest': []
+}
+
+heuristic = {
+    'Arad': 366, 'Zerind': 374, 'Oradea': 380, 'Sibiu': 253,
+    'Timisoara': 329, 'Lugoj': 244, 'Mehadia': 241, 'Drobeta': 242,
+    'Craiova': 160, 'Rimnicu Vilcea': 193, 'Fagaras': 176,
+    'Pitesti': 100, 'Bucharest': 0
+}
+
+def astar(start, goal):
+    queue = [(heuristic[start], 0, start, [start])]
+    visited = set()
+
+    while queue:
+        f, g_cost, city, path = heapq.heappop(queue)
+
+        if city == goal:
+            return g_cost, path
+
+        if city not in visited:
+            visited.add(city)
+            for neighbor, distance in graph[city]:
+                if neighbor not in visited:
+                    new_g = g_cost + distance
+                    new_f = new_g + heuristic[neighbor]
+                    heapq.heappush(queue, (new_f, new_g, neighbor, path + [neighbor]))
+
+    return None, []
+
+cost, path = astar('Arad', 'Bucharest')
+
+print("Shortest path using A* Search:")
+print("Path:", " -> ".join(path))
+print("Total Cost:", cost)

sickittit-learno-3.0.1/sickittit_learno/practicals/p08_bayes_medical.py

@@ -0,0 +1,20 @@
+# ============================================================
+# Practical 8: Bayes' Rule — Medical Test Probability
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Run this file:
+#        python p08_bayes_medical.py
+# ============================================================
+
+P_D = 0.01
+
+P_NotD = 1 - P_D
+
+P_Pos_D = 0.99
+
+P_Pos_NotD = 0.05
+
+P_D_Pos = (P_Pos_D * P_D) / ((P_Pos_D * P_D) + (P_Pos_NotD * P_NotD))
+
+print("Probability that person actually has disease:")
+print(round(P_D_Pos * 100, 2), "%")

sickittit-learno-3.0.1/sickittit_learno/practicals/p09_naivebayes_weather.py

@@ -0,0 +1,43 @@
+# ============================================================
+# Practical 9: Naive Bayes' Classification — Weather Dataset
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install pandas scikit-learn
+#   2. Run this file:
+#        python p09_naivebayes_weather.py
+# ============================================================
+
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+from sklearn.naive_bayes import GaussianNB
+
+data = {
+    'Outlook': ['Sunny','Sunny','Overcast','Rainy','Rainy','Rainy','Overcast','Sunny','Sunny','Rainy'],
+    'Temperature': ['Hot','Hot','Hot','Mild','Cool','Cool','Cool','Mild','Cool','Mild'],
+    'Humidity': ['High','High','High','High','Normal','Normal','Normal','High','Normal','Normal'],
+    'Windy': ['False','True','False','False','False','True','True','False','False','False'],
+    'Play': ['No','No','Yes','Yes','Yes','No','Yes','No','Yes','Yes']
+}
+
+df = pd.DataFrame(data)
+
+le = LabelEncoder()
+for col in df.columns:
+    df[col] = le.fit_transform(df[col])
+
+X = df[['Outlook','Temperature','Humidity','Windy']]
+y = df['Play']
+
+model = GaussianNB()
+model.fit(X, y)
+
+test = pd.DataFrame([[2, 0, 0, 0]],
+    columns=['Outlook', 'Temperature', 'Humidity', 'Windy'])
+
+prediction = model.predict(test)
+
+if prediction[0] == 1:
+    print("Prediction: Yes, we can play")
+else:
+    print("Prediction: No, we cannot play")

sickittit-learno-3.0.1/sickittit_learno/practicals/p10_bayesnet_burglary.py

@@ -0,0 +1,81 @@
+# ============================================================
+# Practical 10: Bayesian Network (Burglary–Alarm) with pgmpy
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install pgmpy
+#   2. Run this file:
+#        python p10_bayesnet_burglary.py
+# ============================================================
+
+from pgmpy.models import DiscreteBayesianNetwork
+from pgmpy.factors.discrete import TabularCPD
+from pgmpy.inference import VariableElimination
+
+model = DiscreteBayesianNetwork([
+    ("Burglary", "Alarm"),
+    ("Earthquake", "Alarm"),
+    ("Alarm", "JohnCalls"),
+    ("Alarm", "MaryCalls")
+])
+
+cpd_burglary = TabularCPD(
+    variable="Burglary",
+    variable_card=2,
+    values=[[0.999], [0.001]],
+    state_names={"Burglary": ["False", "True"]}
+)
+
+cpd_earthquake = TabularCPD(
+    variable="Earthquake",
+    variable_card=2,
+    values=[[0.998], [0.002]],
+    state_names={"Earthquake": ["False", "True"]}
+)
+
+cpd_alarm = TabularCPD(
+    variable="Alarm",
+    variable_card=2,
+    values=[
+        [0.999, 0.71, 0.06, 0.05],
+        [0.001, 0.29, 0.94, 0.95]
+    ],
+    evidence=["Burglary", "Earthquake"],
+    evidence_card=[2, 2],
+    state_names={
+        "Alarm": ["False", "True"],
+        "Burglary": ["False", "True"],
+        "Earthquake": ["False", "True"]
+    }
+)
+
+cpd_john = TabularCPD(
+    variable="JohnCalls",
+    variable_card=2,
+    values=[[0.95, 0.10], [0.05, 0.90]],
+    evidence=["Alarm"],
+    evidence_card=[2],
+    state_names={"JohnCalls": ["False", "True"], "Alarm": ["False", "True"]}
+)
+
+cpd_mary = TabularCPD(
+    variable="MaryCalls",
+    variable_card=2,
+    values=[[0.99, 0.30], [0.01, 0.70]],
+    evidence=["Alarm"],
+    evidence_card=[2],
+    state_names={"MaryCalls": ["False", "True"], "Alarm": ["False", "True"]}
+)
+
+model.add_cpds(cpd_burglary, cpd_earthquake, cpd_alarm, cpd_john, cpd_mary)
+
+print("Is Bayesian Network valid?", model.check_model())
+
+inference = VariableElimination(model)
+
+print("\nProbability of Burglary given JohnCalls=True and MaryCalls=True:")
+result = inference.query(
+    variables=["Burglary"],
+    evidence={"JohnCalls": "True", "MaryCalls": "True"}
+)
+print(result)

sickittit-learno-3.0.1/sickittit_learno/practicals/p11_bayesnet_posterior.py

@@ -0,0 +1,62 @@
+# ============================================================
+# Practical 11: Bayesian Network — Posterior Probability P(Burglary | Alarm = True)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install pgmpy
+#   2. Run this file:
+#        python p11_bayesnet_posterior.py
+# ============================================================
+
+from pgmpy.models import DiscreteBayesianNetwork
+from pgmpy.factors.discrete import TabularCPD
+from pgmpy.inference import VariableElimination
+
+model = DiscreteBayesianNetwork([
+    ("Burglary", "Alarm"),
+    ("Earthquake", "Alarm")
+])
+
+cpd_burglary = TabularCPD(
+    variable="Burglary",
+    variable_card=2,
+    values=[[0.999], [0.001]],
+    state_names={"Burglary": ["False", "True"]}
+)
+
+cpd_earthquake = TabularCPD(
+    variable="Earthquake",
+    variable_card=2,
+    values=[[0.998], [0.002]],
+    state_names={"Earthquake": ["False", "True"]}
+)
+
+cpd_alarm = TabularCPD(
+    variable="Alarm",
+    variable_card=2,
+    values=[
+        [0.999, 0.71, 0.06, 0.05],
+        [0.001, 0.29, 0.94, 0.95]
+    ],
+    evidence=["Burglary", "Earthquake"],
+    evidence_card=[2, 2],
+    state_names={
+        "Alarm": ["False", "True"],
+        "Burglary": ["False", "True"],
+        "Earthquake": ["False", "True"]
+    }
+)
+
+model.add_cpds(cpd_burglary, cpd_earthquake, cpd_alarm)
+
+print("Is Bayesian Network valid?", model.check_model())
+
+inference = VariableElimination(model)
+
+print("\nPosterior Probability:")
+result = inference.query(
+    variables=["Burglary"],
+    evidence={"Alarm": "True"}
+)
+print(result)
+

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_1_ml_student_csv.py

@@ -0,0 +1,43 @@
+# ============================================================
+# Practical 12.1: Machine Learning Workflow — CSV Dataset (student.csv)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install pandas scikit-learn
+#   2. Get the data file (one line, from this library):
+#        from sickittit_learno import get_data; get_data("student.csv")
+#   3. Run this file:
+#        python p12_1_ml_student_csv.py
+# ============================================================
+
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import accuracy_score
+
+data = pd.read_csv("student.csv")
+print("Dataset:")
+print(data)
+
+le = LabelEncoder()
+data["Result"] = le.fit_transform(data["Result"])
+
+X = data[["Hours", "Attendance"]]
+y = data["Result"]
+
+scaler = StandardScaler()
+X = scaler.fit_transform(X)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=1)
+
+model = KNeighborsClassifier()
+model.fit(X_train, y_train)
+
+train_pred = model.predict(X_train)
+test_pred = model.predict(X_test)
+
+print("\nTraining Accuracy:", accuracy_score(y_train, train_pred) * 100)
+print("Testing Accuracy:", accuracy_score(y_test, test_pred) * 100)

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_2_linreg_marks.py

@@ -0,0 +1,33 @@
+# ============================================================
+# Practical 12.2: Linear Regression — Student Study Hours Dataset (student_marks.csv)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install pandas scikit-learn
+#   2. Get the data file (one line, from this library):
+#        from sickittit_learno import get_data; get_data("student_marks.csv")
+#   3. Run this file:
+#        python p12_2_linreg_marks.py
+# ============================================================
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+
+data = pd.read_csv("student_marks.csv")
+
+X = data[["Hours"]]
+y = data["Marks"]
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=1)
+
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+print("Training Accuracy:", round(model.score(X_train, y_train) * 100, 2))
+print("Testing Accuracy:", round(model.score(X_test, y_test) * 100, 2))
+
+new_data = pd.DataFrame([[11]], columns=["Hours"])
+pred = model.predict(new_data)
+print("Predicted Marks for 11 hours:", round(pred[0], 2))

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_3_mnist_binary.py

@@ -0,0 +1,33 @@
+# ============================================================
+# Practical 12.3: Binary Classifier — MNIST Dataset (Digit 5 vs Not Digit 5)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install scikit-learn
+#   2. Run this file:
+#        python p12_3_mnist_binary.py
+# ============================================================
+
+from sklearn.datasets import load_digits
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+
+digits = load_digits()
+
+X = digits.data
+y = (digits.target == 5)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=1)
+
+model = LogisticRegression(max_iter=1000)
+model.fit(X_train, y_train)
+
+print("Training Accuracy:", model.score(X_train, y_train) * 100)
+print("Testing Accuracy:", model.score(X_test, y_test) * 100)
+
+prediction = model.predict([X_test[0]])
+if prediction[0]:
+    print("Digit is 5")
+else:
+    print("Digit is not 5")

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_4_kfold_iris.py

@@ -0,0 +1,25 @@
+# ============================================================
+# Practical 12.4: K-Fold Cross-Validation on a Classification Model (Iris + KNN)
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install scikit-learn
+#   2. Run this file:
+#        python p12_4_kfold_iris.py
+# ============================================================
+
+from sklearn.datasets import load_iris
+from sklearn.model_selection import cross_val_score
+from sklearn.neighbors import KNeighborsClassifier
+
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+model = KNeighborsClassifier()
+
+scores = cross_val_score(model, X, y, cv=5)
+
+print("Accuracy scores for each fold:")
+print(scores)
+print("Average Accuracy:", round(scores.mean() * 100, 2), "%")

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_5_dtree_iris.py

@@ -0,0 +1,30 @@
+# ============================================================
+# Practical 12.5: Decision Tree Classifier — Iris Dataset
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install scikit-learn
+#   2. Run this file:
+#        python p12_5_dtree_iris.py
+# ============================================================
+
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=1)
+
+model = DecisionTreeClassifier()
+
+model.fit(X_train, y_train)
+
+print("Training Accuracy:", model.score(X_train, y_train) * 100)
+print("Testing Accuracy:", model.score(X_test, y_test) * 100)
+
+prediction = model.predict([X_test[0]])
+print("Predicted Class:", prediction[0])

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_6_dtree_reg_marks.py

@@ -0,0 +1,34 @@
+# ============================================================
+# Practical 12.6: Decision Tree Regression — student_marks.csv
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install pandas scikit-learn
+#   2. Get the data file (one line, from this library):
+#        from sickittit_learno import get_data; get_data("student_marks.csv")
+#   3. Run this file:
+#        python p12_6_dtree_reg_marks.py
+# ============================================================
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeRegressor
+
+data = pd.read_csv("student_marks.csv")
+
+X = data[["Hours"]]
+y = data["Marks"]
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=1)
+
+model = DecisionTreeRegressor()
+
+model.fit(X_train, y_train)
+
+print("Training Accuracy:", model.score(X_train, y_train) * 100)
+print("Testing Accuracy:", model.score(X_test, y_test) * 100)
+
+new_data = pd.DataFrame([[11]], columns=["Hours"])
+prediction = model.predict(new_data)
+print("Predicted Marks for 11 Hours:", prediction[0])

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_7_knn_iris.py

@@ -0,0 +1,30 @@
+# ============================================================
+# Practical 12.7: K-Nearest Neighbors (KNN) Classifier — Iris Dataset
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install scikit-learn
+#   2. Run this file:
+#        python p12_7_knn_iris.py
+# ============================================================
+
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=1)
+
+model = KNeighborsClassifier(n_neighbors=3)
+
+model.fit(X_train, y_train)
+
+print("Training Accuracy:", model.score(X_train, y_train) * 100)
+print("Testing Accuracy:", model.score(X_test, y_test) * 100)
+
+prediction = model.predict([X_test[0]])
+print("Predicted Class:", prediction[0])

sickittit-learno-3.0.1/sickittit_learno/practicals/p12_8_multiclass_dtree_iris.py

@@ -0,0 +1,30 @@
+# ============================================================
+# Practical 12.8: Multiclass Classification Using Decision Tree — Iris Dataset
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install scikit-learn
+#   2. Run this file:
+#        python p12_8_multiclass_dtree_iris.py
+# ============================================================
+
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=1)
+
+model = DecisionTreeClassifier()
+
+model.fit(X_train, y_train)
+
+print("Training Accuracy:", model.score(X_train, y_train) * 100)
+print("Testing Accuracy:", model.score(X_test, y_test) * 100)
+
+prediction = model.predict([X_test[0]])
+print("Predicted Class:", prediction[0])

sickittit-learno-3.0.1/sickittit_learno/practicals/p13_ethics_bias_iris.py

@@ -0,0 +1,31 @@
+# ============================================================
+# Practical 13: Ethics and Bias Analysis — Iris Dataset
+# ------------------------------------------------------------
+# HOW TO RUN
+#   1. Install dependencies:
+#        pip install pandas scikit-learn
+#   2. Run this file:
+#        python p13_ethics_bias_iris.py
+# ============================================================
+
+import pandas as pd
+from sklearn.datasets import load_iris
+
+iris = load_iris()
+data = pd.DataFrame(iris.data, columns=iris.feature_names)
+data['Class'] = iris.target
+
+print("First 5 records:")
+print(data.head())
+
+print("Class Distribution:")
+print(data['Class'].value_counts())
+
+print("Missing Values:")
+print(data.isnull().sum())
+
+print("Bias Analysis:")
+if data['Class'].value_counts().min() == data['Class'].value_counts().max():
+    print("Dataset is balanced.")
+else:
+    print("Dataset is imbalanced.")

sickittit-learno-3.0.1/sickittit_learno/practs.py

@@ -0,0 +1,133 @@
+"""sickittit_learno — Anant's AI Practicals cheatsheet.
+
+Quick use:
+    from sickittit_learno import list_all, show, get_data
+
+    list_all()                     # see every practical
+    show("p09_naivebayes_weather") # print a practical's code
+    get_data("student.csv")        # drop a required data file into your folder
+"""
+from importlib import resources
+import shutil
+import sys
+import os
+
+PKG_PRACTICALS = "sickittit_learno.practicals"
+PKG_DATA = "sickittit_learno.data"
+
+
+def _practical_files():
+    """Return sorted list of practical stems (filenames without .py)."""
+    root = resources.files(PKG_PRACTICALS)
+    names = []
+    for entry in root.iterdir():
+        n = entry.name
+        if n.endswith(".py") and not n.startswith("__"):
+            names.append(n[:-3])
+    return sorted(names)
+
+
+def _resolve(name):
+    """Match a user-typed name to an actual practical stem (forgiving)."""
+    name = name.strip()
+    if name.endswith(".py"):
+        name = name[:-3]
+    stems = _practical_files()
+    if name in stems:
+        return name
+    low = name.lower()
+    # exact case-insensitive
+    for s in stems:
+        if s.lower() == low:
+            return s
+    # match by the leading pNN / pNN_M token  (e.g. "p9", "9", "12.1", "p12_1")
+    token = low.replace("practical", "").replace("prac", "").strip()
+    token = token.lstrip("p").replace(".", "_").strip("_ ")
+    for s in stems:
+        head = s[1:].split("_")
+        # head like ['01'] or ['12','1']
+        norm = "_".join(str(int(x)) if x.isdigit() else x for x in head[:2] if x.isdigit())
+        if token == norm or token == norm.replace("_", ""):
+            return s
+    # substring fallback
+    for s in stems:
+        if low in s.lower():
+            return s
+    return None
+
+
+def list_all():
+    """List all available practicals."""
+    stems = _practical_files()
+    print("Available practicals (use show(\"<name>\") to print the code):\n")
+    for s in stems:
+        print("  -", s)
+    print("\nData files (use get_data(\"<file>\")):")
+    for d in list_data():
+        print("  -", d)
+
+
+def show(name):
+    """Print the full code of a practical."""
+    stem = _resolve(name)
+    if stem is None:
+        print(f"'{name}' not found. Run list_all() to see the available names.")
+        return
+    code = (resources.files(PKG_PRACTICALS) / f"{stem}.py").read_text(encoding="utf-8")
+    print(f"--- {stem} ---\n")
+    print(code)
+
+
+def list_data():
+    """Return the names of bundled data files."""
+    root = resources.files(PKG_DATA)
+    return sorted(e.name for e in root.iterdir()
+                  if not e.name.startswith("__") and e.name != "")
+
+
+def get_data(name=None, dest="."):
+    """Copy a bundled data file into `dest` (current folder by default).
+
+    get_data()                -> copies ALL data files here
+    get_data("student.csv")   -> copies just that one
+    """
+    available = list_data()
+    targets = available if name is None else [name]
+    os.makedirs(dest, exist_ok=True)
+    done = []
+    for fn in targets:
+        if fn not in available:
+            print(f"'{fn}' is not a bundled data file. Available: {', '.join(available)}")
+            continue
+        src = resources.files(PKG_DATA) / fn
+        out = os.path.join(dest, fn)
+        with resources.as_file(src) as p:
+            shutil.copyfile(p, out)
+        done.append(os.path.abspath(out))
+    for p in done:
+        print("Saved:", p)
+    return done[0] if len(done) == 1 else done
+
+
+def main():
+    args = sys.argv[1:]
+    if not args:
+        print("Usage: sickittit_learno [list | show <name> | data [<file>]]")
+        return
+    cmd = args[0]
+    if cmd == "list":
+        list_all()
+    elif cmd == "show":
+        if len(args) < 2:
+            print("Usage: sickittit_learno show <name>")
+        else:
+            show(args[1])
+    elif cmd == "data":
+        get_data(args[1] if len(args) > 1 else None)
+    else:
+        print(f"Unknown command: {cmd}")
+        print("Usage: sickittit_learno [list | show <name> | data [<file>]]")
+
+
+if __name__ == "__main__":
+    main()

sickittit-learno-3.0.1/sickittit_learno.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: sickittit-learno
+Version: 3.0.1
+Summary: AI Practicals cheatsheet (print code + fetch ready-made data files)
+Home-page: UNKNOWN
+Author: Anant Prajapati
+License: UNKNOWN
+Platform: UNKNOWN
+Requires-Python: >=3.9
+
+UNKNOWN
+

sickittit-learno-3.0.1/sickittit_learno.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+MANIFEST.in
+setup.cfg
+setup.py
+sickittit_learno/__init__.py
+sickittit_learno/practs.py
+sickittit_learno.egg-info/PKG-INFO
+sickittit_learno.egg-info/SOURCES.txt
+sickittit_learno.egg-info/dependency_links.txt
+sickittit_learno.egg-info/entry_points.txt
+sickittit_learno.egg-info/top_level.txt
+sickittit_learno/data/__init__.py
+sickittit_learno/data/student.csv
+sickittit_learno/data/student_marks.csv
+sickittit_learno/practicals/__init__.py
+sickittit_learno/practicals/p01_reflex_vacuum.py
+sickittit_learno/practicals/p02_bfs_8puzzle.py
+sickittit_learno/practicals/p03_dfs_waterjug.py
+sickittit_learno/practicals/p04_ucs_citygraph.py
+sickittit_learno/practicals/p05_greedy_8puzzle.py
+sickittit_learno/practicals/p06_astar_8puzzle.py
+sickittit_learno/practicals/p07_astar_romania.py
+sickittit_learno/practicals/p08_bayes_medical.py
+sickittit_learno/practicals/p09_naivebayes_weather.py
+sickittit_learno/practicals/p10_bayesnet_burglary.py
+sickittit_learno/practicals/p11_bayesnet_posterior.py
+sickittit_learno/practicals/p12_1_ml_student_csv.py
+sickittit_learno/practicals/p12_2_linreg_marks.py
+sickittit_learno/practicals/p12_3_mnist_binary.py
+sickittit_learno/practicals/p12_4_kfold_iris.py
+sickittit_learno/practicals/p12_5_dtree_iris.py
+sickittit_learno/practicals/p12_6_dtree_reg_marks.py
+sickittit_learno/practicals/p12_7_knn_iris.py
+sickittit_learno/practicals/p12_8_multiclass_dtree_iris.py
+sickittit_learno/practicals/p13_ethics_bias_iris.py

sickittit-learno-3.0.1/sickittit_learno.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sickittit-learno-3.0.1/sickittit_learno.egg-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+sickittit-learno = sickittit_learno.practs:main
+sickittit_learno = sickittit_learno.practs:main
+

sickittit-learno-3.0.1/sickittit_learno.egg-info/top_level.txt

@@ -0,0 +1 @@
+sickittit_learno