error fix

Author: quancore

generator.py

@@ -15,16 +15,18 @@
 
 
 class data_augmentator():
+	# class for data augmentation
 
 	def __init__(self,f_prefix, num_of_data, seq_length, val_percent):
 
 		self.base_train_path = 'data/train/'
 		self.base_validation_path = 'data/validation/'
 
+		# list of angles will be use for rotation
 		self.angles = list(range(0,360,30))
 		self.num_of_data = np.clip(num_of_data, 0, len(self.angles) -1)
-		self.num_validation_data = math.ceil(self.num_of_data * val_percent)
-		self.num_train_data = self.num_of_data - self.num_validation_data
+		self.num_validation_data = math.ceil(self.num_of_data * val_percent) # number of validation dataset
+		self.num_train_data = self.num_of_data - self.num_validation_data # number of train dataset
 		print("For each dataset -----> Number of additional training dataset: ", self.num_train_data, " Number of validation dataset: ", self.num_validation_data)
 
 		self.num_validation_data =+1
@@ -35,12 +37,13 @@ def __init__(self,f_prefix, num_of_data, seq_length, val_percent):
 
 		self.dataloader = DataLoader(f_prefix, 1, seq_length , 0 ,forcePreProcess = True, infer = False, generate=True)
 
-
+		# noise parameter definition
 		self.noise_std_min = 0.05
 		self.noise_std_max = 0.15
 		self.noise_std = random.uniform(self.noise_std_min, self.noise_std_max)
 		self.noise_mean = 0.0
 
+		# remove datasets from directories for new creation
 		self.clear_directories(self.base_train_path)
 		self.clear_directories(self.base_validation_path, True)
 		self.random_dataset_creation()
@@ -67,39 +70,38 @@ def random_dataset_creation(self):
 			# Get the sequence
 			x_seq,d_seq ,numPedsList_seq, PedsList_seq = x[0], d[0], numPedsList[0], PedsList[0]
 
+			# convert dense vector
 			x_seq , lookup_seq = self.dataloader.convert_proper_array(x_seq, numPedsList_seq, PedsList_seq)
 
 			if dataset_pointer_ins is not self.dataloader.dataset_pointer:
 			    if self.dataloader.dataset_pointer is not 0:
 			        whole_dataset.append(dataset_instances)
 			        dataset_instances = {}
-			        random_angles = random.sample(self.angles, self.num_of_data)
-			        self.noise_std = random.uniform(self.noise_std_min, self.noise_std_max)
+			        random_angles = random.sample(self.angles, self.num_of_data) # sample new angle
+			        self.noise_std = random.uniform(self.noise_std_min, self.noise_std_max) #sample new noise
 			        print("Dataset creation for: ", file_name, " angles: ", random_angles)
 
 			    dataset_pointer_ins = self.dataloader.dataset_pointer
 
-
-
-			#self.add_element_to_dict(dataset_instances, (dir_name, file_name, ''), self.submision_seq_preprocess(x_seq, self.seq_length, lookup_seq))
-
 			for index, angle in enumerate(random_angles):
 				self.noise_std = random.uniform(self.noise_std_min, self.noise_std_max)
+				# modify and preprocess dataset
 				modified_x_seq = self.submision_seq_preprocess(self.handle_seq(x_seq, lookup_seq, PedsList_seq, angle), self.seq_length, lookup_seq)
+				# store modified data points to dict
 				self.dataloader.add_element_to_dict(dataset_instances, (dir_name, file_name, index), modified_x_seq)
 
 			end = time.time()
 			print('Current file : ', file_name,' Processed trajectory number : ', batch+1, 'out of', self.dataloader.num_batches, 'trajectories in time', end - start)
 
-
+		# write modified datapoints to txt files
 		whole_dataset.append(dataset_instances)
 		create_directories(os.path.join(self.f_prefix, self.base_validation_path), self.dataloader.get_all_directory_namelist())
 		self.write_modified_datasets(whole_dataset)
 
 
 	def handle_seq(self, x_seq, lookup_seq, PedsList_seq, angle):
