Merge branch 'master' of https://github.com/avinashkranjan/Amazing-Python-Scripts

Author: whiteknight16

.github/workflows/py_lint.yml

@@ -36,7 +36,7 @@ jobs:
       # Checkout the code base #
       ##########################
       - name: Checkout Code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           # Full git history is needed to get a proper list of changed files within `super-linter`
           fetch-depth: 0
@@ -45,7 +45,7 @@ jobs:
       # Run Linter against code base #
       ################################
       - name: Lint Code Base
-        uses: github/super-linter@v3
+        uses: github/super-linter@v5
         env:
           VALIDATE_ALL_CODEBASE: false
           VALIDATE_PYTHON: true

Autonomous-Taxi-Agent/Autonomous TaxiAgent.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jun  4 18:02:01 2021
+
+@author: Ayush
+"""
+
+import gym
+import numpy as np
+from IPython.display import clear_output
+
+env = gym.make('Taxi-v3')
+
+episodes = 10
+for episode in range(1,episodes):
+    state = env.reset()
+    done= False
+    score=0
+    
+    while not done:
+        env.render()
+        state,reward,done,info = env.step(env.action_space.sample())
+        score += reward
+        clear_output(wait=True)
+    print('Episode: {}\nScore: {}'.format(episode, score))
+env.close()
+
+#Creating Q-Table
+actions = env.action_space.n
+state = env.observation_space.n
+
+q_table = np.zeros((state,actions))
+
+#q_table.shape
+#q_table
+
+#Parameters for Q-Learning
+num_episodes = 10000
+max_steps_per_episode =1000
+learning_rate=0.01
+discount_rate = 0.99
+exploration_rate=1
+max_exploration_rate = 1
+min_exploration_rate = 0.01
+exploration_decay_rate= 0.01
+
+rewards_all_episodes = []
+
+#Q-Learning Algorithm
+import random
+for episode in range(num_episodes):
+    state = env.reset()
+    done = False
+    reward_current_episode = 0
+    
+    for step in range(max_steps_per_episode):
+        #Exploration vs Exploitation trade-off
+        exploration_threshold = random.uniform(0,1)
+        if exploration_threshold > exploration_rate:
+            action = np.argmax(q_table[state,:])
+        else:
+            action = env.action_space.sample()
+        new_state,reward,done,info = env.step(action)
+        
+        #Update Q-Table
+        q_table[state,action] = q_table[state,action]*(1-learning_rate)+ learning_rate*(reward + discount_rate * np.max(q_table[new_state, :]))
+        state=new_state
+        reward_current_episode += reward
+        
+        if done== True:
+            break
+    exploration_rate = min_exploration_rate + \
+        (max_exploration_rate- min_exploration_rate) * np.exp(-exploration_decay_rate * episode)
+    rewards_all_episodes.append(reward_current_episode)
+print("***** Training Finished *****")
+
+q_table
+
+#Calculate and print average reward per thousand episodes
+rewards_per_thousand_episodes = np.split(np.array(rewards_all_episodes), num_episodes/1000)
+count = 1000
+
+print("Average per thousand episodes")
+
+for r in rewards_per_thousand_episodes:
+    print(count, ":", str(sum(r/1000)))
+    count+=1000
+    
+# Visualize Agent
+import time 
+for episode in range(3):
+    status = env.reset()
+    done = False
+    print("Episode is: "+ str(episode))
+    time.sleep(1)
+    
+    for step in range(max_steps_per_episode):
+        clear_output(wait=True)
+        env.render()
+        time.sleep(.4)
+        
+        action = np.argmax(q_table[state,:])
+        
+        new_state, reward, done, info = env.step(action)
+        
+        if done:
+            clear_output(wait=True)
+            env.render()
+            if reward == 1:
+                print("****Reached Goal****")
+                time.sleep(2)
+                clear_output(wait=True)
+            else:
+                print("****Failed****")
+                time.sleep(2)
+                clear_output(wait=True)
+                
+            break
+        state=new_state
+env.close()
+
+
+

Autonomous-Taxi-Agent/README.md

@@ -0,0 +1,47 @@
+# Q-Learning with Taxi-v3 Environment
+
+This repository contains code for implementing the Q-Learning algorithm using the Taxi-v3 environment from the OpenAI Gym.
+
+## Prerequisites
+
+To run this code, you need the following dependencies:
+
+- Python 3.x
+- Gym: `pip install gym`
+- NumPy: `pip install numpy`
+
+## Getting Started
+
+1. Clone the repository: `git clone https://github.com/your_username/your_repository.git`
+2. Navigate to the cloned repository: `cd your_repository`
+
+## Running the Code
+
+1. Open the Python script `q_learning_taxi.py`.
+2. Configure the number of episodes, learning parameters, and other settings as needed.
+3. Run the script: `python q_learning_taxi.py`.
+
+## Understanding the Code
+
+The code performs the following steps:
+
+1. Imports the necessary libraries and initializes the Taxi-v3 environment.
+2. Runs a specified number of episodes, where each episode represents a learning iteration.
+3. Resets the environment for each episode and plays the game until completion.
+4. Renders the environment to visualize the game.
+5. Selects actions randomly for exploration or based on the learned Q-values for exploitation.
+6. Updates the Q-table based on the Q-Learning algorithm.
+7. Adjusts the exploration rate over time to balance exploration and exploitation.
+8. Stores the rewards obtained in each episode.
+9. Prints the Q-table after training.
+10. Calculates and prints the average reward per thousand episodes.
+11. Visualizes the agent's performance in a few test episodes.
+
+
+
+## Acknowledgments
+
+- [OpenAI Gym](https://gym.openai.com/)
+
+Feel free to modify and adapt this code according to your needs.
+

Lane Detection/README.md

@@ -0,0 +1,2 @@
+# lane_detection
+This project uses OpenCV to detect the lanes on the road.

Lane Detection/laneDetection.py

@@ -0,0 +1,89 @@
+import cv2
+import numpy as np
+ 
+def canny(img):
+    if img is None:
+        cap.release()
+        cv2.destroyAllWindows()
+        exit()
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    kernel = 5
+    blur = cv2.GaussianBlur(gray,(kernel, kernel),0)
+    canny = cv2.Canny(gray, 50, 150)
+    return canny
+
+def region_of_interest(canny):
+    height = canny.shape[0]
+    width = canny.shape[1]
+    mask = np.zeros_like(canny)
+    triangle = np.array([[
+    (200, height),
+    (800, 350),
+    (1200, height),]], np.int32)
+    cv2.fillPoly(mask, triangle, 255)
+    masked_image = cv2.bitwise_and(canny, mask)
+    return masked_image
+
+def houghLines(cropped_canny):
+    return cv2.HoughLinesP(cropped_canny, 2, np.pi/180, 100, 
+        np.array([]), minLineLength=40, maxLineGap=5)
+
+def addWeighted(frame, line_image):
+    return cv2.addWeighted(frame, 0.8, line_image, 1, 1)
+ 
+def display_lines(img,lines):
+    line_image = np.zeros_like(img)
+    if lines is not None:
+        for line in lines:
+            for x1, y1, x2, y2 in line:
+                cv2.line(line_image,(x1,y1),(x2,y2),(0,0,255),10)
+    return line_image
+ 
+def make_points(image, line):
+    slope, intercept = line
+    y1 = int(image.shape[0])
+    y2 = int(y1*3.0/5)      
+    x1 = int((y1 - intercept)/slope)
+    x2 = int((y2 - intercept)/slope)
+    return [[x1, y1, x2, y2]]
+ 
+def average_slope_intercept(image, lines):
+    left_fit    = []
+    right_fit   = []
+    if lines is None:
+        return None
+    for line in lines:
+        for x1, y1, x2, y2 in line:
+            fit = np.polyfit((x1,x2), (y1,y2), 1)
+            slope = fit[0]
+            intercept = fit[1]
+            if slope < 0: 
+                left_fit.append((slope, intercept))
+            else:
+                right_fit.append((slope, intercept))
+    left_fit_average  = np.average(left_fit, axis=0)
+    right_fit_average = np.average(right_fit, axis=0)
+    left_line  = make_points(image, left_fit_average)
+    right_line = make_points(image, right_fit_average)
+    averaged_lines = [left_line, right_line]
+    return averaged_lines
+
+cap = cv2.VideoCapture("test1.mp4")
+while(cap.isOpened()):
+    _, frame = cap.read()
+    canny_image = canny(frame)
+    cropped_canny = region_of_interest(canny_image)
+    # cv2.imshow("cropped_canny",cropped_canny)
+
+    lines = houghLines(cropped_canny)
+    averaged_lines = average_slope_intercept(frame, lines)
+    line_image = display_lines(frame, averaged_lines)
+    combo_image = addWeighted(frame, line_image)
+    cv2.imshow("result", combo_image)
+    
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+cap.release()
+cv2.destroyAllWindows()
+