Fixing ml (#56)

* changed tensor value None, starting investigation into ML

* Debugging torch.tensor changes, added several bug fixes with duplicate traces

* Fixed double trace

* removed trace bug

* ml working for 8x8 maps

* fixed ml for all size maps...

* pushing new models

* added parameter changes, the training batch script

* implemented requested changes

* adding trainer requirements for the batch trainer

* changing batch trainer to use trainer_requirements, added comments for the VIN file (dont touch), and deleted redundant GUI import from runtrainer

* removed relative pathing from directory model

* added the atlas generation back, fixed uniform random fill generation labelling.

* adding bootstrap full generate + train

* updating the batch train

* setting the generator to true

* fixed the np breaking change, currently have a torch breaking change for CUDA issues but hopefully will work on device with just cpu

* lengths cpu hot fix

* adding the 3000 trained for onlineLSTM

* patching the fixes from the updates to master

* removing last bit of resources folder

* removing debugging and the versioning on the requirements

* Fixed indentation

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

* Made code concise

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

* Delete vin.py

* deleting comments

* hasattr fix

* removing print

* Polished file not found message

* Dependencies / requirements cleanup

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

* Imports cleanup

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

* Formatted code

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

* Removed useless import

Signed-off-by: [ 大鳄 ] Asew <[email protected]>

Co-authored-by: Abel Shields <[email protected]>
Co-authored-by: [ 大鳄 ] Asew <[email protected]>
Co-authored-by: [ 大鳄 ] Asew <[email protected]>

Author: 3 people

data/cache/tile_by_tile_training_uniform_random_fill_3_block_map_3_house_3_pre_processed_data.pickle

@@ -201,19 +201,20 @@ def get_occupancy_percentage_size(size: Size, items_nr: int) -> float:
 
     @staticmethod
     def get_euclidean_distance_traveled(trace: List[Trace], agent: Agent) -> float:
-        trace.append(Trace(agent.position))
+        if (not trace) or trace[-1].position != agent.position:
+            trace.append(Trace(agent.position))
         dist = 0
         for i in range(1, len(trace)):
             dist += np.linalg.norm(np.array(trace[i - 1].position) - np.array(trace[i].position))
         return dist
 
     @staticmethod
     def get_smoothness(trace: List[Trace], agent: Agent) -> float:
-        trace.append(Trace(agent.position))
+        if (not trace) or trace[-1].position != agent.position:
+            trace.append(Trace(agent.position))
         angle = 0
         prev_angle = None
 
-        # print(trace)
         for i in range(1, len(trace)):
 
             if(not trace[i - 1].position == trace[i].position):

data/training_data/training_block_map_3.pickle

@@ -65,11 +65,14 @@ def __init__(self) -> None:
 
         # Generator
         self.generator = False
-        self.generator_labelling_atlases = []
-        self.generator_nr_of_examples = 10
-        self.generator_gen_type = "house"
-        self.generator_labelling_features = []
-        self.generator_labelling_labels = []
+        self.generator_labelling_atlases = ['block_map_100']
+        self.generator_nr_of_examples = 100
+        self.generator_gen_type = "block_map"
+        self.generator_labelling_features = ["distance_to_goal_normalized",
+                                             "raycast_8_normalized",
+                                             "direction_to_goal_normalized",
+                                             "agent_goal_angle"]
+        self.generator_labelling_labels = ["next_position_index"]
         self.generator_single_labelling_features = []
         self.generator_single_labelling_labels = []
         self.generator_aug_labelling_features = []
@@ -79,9 +82,9 @@ def __init__(self) -> None:
         self.generator_modify = None
         self.generator_show_gen_sample = False
         self.generator_house_expo = False
-        self.generator_size = 28
+        self.generator_size = 64
 
-        self.num_dim = 3
+        self.num_dim = 2
 
         # Trainer
         self.trainer = False

data/training_data/training_house_3.pickle

@@ -29,3 +29,6 @@ def __eq__(self, other: object) -> bool:
         if not isinstance(other, Trace):
             return False
         return super().__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash(self.position)

data/training_data/training_uniform_random_fill_3.pickle

@@ -1,9 +1,9 @@
-import copy
 from typing import List, Optional, Set, Dict, Callable, TypeVar, Union, Tuple
-
+from itertools import product
+import copy
 import math
+
 import numpy as np
-from itertools import product
 
 from algorithms.configuration.entities.agent import Agent
 from algorithms.configuration.entities.entity import Entity
@@ -116,10 +116,6 @@ def get_obstacle_bound(self, obstacle_start_point: Point, visited: Optional[Set[
         """
         # modified initialisation of visited set for n dimensional nodes
         if visited is None:
-            #visited = [False for _ in range(self.size.width)]
-
-            # for i in range(self.dim - 1):
-            #    visited = [visited for _ in range(self.size[i + 1])]
             visited: Set[Point] = set()
 
         if self.is_agent_valid_pos(obstacle_start_point):
@@ -149,6 +145,7 @@ def get_move_index(self, direction: List[float]) -> int:
         :param direction: The direction
         :return: The index corresponding to :ref:`ALL_POINTS_MOVE_VECTOR`
         """
+        direction = direction.tolist() if hasattr(direction, "tolist") else direction
         rounded_point = self.get_move_along_dir(direction)
         return self.ALL_POINTS_MOVE_VECTOR.index(rounded_point)
 
@@ -158,6 +155,7 @@ def get_move_along_dir(self, direction: List[float]) -> Point:
         :param direction: The true direction
         :return: The :ref:`ALL_POINTS_MOVE_VECTOR` point
         """
+        assert(any(direction))
         dir_length = math.sqrt(sum(i*i for i in direction))
         norm_direction = list(map(lambda i: i/dir_length, direction))
         rounded_direction = list(map(lambda i: round(i), norm_direction))
@@ -195,23 +193,11 @@ def move_agent(self, to: Point, no_trace: bool = False, follow: bool = False) ->
 
         if not follow:
             return self.move(self.agent, to, no_trace)
-        # else:
-        #     line: List[Point] = self.get_line_sequence(self.agent.position, to)
-        #     for next_pos in line:
-        #         if not self.move(self.agent, next_pos, no_trace):
-        #             return False
-        #     return True
-            # for pt in EIGHT_POINTS_MOVE_VECTOR:
-            #     inx = int(next_pos.x + point.x)
-            #     iny = int(next_pos.y + point.y)
         else:
-            line: List[Point] = self.get_line_sequence(self.agent.position, to)
-            print(line)
-            n = 0
+            line: List[Point] = self.get_line_sequence(self.agent.position, to)[1:]  # Get rid of first point, the current agent pos
             for next_pos in line:
                 if not self.move(self.agent, next_pos, no_trace):
-                    if n != 0:
-                        return False
+                    return False
             return True
 
     def get_line_sequence(self, frm: Point, to: Point) -> List[Point]:

data/training_data/training_uniform_random_fill_3_block_map_3_house_3.pickle

@@ -25,7 +25,7 @@
 class CAEEncoder(nn.Module):
     def __init__(self, latent_dim: int):
         super().__init__()
-        #The four convolutional layers, and four batch normalization layers in the CAE Encoder. 
+        # The four convolutional layers, and four batch normalization layers in the CAE Encoder.
         self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, padding=1)
         self.bn1 = nn.BatchNorm2d(num_features=64)
         self.conv2 = nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, padding=1)
@@ -37,8 +37,8 @@ def __init__(self, latent_dim: int):
         self.latent_linear = nn.Linear(in_features=8 * 4 * 4, out_features=latent_dim)
         self.bn_latent = nn.BatchNorm1d(num_features=latent_dim)
 
-        #Define the forward motion of the CAE Encoder, basically applies the Leakey Relu + Max pool activation function -
-        # to the Batch Normalized Convolutional Layer, 
+        # Define the forward motion of the CAE Encoder, basically applies the Leakey Relu + Max pool activation function -
+        # to the Batch Normalized Convolutional Layer,
     def forward(self, input):
         out1 = F.leaky_relu(F.max_pool2d(self.bn1(self.conv1(input)), kernel_size=2, stride=2))
         out2 = F.leaky_relu(F.max_pool2d(self.bn2(self.conv2(out1)), kernel_size=2, stride=2))
@@ -53,7 +53,7 @@ def __init__(self, latent_dim: int, with_skip):
         super().__init__()
 
         self.__with_skip = with_skip
-        #Similar to above, but in opposite order
+        # Similar to above, but in opposite order
         self.latent_linear = nn.Linear(in_features=latent_dim, out_features=8 * 4 * 4)
         self.bn_latent = nn.BatchNorm1d(num_features=8 * 4 * 4)
         self.deconv1 = nn.ConvTranspose2d(in_channels=8, out_channels=16, kernel_size=2, stride=2)
@@ -81,15 +81,15 @@ def forward(self, x):
         return out5
 
 
-#Actual MLModel CAE class
+# Actual MLModel CAE class
 class CAE(MLModel):
     MAP_COLORMAP_FULL = LinearSegmentedColormap.from_list("my_list", [(1, 1, 1), (0, 0, 0), (1, 0, 0), (0, 1, 0)])
     MAP_COLORMAP = "gray_r"
     MNIST_COLORMAP = "gray"
 
     def __init__(self, services: Services, config: Dict[str, any]):
         super().__init__(services, config)
-        #Run encoder then dedoder
+        # Run encoder then dedoder
         self.encoder = CAEEncoder(self.config["latent_dim"])
         self.decoder = CAEDecoder(self.config["latent_dim"], self.config["with_skip_connections"])
 
@@ -112,7 +112,7 @@ def pre_process_data(self) -> Tuple[Dataset, Dataset]:
             return features, labels
 
     def batch_start(self, inputs: torch.Tensor, labels: torch.Tensor) -> Tuple[
-        torch.Tensor, torch.Tensor, torch.Tensor]:
+            torch.Tensor, torch.Tensor, torch.Tensor]:
 
         inp = inputs[0].view((inputs[0].shape[0], -1)).to(self._services.torch.device)
         lbl = labels[0].view((labels[0].shape[0], -1)).to(self._services.torch.device)
@@ -237,12 +237,8 @@ def get_config() -> Dict[str, Any]:
             ],
             "save_name": "caelstm_section_cae",
             "training_data": [
-                #'training_house_100'
-                #"training_" + str(config.) + "_" + str(ui.nbr_ex)
-                # "training_uniform_random_fill_10", #IMPT
-               #"training_uniform_random_fill_100",
                 "training_house_1000",
-            ], # training_uniform_random_fill_10000_block_map_10000_house_10000, "training_uniform_random_fill_10000_block_map_10000", "training_house_10000", "training_uniform_random_fill_10000", "training_block_map_10000",
+            ],
             "use_mnist_instead": False,
             "mnist_size": None,
             "epochs": 100,
@@ -355,32 +351,32 @@ def forward_features(self, mp: Map) -> torch.Tensor:
     @staticmethod
     def get_config() -> Dict[str, Any]:
         return {
-              "data_features": [
-                  "raycast_8_normalized",
-                  "distance_to_goal_normalized",
-                  "direction_to_goal_normalized",
-                  "agent_goal_angle",
-              ],
-              "data_single_features": [
-                  "global_map",
-              ],
-              "data_labels": [
-                  "next_position_index",
-              ],
-              "custom_encoder": None, # "caelstm_section_cae_training_uniform_random_fill_10000_block_map_10000_house_10000_model",
-              "save_name": "caelstm_section_lstm",
-              "training_data": [
-                  "training_house_100"
-                  #"training_uniform_random_fill_10000",
-                  #"training_block_map_10000",
-                  #"training_house_10000",
-              ], # training_uniform_random_fill_10000_block_map_10000_house_10000, "training_uniform_random_fill_10000_block_map_10000", "training_house_10000", "training_uniform_random_fill_10000", "training_block_map_10000",
-              "epochs": 21,
-              "num_layers": 2,
-              #"with_init_fn": False,
-              #"input_size": 114,
-              "lstm_input_size": 112,
-              "lstm_output_size": 8,
-              "loss": nn.CrossEntropyLoss(),
-              "optimizer": lambda model: torch.optim.Adam(model.parameters(), lr=0.01),
+            "data_features": [
+                "raycast_8_normalized",
+                "distance_to_goal_normalized",
+                "direction_to_goal_normalized",
+                "agent_goal_angle",
+            ],
+            "data_single_features": [
+                "global_map",
+            ],
+            "data_labels": [
+                "next_position_index",
+            ],
+            "custom_encoder": None,  # "caelstm_section_cae_training_uniform_random_fill_10000_block_map_10000_house_10000_model",
+            "save_name": "caelstm_section_lstm",
+            "training_data": [
+                "training_house_100"
+                # "training_uniform_random_fill_10000",
+                # "training_block_map_10000",
+                # "training_house_10000",
+            ],  # training_uniform_random_fill_10000_block_map_10000_house_10000, "training_uniform_random_fill_10000_block_map_10000", "training_house_10000", "training_uniform_random_fill_10000", "training_block_map_10000",
+            "epochs": 21,
+            "num_layers": 2,
+            # "with_init_fn": False,
+            # "input_size": 114,
+            "lstm_input_size": 112,
+            "lstm_output_size": 8,
+            "loss": nn.CrossEntropyLoss(),
+            "optimizer": lambda model: torch.optim.Adam(model.parameters(), lr=0.01),
         }