+		# add noise and rotate a trajectory
 		vectorized_x_seq, first_values_dict = vectorize_seq(x_seq, PedsList_seq, lookup_seq)
-		#print("x_seq: %s"%vectorized_x_seq)
 		modified_x_seq = vectorized_x_seq.clone()
 		mean = torch.FloatTensor([self.noise_mean, self.noise_mean])
 		stddev =torch.FloatTensor([self.noise_std, self.noise_std])
@@ -108,41 +110,31 @@ def handle_seq(self, x_seq, lookup_seq, PedsList_seq, angle):
 		for ind, frame in enumerate(vectorized_x_seq):
 			for ped in PedsList_seq[ind]:
 				selected_point = frame[lookup_seq[ped], :]
-				#print("selected point : %s"%selected_point)
+				# rotate a frame point
 				rotated_point = rotate(origin, selected_point, math.radians(angle))
-				#print("after rotation: %s"%(rotated_point))
 				noise =  torch.normal(mean, stddev).clone()
-				#print("noise %s"%noise)
+				# add random noise
 				modified_x_seq[ind, lookup_seq[ped], 0] = rotated_point[0] + noise[0]
 				modified_x_seq[ind, lookup_seq[ped], 1] = rotated_point[1] + noise[1]
-				#print("after rotation and noise: %s"%modified_x_seq[ind, lookup_seq[ped], :])
 				modified_x_seq[ind, lookup_seq[ped], :] = torch.cat(rotate(origin, first_values_dict[ped], math.radians(angle))) + modified_x_seq[ind, lookup_seq[ped], :]
 		return modified_x_seq
 
 	def submision_seq_preprocess(self, x_seq, seq_lenght, lookup_seq):
-
+		# create original txt structure for modified datapoints 
 		ret_x_seq_c = x_seq.data.numpy()
-		#np.array(frame_number_predicted, copy=False, subok=True, ndmin=2)
 		ped_ids = self.dataloader.get_id_sequence(seq_lenght)
-		#print("lookup table: %s"%lookup_seq)
-		#print("ped ids: %s"%ped_ids)
 		positions_of_peds = [lookup_seq[ped] for ped in ped_ids]
-		#print(positions_of_peds)
-		#print("input seq: %s"%ret_x_seq_c)
 		ret_x_seq_c = ret_x_seq_c[:, positions_of_peds, :]
 		ret_x_seq_c_selected = ret_x_seq_c[:,0,:]
 		ret_x_seq_c_selected[:,[0,1]] = ret_x_seq_c_selected[:,[1,0]]
 		frame_numbers = self.dataloader.get_frame_sequence(seq_lenght)
 		id_integrated_seq = np.append(np.array(ped_ids)[:,None], ret_x_seq_c_selected, axis=1)
 		frame_integrated_seq = np.append(frame_numbers[:, None], id_integrated_seq, axis=1)
-		#print("final seq: %s"%frame_integrated_seq)
-		#print(repeated_id.shape)
-		#print(frame_integrated_prediction)
-		#print(result)
-		#print("************************")
+
 		return frame_integrated_seq
 
 	def write_modified_datasets(self, dataset_instances_store):
+		# write constructed txt structure to txt file
 		self.dataloader.reset_batch_pointer()
 
 		for dataset_index in range(self.dataloader.numDatasets):
@@ -166,6 +158,7 @@ def write_dict(self, dict, base_path):
 			self.dataloader.write_dataset(value, file_name, path)
 
 	def clear_directories(self, base_path, delete_all = False):
+		# delete all files from a directory
 		print("Clearing directories...")
 		dir_names = self.dataloader.get_all_directory_namelist()
 		base_path = os.path.join(self.f_prefix, base_path)
@@ -188,13 +181,13 @@ def main():
 	# RNN size parameter (dimension of the output/hidden state)
 	parser.add_argument('--num_data', type=int, default=5,
 	                    help='Number of additional dataset for each one ')
