refactor: compute only angle value

src/tf_container/train_entry_point.py

@@ -21,11 +21,7 @@ from tensorflow.python.client import device_lib
 def get_data(root_dir, filename):
     print('load data from file ' + filename)
     d = json.load(open(os.path.join(root_dir, filename)))
-    if 'pilot/throttle' in d:
-        return [d['user/mode'], d['user/throttle'], d['user/angle'], root_dir, d['cam/image_array'],
-                d['pilot/throttle'], d['pilot/angle']]
-    else:
-        return [d['user/mode'], d['user/throttle'], d['user/angle'], root_dir, d['cam/image_array']]
+    return [d['user/angle'], root_dir, d['cam/image_array']]
 
 
 numbers = re.compile(r'(\d+)')
@@ -58,36 +54,19 @@ def train():
         data.extend(
             [get_data(root, f) for f in sorted(files, key=str.lower) if f.startswith('record') and f.endswith('.json')])
 
-    # Normalize / correct data
-    # data = [d for d in data if d[1] > 0.1]
-    # for d in data:
-    #    if d[1] < 0.2:
-    #        d[1] = 0.2
 
     # ### Loading throttle and angle ###
 
-    angle = [d[2] for d in data]
-    throttle = [d[1] for d in data]
+    angle = [d[0] for d in data]
     angle_array = np.array(angle)
-    throttle_array = np.array(throttle)
-
-    if len(data[0]) > 5:
-        pilot_angle = [d[6] for d in data]
-        pilot_throttle = [d[5] for d in data]
-        pilot_angle_array = np.array(pilot_angle)
-        pilot_throttle_array = np.array(pilot_throttle)
-    else:
-        pilot_angle = []
-        pilot_throttle = []
 
     # ### Loading images ###
-    images = np.array([img_to_array(load_img(os.path.join(d[3], d[4]))) for d in data], 'f')
+    images = np.array([img_to_array(load_img(os.path.join(d[1], d[2]))) for d in data], 'f')
 
     # slide images vs orders
     if env.hyperparameters.get('with_slide', False):
         images = images[:len(images) - 2]
         angle_array = angle_array[2:]
-        throttle_array = throttle_array[2:]
 
     # ### Start training ###
     def linear_bin(a):
@@ -109,19 +88,20 @@ def train():
     sess = tf.Session()
     K.set_session(sess)
 
+    # First layer, input layer, Shape comes from camera.py resolution, RGB
     img_in = Input(shape=(128, 160, 3),
-                   name='img_in')  # First layer, input layer, Shape comes from camera.py resolution, RGB
+                   name='img_in')
     x = img_in
-    x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(
-        x)  # 24 features, 5 pixel x 5 pixel kernel (convolution, feauture) window, 2wx2h stride, relu activation
-    x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(
-        x)  # 32 features, 5px5p kernel window, 2wx2h stride, relu activatiion
-    x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu')(
-        x)  # 64 features, 5px5p kernal window, 2wx2h stride, relu
-    x = Convolution2D(64, (3, 3), strides=(2, 2), activation='relu')(
-        x)  # 64 features, 3px3p kernal window, 2wx2h stride, relu
-    x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(
-        x)  # 64 features, 3px3p kernal window, 1wx1h stride, relu
+    # 24 features, 5 pixel x 5 pixel kernel (convolution, feauture) window, 2wx2h stride, relu activation
+    x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(x)
+    # 32 features, 5px5p kernel window, 2wx2h stride, relu activatiion
+    x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(x)
+    # 64 features, 5px5p kernal window, 2wx2h stride, relu
+    x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu')(x)
+    # 64 features, 3px3p kernal window, 2wx2h stride, relu
+    x = Convolution2D(64, (3, 3), strides=(2, 2), activation='relu')(x)
+    # 64 features, 3px3p kernal window, 1wx1h stride, relu
+    x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x)
 
     # Possibly add MaxPooling (will make it less sensitive to position in image).  Camera angle fixed, so may not to be needed
 
@@ -129,21 +109,20 @@ def train():
     x = Dense(100, activation='relu')(x)  # Classify the data into 100 features, make all negatives 0
     x = Dropout(.1)(x)
     x = Dense(50, activation='relu')(x)
-    x = Dropout(.1)(x)  # Randomly drop out 10% of the neurons (Prevent overfitting)
+    # Randomly drop out 10% of the neurons (Prevent overfitting)
+    x = Dropout(.1)(x)
     # categorical output of the angle
     callbacks_list = [save_best, early_stop, logs]
-    angle_out = Dense(15, activation='softmax', name='angle_out')(
-        x)  # Connect every input with every output and output 15 hidden units. Use Softmax to give percentage. 15 categories and find best one based off percentage 0.0-1.0
+    # Connect every input with every output and output 15 hidden units. Use Softmax to give percentage.
+    # 15 categories and find best one based off percentage 0.0-1.0
+    angle_out = Dense(15, activation='softmax', name='angle_out')(x)
 
-    # continous output of throttle
-    throttle_out = Dense(1, activation='relu', name='throttle_out')(x)  # Reduce to 1 number, Positive number only
     angle_cat_array = np.array([linear_bin(a) for a in angle_array])
-    model = Model(inputs=[img_in], outputs=[angle_out, throttle_out])
+    model = Model(inputs=[img_in], outputs=[angle_out])
     model.compile(optimizer='adam',
-                  loss={'angle_out': 'categorical_crossentropy',
-                        'throttle_out': 'mean_absolute_error'},
-                  loss_weights={'angle_out': 0.9, 'throttle_out': .001})
-    model.fit({'img_in': images}, {'angle_out': angle_cat_array, 'throttle_out': throttle_array}, batch_size=32,
+                  loss={'angle_out': 'categorical_crossentropy', },
+                  loss_weights={'angle_out': 0.9 })
+    model.fit({'img_in': images}, {'angle_out': angle_cat_array, }, batch_size=32,
               epochs=100, verbose=1, validation_split=0.2, shuffle=True, callbacks=callbacks_list)
 
     # Save model for tensorflow using