diff --git "a/causalvideovae/eval/cal_we.ipynb" "b/causalvideovae/eval/cal_we.ipynb"
new file mode 100644--- /dev/null
+++ "b/causalvideovae/eval/cal_we.ipynb"
@@ -0,0 +1,459 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/remote-home1/lzj/miniconda3/envs/lzj/lib/python3.10/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: '/remote-home1/lzj/miniconda3/envs/lzj/lib/python3.10/site-packages/torchvision/image.so: undefined symbol: _ZN3c1017RegisterOperatorsD1Ev'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?\n",
+      "  warn(\n",
+      "/remote-home1/lzj/miniconda3/envs/lzj/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "from RAFT.core.raft import RAFT\n",
+    "from RAFT.core.utils.utils import InputPadder\n",
+    "from torchvision.utils import flow_to_image\n",
+    "import cv2\n",
+    "import torch\n",
+    "import numpy as np\n",
+    "from einops import rearrange\n",
+    "import matplotlib.pyplot as plt\n",
+    "from decord import VideoReader\n",
+    "import numpy.typing as npt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def array_to_video(\n",
+    "    image_array: npt.NDArray, fps: float = 30.0, output_file: str = \"output_video.mp4\"\n",
+    ") -> None:\n",
+    "    height, width, channels = image_array[0].shape\n",
+    "    fourcc = cv2.VideoWriter_fourcc(*\"mp4v\")\n",
+    "    video_writer = cv2.VideoWriter(output_file, fourcc, float(fps), (width, height))\n",
+    "\n",
+    "    for image in image_array:\n",
+    "        image_rgb = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
+    "        video_writer.write(image_rgb)\n",
+    "\n",
+    "    video_writer.release()\n",
+    "\n",
+    "\n",
+    "def custom_to_video(\n",
+    "    x: torch.Tensor, fps: float = 2.0, output_file: str = \"output_video.mp4\"\n",
+    ") -> None:\n",
+    "    x = x.detach().cpu()\n",
+    "    x = torch.clamp(x, -1, 1)\n",
+    "    x = (x + 1) / 2\n",
+    "    x = x.permute(1, 2, 3, 0).float().numpy()\n",
+    "    x = (255 * x).astype(np.uint8)\n",
+    "    array_to_video(x, fps=fps, output_file=output_file)\n",
+    "    return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class RaftParams():\n",
+    "\tdef __init__(self) -> None:\n",
+    "\t\tself.small = False\n",
+    "\t\tself.mixed_precision = True\n",
+    "\t\tself.alternate_corr = False\n",
+    "\tdef __getitem__(self, key):\n",
+    "\t\treturn getattr(self, key)\n",
+    "\t\n",
+    "\tdef __setitem__(self, key, value):\n",
+    "\t\tsetattr(self, key, value)\n",
+    "\t\n",
+    "\tdef __delitem__(self, key):\n",
+    "\t\tdelattr(self, key)\n",
+    "\t\n",
+    "\tdef __contains__(self, key):\n",
+    "\t\treturn hasattr(self, key)\t\n",
+    "params = RaftParams()\n",
+    "raft = RAFT(params)\n",
+    "ckpt = {key.replace(\"module.\", \"\"): value for key, value in torch.load(\"/remote-home1/lzj/causal-video-vae-github/.cache/raft/raft-things.pth\").items()}\n",
+    "raft.load_state_dict(ckpt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(0., grad_fn=<MeanBackward0>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "video_read = VideoReader(\"/remote-home1/lzj/dataset/gen/opensora1.1_k400_sr1_nf33_res256_subset50/origin/--nQbRBEz2s.mp4\")\n",
+    "origin_video_read = VideoReader(\"/remote-home1/lzj/dataset/gen/opensora1.1_k400_sr1_nf33_res256_subset50/origin/--nQbRBEz2s.mp4\")\n",
+    "\n",
+    "video = torch.tensor(video_read[:].asnumpy())\n",
+    "video = rearrange(video, \"t h w c -> t c h w\")\n",
+    "video = video[:, :, :, :]\n",
+    "\n",
+    "origin_video = torch.tensor(origin_video_read[:].asnumpy())\n",
+    "origin_video = rearrange(origin_video, \"t h w c -> t c h w\")\n",
+    "origin_video = origin_video[:, :, :, :]\n",
+    "\n",
+    "# _, forward_flow = raft(video[:-1], video[1:], iters=20, test_mode=True)\n",
+    "# _, backward_flow = raft(reversed(video)[:-1], reversed(video)[1:], iters=20, test_mode=True)\n",
+    "# backward_flow = torch.flip(backward_flow, [0])\n",
+    "\n",
+    "_, fake_forward_flow = raft(video[:-1], video[1:], iters=20, test_mode=True)\n",
+    "_, gt_forward_flow = raft(origin_video[:-1], origin_video[1:], iters=20, test_mode=True)\n",
+    "print(torch.mean(torch.norm(gt_forward_flow - fake_forward_flow, dim=1)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([16, 2, 512, 512])\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "print((gt_forward_flow - fake_forward_flow).shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(0.1286, grad_fn=<MeanBackward0>)\n"
+     ]
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(0.1124)\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_rc_matrix(frame):\n",
+    "    row, col = torch.meshgrid(torch.arange(frame.shape[-2]), torch.arange(frame.shape[-1]), indexing='ij')\n",
+    "    row = row.unsqueeze(0)\n",
+    "    col = col.unsqueeze(0)\n",
+    "    rc_matrix = torch.concat([row, col], dim=0)\n",
+    "    return rc_matrix\n",
+    "\n",
+    "def clamp_warp_rc(warp_rc, frame):\n",
+    "    height, width = frame.shape[-2:]\n",
+    "    warp_rc = torch.clamp(warp_rc, min=0)\n",
+    "    warp_rc[:, 0, :, :] = torch.clamp(warp_rc[:, 0, :, :], max=height - 1)\n",
+    "    warp_rc[:, 1, :, :] = torch.clamp(warp_rc[:, 1, :, :], max=width - 1)\n",
+    "    return warp_rc\n",
+    "\n",
+    "def get_disocclusion_mask(forward_flow, backward_flow, frame0, frame1):\n",
+    "    \"\"\"\n",
+    "    http://arxiv.org/abs/1604.08610\n",
+    "    \"\"\"\n",
+    "    num_frames = frame0.shape[0]\n",
+    "    rc_matrix = get_rc_matrix(frame0)\n",
+    "    \n",
+    "    warp_rc = rc_matrix + backward_flow\n",
+    "    warp_rc = clamp_warp_rc(warp_rc, frame0)\n",
+    "    warp_rc = warp_rc.long()\n",
+    "    warp_forward_flow = torch.zeros_like(backward_flow) # T V H W\n",
+    "    \n",
+    "    for t in range(num_frames):\n",
+    "        warp_forward_flow[t, :, warp_rc[t, 0], warp_rc[t, 1]] += forward_flow[t]\n",
+    "        \n",
+    "    # Formula (4)\n",
+    "    mask = torch.square(torch.norm(warp_forward_flow + backward_flow, dim=1)) <= 0.01 * (torch.square(torch.norm(warp_forward_flow, dim=1)) + torch.square(torch.norm(backward_flow, dim=1))) + 0.5\n",
+    "    \n",
+    "    return mask\n",
+    "    \n",
+    "def warp_frame(forward_flow, frame0):\n",
+    "    num_frames = frame0.shape[0]\n",
+    "    rc_matrix = get_rc_matrix(frame0)\n",
+    "    warp_frame = torch.zeros_like(frame0)\n",
+    "    warp_rc = forward_flow + rc_matrix\n",
+    "    warp_rc = clamp_warp_rc(warp_rc, frame0)\n",
+    "    warp_rc = warp_rc.long()\n",
+    "    for t in range(num_frames):\n",
+    "        warp_frame[t, :, warp_rc[t, 0], warp_rc[t, 1]] = frame0[t]\n",
+    "    return warp_frame\n",
+    "    \n",
+    "def cal_warp_error(forward_flow, backward_flows, video):\n",
+    "    num_frames = video.shape[0]\n",
+    "    disocclusion_mask = get_disocclusion_mask(forward_flow, backward_flow, video[:-1], video[1:])\n",
+    "    disocclusion_mask = disocclusion_mask.long()\n",
+    "    warp_frames = warp_frame(forward_flow, video[:-1])\n",
+    "    video = video.to(dtype=torch.float)\n",
+    "    warp_frames = warp_frames.to(dtype=torch.float)\n",
+    "    warp_error = torch.mean(torch.sum(torch.norm(video[:-1] - warp_frames, dim=1) * disocclusion_mask, dim=(1,2)) / torch.sum(disocclusion_mask, dim=(1,2)))\n",
+    "    return warp_error\n",
+    "\n",
+    "warp_error = cal_warp_error(forward_flow, backward_flow, origin_video / 255)\n",
+    "print(warp_error)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'warp_frames' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[65], line 6\u001b[0m\n\u001b[1;32m      4\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(video[frame_idx]\u001b[38;5;241m.\u001b[39mpermute(\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m0\u001b[39m))\n\u001b[1;32m      5\u001b[0m plt\u001b[38;5;241m.\u001b[39msubplot(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(\u001b[43mwarp_frames\u001b[49m[frame_idx \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mpermute(\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m0\u001b[39m))\n\u001b[1;32m      7\u001b[0m plt\u001b[38;5;241m.\u001b[39msubplot(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m3\u001b[39m)\n\u001b[1;32m      8\u001b[0m mask_image \u001b[38;5;241m=\u001b[39m disocclusion_mask[frame_idx \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mlong() \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m255\u001b[39m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'warp_frames' is not defined"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1280x960 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "frame_idx = 3\n",
+    "plt.figure(dpi=200)\n",
+    "plt.subplot(1, 4, 1)\n",
+    "plt.imshow(video[frame_idx].permute(1,2,0))\n",
+    "plt.subplot(1, 4, 2)\n",
+    "plt.imshow(warp_frames[frame_idx - 1].permute(1,2,0))\n",
+    "plt.subplot(1, 4, 3)\n",
+    "mask_image = disocclusion_mask[frame_idx - 1].long() * 255\n",
+    "plt.imshow(mask_image.unsqueeze(0).repeat((3,1,1)).permute(1,2,0))\n",
+    "plt.subplot(1, 4, 4)\n",
+    "mask_on_warp_frames = warp_frames[frame_idx - 1].clone()\n",
+    "mask_on_warp_frames[:, disocclusion_mask[frame_idx - 1]] = 0\n",
+    "plt.imshow(mask_on_warp_frames.permute(1,2,0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "RuntimeError",
+     "evalue": "linalg.vector_norm: Expected a floating point or complex tensor as input. Got Long",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/remote-home1/lzj/miniconda3/envs/lzj/lib/python3.10/site-packages/torch/functional.py:1610\u001b[0m, in \u001b[0;36mnorm\u001b[0;34m(input, p, dim, keepdim, out, dtype)\u001b[0m\n\u001b[1;32m   1608\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m p \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfro\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m (dim \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(dim, (\u001b[38;5;28mint\u001b[39m, torch\u001b[38;5;241m.\u001b[39mSymInt)) \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(dim) \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m):\n\u001b[1;32m   1609\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1610\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinalg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvector_norm\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_dim\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeepdim\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1611\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   1612\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39mvector_norm(\u001b[38;5;28minput\u001b[39m, \u001b[38;5;241m2\u001b[39m, _dim, keepdim, dtype\u001b[38;5;241m=\u001b[39mdtype, out\u001b[38;5;241m=\u001b[39mout)\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: linalg.vector_norm: Expected a floating point or complex tensor as input. Got Long"
+     ]
+    }
+   ],
+   "source": [
+    "torch.norm(torch.tensor([[0,1], [1,2]]), dim=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 264,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[[[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]],\n",
+       "\n",
+       "         [[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]]],\n",
+       "\n",
+       "\n",
+       "        [[[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]],\n",
+       "\n",
+       "         [[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]]],\n",
+       "\n",
+       "\n",
+       "        [[[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]],\n",
+       "\n",
+       "         [[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]]],\n",
+       "\n",
+       "\n",
+       "        ...,\n",
+       "\n",
+       "\n",
+       "        [[[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]],\n",
+       "\n",
+       "         [[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]]],\n",
+       "\n",
+       "\n",
+       "        [[[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]],\n",
+       "\n",
+       "         [[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]]],\n",
+       "\n",
+       "\n",
+       "        [[[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]],\n",
+       "\n",
+       "         [[False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          ...,\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False],\n",
+       "          [False, False, False,  ..., False, False, False]]]])"
+      ]
+     },
+     "execution_count": 264,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "forward_flow > 10"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "lzj",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}