-
+	# lenght of sequence
 	parser.add_argument('--seq_length', type=int, default=20,
 	                    help='Processing sequence length')
-
+	# allocation percentage between train and validation datasets
 	parser.add_argument('--validation', type=float, default=0.1,
 	                    help='Percentage of data will be allocated for validation in additional datasets')
-
+	# use of gogle drive
 	parser.add_argument('--drive', action="store_true", default=False,
 	                    help='Use Google drive or not')
 
@@ -208,8 +201,8 @@ def main():
 	prefix = ''
 	f_prefix = '.'
 	if args.drive is True:
-	  prefix='drive/semester_project/new_social_LSTM_pytorch_v2/'
-	  f_prefix = 'drive/semester_project/new_social_LSTM_pytorch_v2'
+	  prefix='drive/semester_project/social_lstm_final/'
+	  f_prefix = 'drive/semester_project/social_lstm_final'
 
 	augmentator = data_augmentator(f_prefix, args.num_data, args.seq_length, args.validation)
 

grid.py

@@ -4,7 +4,7 @@
 from torch.autograd import Variable
 
 
-def getGridMask(frame, dimensions, num_person, neighborhood_size, grid_size, is_occupancy):
+def getGridMask(frame, dimensions, num_person, neighborhood_size, grid_size, is_occupancy = False):
     '''
     This function computes the binary mask that represents the
     occupancy of each ped in the other's grid
@@ -13,32 +13,19 @@ def getGridMask(frame, dimensions, num_person, neighborhood_size, grid_size, is_
     dimensions : This will be a list [width, height]
     neighborhood_size : Scalar value representing the size of neighborhood considered
     grid_size : Scalar value representing the size of the grid discretization
+    num_person : number of people exist in given frame
     is_occupancy: A flag using for calculation of accupancy map
 
     '''
-
-    # Maximum number of pedestrians
-    #print("***********************")
-    #print(frame)
-    #print(pedlist_seq)
-    #print(lookup_seq)
-    #mnp = frame.shape[0]
-    #print("*********************")
     mnp = num_person
-    #print(pedlist_seq)
-    #print(lookup_seq)
-
 
     width, height = dimensions[0], dimensions[1]
-    #print("width: ",width,"height: ",height)
     if is_occupancy:
         frame_mask = np.zeros((mnp, grid_size**2))
     else:
         frame_mask = np.zeros((mnp, mnp, grid_size**2))
     frame_np =  frame.data.numpy()
 
-    #print("frame: ", frame)
-
     #width_bound, height_bound = (neighborhood_size/(width*1.0)), (neighborhood_size/(height*1.0))
     width_bound, height_bound = (neighborhood_size/(width*1.0))*2, (neighborhood_size/(height*1.0))*2
     #print("weight_bound: ", width_bound, "height_bound: ", height_bound)
@@ -61,7 +48,6 @@ def getGridMask(frame, dimensions, num_person, neighborhood_size, grid_size, is_
         # If in surrounding, calculate the grid cell
         cell_x = int(np.floor(((other_x - width_low)/width_bound) * grid_size))
         cell_y = int(np.floor(((other_y - height_low)/height_bound) * grid_size))
-        #print("cell_x: ", cell_x, "cell_y: ", cell_y)
 
         if cell_x >= grid_size or cell_x < 0 or cell_y >= grid_size or cell_y < 0:
                 continue
@@ -135,8 +121,6 @@ def getSequenceGridMask(sequence, dimensions, pedlist_seq, neighborhood_size, gr
     '''
     sl = len(sequence)
     sequence_mask = []
-    #print(pedlist_seq)
-    #print(lookup_seq)
 
     for i in range(sl):
         mask = Variable(torch.from_numpy(getGridMask(sequence[i], dimensions, len(pedlist_seq[i]), neighborhood_size, grid_size, is_occupancy)).float())