start = time.time()
        # multi-step prediction: 10 time steps:
        for j in range(SEQ_LEN):
            print('----------------------Decode the %dth frame-----------------------------'%(j+1))
            # Create input grid maps:
            input_gridMap = copy.deepcopy(input_gridMap_bak)
            # current position and velocities: 
            obs_pos_N = positions[:, SEQ_LEN-1]
            vel_N = velocities[:, SEQ_LEN-1]
            # Predict the future origin pose of the robot: t+n 
            T = j+1 #int(t_pred)
            noise_std = [0, 0, 0]#[0.00111, 0.00112, 0.02319]
            pos_origin = input_gridMap.origin_pose_prediction(vel_N, obs_pos_N, T, noise_std)
            # robot positions:
            pos = positions[:,:SEQ_LEN]
            # Transform the robot past poses to the predicted reference frame.
            x_odom, y_odom, theta_odom = input_gridMap.robot_coordinate_transform(pos, pos_origin)
            # Lidar measurements:
            distances = scans[:,:SEQ_LEN]
            # the angles of lidar scan: -135 ~ 135 degree
            angles = torch.linspace(-(135*np.pi/180), 135*np.pi/180, distances.shape[-1]).to(device)
            # Lidar measurements in X-Y plane: transform to the predicted robot reference frame
            distances_x, distances_y = input_gridMap.lidar_scan_xy(distances, angles, x_odom, y_odom, theta_odom)
            # discretize to binary maps:
            input_binary_maps = input_gridMap.discretize(distances_x, distances_y)
            # binary occupancy maps:
            input_binary_maps = input_binary_maps.unsqueeze(2)
            # feed the batch to the network:
            num_samples = 32 #1
            inputs_samples = input_binary_maps.repeat(num_samples,1,1,1,1)
            timestamp8 = time.time()
            for t in range(T):
                prediction, kl_loss = model(inputs_samples)
                prediction = prediction.reshape(-1,1,1,IMG_SIZE,IMG_SIZE)
                inputs_samples = torch.cat([inputs_samples[:,1:], prediction], dim=1) 
            timestamp9 = time.time()
            print('pytorch prediction takes %.4f' %(timestamp9 - timestamp8))
            predictions = prediction.squeeze(1)
            # mean and std:
            pred_mean = torch.mean(predictions, dim=0, keepdim=True)
            prediction_maps[j, 0] = pred_mean.squeeze()
        end = time.time()
        print('prediction 10 time steps takes：%.4f s'%(end - start))`