there is not python3.4 with keras2.1.4 and tensorflow1.0.1 ; so , i install python3.5 with keras2.1.4 and tensorflow1.0.1 about rpg_public_dronet HOT 11 OPEN

  def next(self):                                                                                                                                                                                                                    
        with self.lock:                                                                                                                                                                                                                
            index_array = next(self.index_generator)                                                                                                                                                                                   
        # The transformation of images is not under thread lock                                                                                                                                                                        
        # so it can be done in parallel                                                                                                                                                                                                
        return self._get_batches_of_transformed_samples(index_array) 

  def _get_batches_of_transformed_samples(self, index_array) :
        current_batch_size = index_array.shape[0]                                                                                                                                                                                                                                                                                                                                                                                                              
        # Image transformation is not under thread lock, so it can be done in                                                                                                                                                          
        # parallel                                                                                                                                                                                                                     
        batch_x = np.zeros((current_batch_size,) + self.image_shape,                                                                                                                                                                   
                dtype=K.floatx())                                                                                                                                                                                                      
        batch_steer = np.zeros((current_batch_size, 2,),                                                                                                                                                                               
                dtype=K.floatx())                                                                                                                                                                                                      
        batch_coll = np.zeros((current_batch_size, 2,),                                                                                                                                                                                
                dtype=K.floatx())                                                                                                                                                                                                      
                                                                                                                                                                                                                                       
        grayscale = self.color_mode == 'grayscale'                                                                                                                                                                                     
                                                                                                                                                                                                                                       
        # Build batch of image data                                                                                                                                                                                                    
        for i, j in enumerate(index_array):                                                                                                                                                                                            
            fname = self.filenames[j]                                                                                                                                                                                                  
            x = img_utils.load_img(os.path.join(self.directory, fname),                                                                                                                                                                
                    grayscale=grayscale,                                                                                                                                                                                               
                    crop_size=self.crop_size,                                                                                                                                                                                          
                    target_size=self.target_size)                                                                                                                                                                                      
                                                                                                                                                                                                                                       
            x = self.image_data_generator.random_transform(x)                                                                                                                                                                          
            x = self.image_data_generator.standardize(x)                                                                                                                                                                               
            batch_x[i] = x                                                                                                                                                                                                             
                                                                                                                                                                                                                                       
            # Build batch of steering and collision data                                                                                                                                                                               
            if self.exp_type[index_array[i]] == 1:                                                                                                                                                                                     
                # Steering experiment (t=1)                                                                                                                                                                                            
                batch_steer[i,0] =1.0                                                                                                                                                                                                  
                batch_steer[i,1] = self.ground_truth[index_array[i]]                                                                                                                                                                   
                batch_coll[i] = np.array([1.0, 0.0])                                                                                                                                                                                   
            else:                                                                                                                                                                                                                      
                # Collision experiment (t=0)                                                                                                                                                                                           
                batch_steer[i] = np.array([0.0, 0.0])                                                                                                                                                                                  
                batch_coll[i,0] = 0.0                                                                                                                                                                                                  
                batch_coll[i,1] = self.ground_truth[index_array[i]]                                                                                                                                                                    
                                                                                                                                                                                                                                       
        batch_y = [batch_steer, batch_coll]                                                                                                                                                                                            
        return batch_x, batch_y