This project implements a self-driving car system utilizing a Convolutional Neural Network (CNN) to predict steering angles based on input images from a front-facing camera. The system is designed to operate within the Udacity Self-Driving Car Simulator, enabling autonomous navigation in a simulated environment.

Udacity autonomous driving car nanodegree projects

Udacity self driving car engineer integration project: focus on building ROS nodes to implement core functionality of the autonomous vehicle system, including traffic light detection, control, and waypoint following

Pytorch model (CNN) to drive a simulated car autonomously in the Udacity Self-Driving Car Simulation.

The purpose of this project is the development of an End-to-End learning model in order to predict the steering angle of an autonomous car. The proposed method uses monocular vision in order to acomplish the prediction task. Specifically, a CNN followed by LSTM units, is trained in order to manage both spatial and temporal information of the image sequence. In addition, a fusion with a second CNN that uses past prediction as inputs, is proposed, in order to improve the temporal information available. Both of the architectures were trained and tested on human driving data, provided by Udacity Challenge 2.

Implemented vision-based algorithm to learn and imitate human driving behavior using Convolutional Neural Networks. Trained model autonomously drives the car safely while maintaining lanes and adjusts for inclinations and sharp turns. Simulated and evaluated on Udacity’s Unity Autonomous Simulator.

This is the final project of the Udacity Self-Driving Car Engineer Nanodegree program. In this project, I designed the most modules and integrate them all together as an autonomous vehicle system in ROS framework to enable our car Carla drive around the test track in Simulator. Carla will load the base waypoints from the simulator and adapts the desired velocity of waypoints according to the traffic light color detected by camera. Then it will interpret all the information to commands of throttle, braking and steering to realize the lateral and longitudinal control through the Drive-By-Wire module. I implemented the modules/nodes waypoint_updater, twist_controller and traffic light detector in Python on my own and adapts the waypoint_follower from [Autoware](https://github.com/autowarefoundation/autoware), which is written in C++. I used transfer learning with Keras API to detect the traffic light color. I retrain the VGG16 Model twice on my small simulator dataset and get a fine result.

My most ambitious project for simulating a self driving car with EEG. This is the code for my project where I used Udacity's self driving car simulator as a testbed for training an autonomous car.

Udacity's Self-Driving Car Simulation built in Unity 3D Game Engine. Customised for Hochschule Furtwangen University Semester Project. You can find the Original Project here: https://github.com/udacity/self-driving-car-sim

Built and trained a convolutional neural network to drive the car itself autonomously in a simulator using Tensorflow (backend) and Keras. Experimented with a modified Nvidia architecture. Performed image processing with brightness, shadow augmentation, and flipped images. Used dropout and Adam optimizer to generalize the network for driving multiple tracks. The datasets are used via Udacity's source for training the model. Trained the model on Amazon AWS EC2 platform with GPU instances.

Lane detection for autonomous navigation using opencv library, done as a part of Udacity Self Driving Car Nanodegree Program

Deep learning neural net for controlling an autonomous vehicle in a simulator for Udacity's Self-Driving Car Engineer program.

Autonomous car system integration for Carla. Capstone of Udacity's Self-Driving Car Nanodegree.

This is part of my work in the Udacity Nanodegree (Self-Driving Car Engineer) which is specialized in Autonomous vehicles

In this project, we utilize the Udacity self-driving car simulator to train a deep learning model to drive a car autonomously in a simulated environment.

Self Driving Car Engineer Nanodegree, Udacity Course submission material Chapter 4 Planning - Project: Motion Planning and Decision Making for Autonomous Vehicles. https://learn.udacity.com/nanodegrees/nd0013

This project showcases the implementation of behavioral cloning for training a self-driving car model using Python, Keras, and the Udacity Self-Driving Car Simulator. By mimicking human driving behavior, the model learns to navigate autonomously in the simulated environment.

Multi-model approach for autonomous driving 🚗🤖: A holistic exploration of traffic sign detection 🛑🚦, vehicle detection 🚗📡, and lane detection 🛣️📸, powered by the magic of deep learning 🧙‍♂️, within the captivating world of the Udacity Self-Driving Car Simulator 🚀🎮.

🎮 Self-Driving Car Simulation using Deep Learning.project simulates autonomous vehicle using a Convolutional Neural Network (CNN) trained via behavioral cloning. Built using Python, TensorFlow, and OpenCV, the model predicts steering angles from road images and navigates a virtual car in Udacity simulator with real-time control via Flask&SocketIo

This is my solution for the PID-Controller project in Udacity's Self-Driving Car Nanodegree Program. The goal of this project is to implement & tune a PID controller in C++ to maneuver the vehicle around the track The original code base can be found here. This contribution also features a PID-Tuning-Notebook (executing some python-code) which explains vehicle lateral dynamics using the "bycicle-model" frequently referred to in science and applied autonomous vehicle technology.

Udacity self-driving car nanodegree Project 3: neural network that drives a simulated car around a track autonomously. The network is implemented in Keras, and trained on recorded behavior of a human driver.

Self Driving Car tested using Udacity Autonomous Simulator.

Localization: using Particle Filter to localize Autonomous Vehicles (Udacity Self Driving Car Nanodegree)

Course projects from studies in Autonomous vehicles including the Udacity Self-driving Car Engineer Nanodegree.

Train a CNN model with a user driving behaviour to autonomously drive a simulated car - Project 4 of Udacity Self-Driving Car Engineer Nanodegree

self driving car python behavioral cloning model nvidia autonomous driving cnn udacity simulator deep learning steering angle prediction end to end driving model keras cnn self driving autonomous vehicle AI project

Project to use Udacity's Self-Driving Car Unity platform to be able to drive autonomously

Motion Planning and Decision Making for Autonomous Vehicles in case of Udacity Self Driving Cars Engineer Nanodegree

Project 4 of the Udacity Nanodegree for Self driving car - Manually driving a simulated car and training a keras based CNN to mimic the human driving pattern, and drive autonomously

In this repository, the code to use Udacity's self driving car simulator as a testbed for training an autonomous car are provided.