Cup stats & predictions

Predizioni Esperte per le Scommesse Sportive

Fare previsioni accurate per le scommesse sportive richiede un'analisi dettaglia<|repo_name|>davidrobles20/SDC-ND-P2<|file_sep|>/model.py import numpy as np import cv2 import tensorflow as tf from keras import backend as K from keras.layers import Convolution2D from keras.layers import Cropping2D from keras.layers import Dense from keras.layers import Flatten from keras.layers import Lambda from keras.models import Sequential def conv_net(input_shape): # Preprocess incoming data, centered around zero with small standard deviation model = Sequential() model.add(Lambda(lambda x : x /127.5 -1., input_shape=input_shape)) # Convolutional layer with rectified linear unit activation model.add(Convolution2D(24,(5,5),strides=(2,2),activation='relu')) model.add(Convolution2D(36,(5,5),strides=(2,2),activation='relu')) model.add(Convolution2D(48,(5,5),strides=(2,2),activation='relu')) model.add(Convolution2D(64,(3,3),activation='relu')) model.add(Convolution2D(64,(3,3),activation='relu')) # Flatten convolutional layers output to feed fully connected layers model.add(Flatten()) # Fully connected layers model.add(Dense(100)) model.add(Dense(50)) model.add(Dense(10)) model.add(Dense(1)) return model class LeNet: def __init__(self): self.model = Sequential() self.model.add(Lambda(lambda x : x /127.5 -1., input_shape=(160,320,3))) self.model.add(Cropping2D(cropping=((70 ,25),(0 ,0)))) self.model.add(Convolution2D(6,(5,5))) self.model.add(MaxPooling2D()) self.model.add(Convolution2D(6,(5,5))) self.model.add(MaxPooling2D()) self.model.add(Flatten()) self.model.add(Dense(120)) self.model.add(Dense(84)) self.model.add(Dense(1)) def compile(self): opt = Adam(lr=0.001) self.model.compile(loss='mse',optimizer=opt) def train(self,X_train,y_train): self.model.fit(X_train,y_train,nb_epoch=10,batch_size=32) <|repo_name|>davidrobles20/SDC-ND-P2<|file_sep|>/README.md # **Behavioral Cloning** ## Project Overview The goals / steps of this project are the following: * Use the simulator to collect data of good driving behavior * Build and train a convolution neural network in Keras that predicts steering angles from images * Validate the model using different training and validation sets * Test that the model successfully drives around track one without leaving the road * Summarize the results with a written report [//]: # (Image References) [image1]: ./examples/center_2016_12_01_13_30_48_342.jpg "Center Image" [image2]: ./examples/center_2016_12_01_13_31_59_229.jpg "Recovery Image" [image3]: ./examples/center_2016_12_01_13_31_53_792.jpg "Flipped Image" [image4]: ./examples/nvidia_model.png "NVIDIA Model" ## Rubric Points ### Here I will consider the [rubric points](https://review.udacity.com/#!/rubrics/432/view) individually and describe how I addressed each point in my implementation. --- ### Files Submitted & Code Quality #### 1. Submission includes all required files and can be used to run the simulator in autonomous mode My project includes the following files: * model.py containing the script to create and train the model * drive.py for driving the car in autonomous mode * model.h5 containing a trained convolution neural network * writeup_report.md or writeup_report.pdf summarizing the results #### 2. Submission includes functional code Using the Udacity provided simulator and my drive.py file my car can be driven autonomously around the track by executing sh python drive.py model.h5 #### 3. Submission code is usable and readable The model.py file contains the code for training and saving the convolution neural network. The file shows the pipeline I used for training and validating the model. ### Model Architecture and Training Strategy #### 1. An appropriate model architecture has been employed My model is based on NVIDIA's self-driving car CNN architecture https://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf. It consists of a convolution neural network with five convolutional layers followed by three fully connected layers. The first layer normalizes pixel values between [-1.,1.] using lambda function. The next three layers are convolutional layers with rectified linear unit activation function. * The first layer has depth of six feature maps with filter size of five by five and stride of two by two. * The second layer has depth of sixteen feature maps with filter size of five by five and stride of two by two. * The third layer has depth of thirty-two feature maps with filter size of three by three. The last two layers are convolutional layers with rectified linear unit activation function. * The fourth layer has depth of sixty-four feature maps with filter size of three by three. * The fifth layer has depth of sixty-four feature maps with filter size of three by three. I decided to add these five convolutional layers because they have worked well in previous projects such as autonomous cars from NVIDIA https://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf. The next layer flattens output from previous layers to feed it into fully connected layers. The first fully connected layer has one hundred neurons followed by fifty neurons in second fully connected layer and ten neurons in third fully connected layer. Finally I added one neuron at last fully connected layer to predict steering angle. #### 2. Attempts to reduce overfitting in the model To reduce overfitting I used dropout on each fully connected layer after activation function. I also used generator to train model instead of loading all data into memory at once. #### 3. Model parameter tuning The model used an adam optimizer so that manually training the learning rate wasn't necessary. #### 4. Appropriate training data Training data was chosen to keep the vehicle driving on the road. I used a combination of center lane driving images and recovery images where the vehicle is driving out of center lane. For details about how I created the training data see section Training Data below. ### Model Architecture and Training Strategy #### 1. Solution Design Approach The overall strategy for deriving a model architecture was to ... My first step was to use a convolution neural network model similar to NVIDIA's self-driving car CNN architecture https://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf. In order to gauge how well my model was working, I split my image and steering angle data into a training set and validation set using an eighty-twenty split. I found that my first architecture had a low mean squared error on both the training set and validation set but it was not able to generalize well for test data. Then I added dropout after each fully connected layer after activation function in order to reduce overfitting but it didn't help much. In order to gauge how well the model was working, I split my image and steering angle data into a training set and validation set. I found that my first architecture had a low mean squared error on both the training set and validation set but it was not able to generalize well for test data. I also recorded the vehicle position while using simulator in autonomous mode which helped me identify where vehicle was loosing control during drive. The final step was to run the simulator to see how well the car was driving around track one without leaving the road. At first car couldn't make it through sharp corners on left side but after flipping images it was able to make it through corners. At some point car started drifting towards right side which could be solved by adding more left images or changing left steering angles. Here is an example image of center lane driving: ![alt text][image1] Here is an example image when vehicle started drifting towards right side: ![alt text][image2] This is flipped version of above image: ![alt text][image3] #### Model Architecture & Training Strategy My first step was to use an existing convolution neural network architecture similar to NVIDIA's self-driving car CNN architecture https://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf. In order to gauge how well my model was working I split my image and steering angle data into a training set and validation set using an eighty-twenty split. My final model consisted of a convolution neural network with five convolutional layers followed by three fully connected layers similar to NVIDIA's self-driving car CNN architecture https://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf . Here is a visualization of the architecture: ![alt text][image4] #### Training Strategy To train the model I used generator because there were too many images in dataset which wouldn't fit into memory at once. Generator read batches from CSV file which contained paths for images as well as steering angles associated with them. For each epoch generator yielded four times number of batches than there were in dataset because it returned batches containing center images as well as left/right images along with their flipped versions. To improve accuracy even more I added left/right images along with their steering angles offseted by ±0.25 respectively. I also flipped images horizontally along with their steering angles multiplied by -1 because this would help car learn how to recover from both sides. For each epoch I used shuffle=True when calling fit_generator() method because this would ensure that batches were shuffled at every epoch which would help prevent overfitting. #### Solution Design Approach I trained for ten epochs using Adam optimizer because it automatically tunes learning rate based on loss value during training process. I used mean squared error loss function because this would minimize difference between predicted values and true values. ### Issues faced during development Initially my car could drive straight line but couldn't make sharp turns on left side due to lack of enough left images. So I decided to flip images horizontally along with their steering angles multiplied by -1 which helped solve this issue. However now car started drifting towards right side which could be solved by adding more left images or changing left steering angles. Also when I ran simulator using drive.py file initially car would only move forward because drive.py only used center camera image but didn't apply any correction factor so now I decided to modify drive.py so that it would use correction factor based on whether left/right camera image was being processed or not. Another issue was that drive.py had problem displaying images on screen due to some kind of conflict between cv2.imshow() method and matplotlib.pyplot.imshow() method so I decided not use matplotlib.pyplot.imshow() method anymore. ### Video link [Video Link](./project_video.mp4) <|repo_name|>davidrobles20/SDC-ND-P2<|file_sep|>/model.py import csv import cv2 import numpy as np import sklearn from sklearn.utils import shuffle from keras.models import Sequential from keras.layers.core import Dense from keras.layers.core import Flatten from keras.layers.core import Dropout from keras.layers.convolutional import Convolution2D