diff --git "a/demo/demo_attn.ipynb" "b/demo/demo_attn.ipynb" new file mode 100644--- /dev/null +++ "b/demo/demo_attn.ipynb" @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Austi\\anaconda3\\envs\\janus_env\\lib\\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" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Python version is above 3.10, patching the collections module.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Austi\\anaconda3\\envs\\janus_env\\lib\\site-packages\\transformers\\models\\auto\\image_processing_auto.py:590: FutureWarning: The image_processor_class argument is deprecated and will be removed in v4.42. Please use `slow_image_processor_class`, or `fast_image_processor_class` instead\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import gradio as gr\n", + "import torch\n", + "from transformers import AutoConfig, AutoModelForCausalLM\n", + "from janus.models import MultiModalityCausalLM, VLChatProcessor\n", + "from janus.utils.io import load_pil_images\n", + "from demo.cam import generate_gradcam\n", + "from captum.attr import LayerGradCam\n", + "from PIL import Image\n", + "from einops import rearrange\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import torch.nn.functional as F\n", + "from scipy.ndimage import filters\n", + "from torch import nn" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def aggregate_attention(attn):\n", + " '''Extract average attention vector'''\n", + " avged = []\n", + " for layer in attn:\n", + " layer_attns = layer.squeeze(0)\n", + " attns_per_head = layer_attns.mean(dim=0)\n", + " vec = torch.concat((\n", + " # We zero the first entry because it's what's called\n", + " # null attention (https://aclanthology.org/W19-4808.pdf)\n", + " torch.tensor([0.]).cuda(),\n", + " # usually there's only one item in attns_per_head but\n", + " # on the first generation, there's a row for each token\n", + " # in the prompt as well, so take [-1]\n", + " attns_per_head[-1][1:],\n", + " # add zero for the final generated token, which never\n", + " # gets any attention\n", + " torch.tensor([0.]).cuda(),\n", + " ))\n", + " avged.append(vec / vec.sum())\n", + " return torch.stack(avged).mean(dim=0)\n", + "\n", + "def heterogenous_stack(vecs):\n", + " '''Pad vectors with zeros then stack'''\n", + " max_length = max(v.shape[0] for v in vecs)\n", + " return torch.stack([\n", + " torch.concat((v, torch.zeros(max_length - v.shape[0]).cuda()))\n", + " for v in vecs\n", + " ])\n", + "\n", + "def decode(tokens, tokenizer):\n", + " '''Turn tokens into text with mapping index'''\n", + " full_text = ''\n", + " chunks = []\n", + " \n", + " for i, token in enumerate(tokens):\n", + " text = tokenizer.decode(token)\n", + " full_text += text\n", + " chunks.append(text)\n", + " return full_text, chunks\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using a slow image processor as `use_fast` is unset and a slow processor was saved with this model. `use_fast=True` will be the default behavior in v4.48, even if the model was saved with a slow processor. This will result in minor differences in outputs. You'll still be able to use a slow processor with `use_fast=False`.\n", + "You are using the default legacy behaviour of the . This is expected, and simply means that the `legacy` (previous) behavior will be used so nothing changes for you. If you want to use the new behaviour, set `legacy=False`. This should only be set if you understand what it means, and thoroughly read the reason why this was added as explained in https://github.com/huggingface/transformers/pull/24565 - if you loaded a llama tokenizer from a GGUF file you can ignore this message.\n", + "Some kwargs in processor config are unused and will not have any effect: add_special_token, num_image_tokens, sft_format, mask_prompt, ignore_id, image_tag. \n" + ] + } + ], + "source": [ + "\n", + "model_path = \"deepseek-ai/Janus-Pro-1B\"\n", + "config = AutoConfig.from_pretrained(model_path)\n", + "language_config = config.language_config\n", + "language_config._attn_implementation = 'eager'\n", + "vl_gpt = AutoModelForCausalLM.from_pretrained(model_path,\n", + " language_config=language_config,\n", + " trust_remote_code=True,\n", + " ignore_mismatched_sizes=True # Adding CLS token, will be handled manually\n", + " )\n", + "\n", + "dtype = torch.bfloat16 if torch.cuda.is_available() else torch.float16\n", + "# dtype = torch.bfloat32 if torch.cuda.is_available() else torch.float32\n", + "\n", + "if torch.cuda.is_available():\n", + " vl_gpt = vl_gpt.to(dtype).cuda()\n", + "else:\n", + " # vl_gpt = vl_gpt.to(torch.float16)\n", + " torch.set_default_device(\"mps\")\n", + " vl_gpt = vl_gpt.to(dtype)\n", + "\n", + "vl_chat_processor = VLChatProcessor.from_pretrained(model_path)\n", + "tokenizer = vl_chat_processor.tokenizer\n", + "cuda_device = 'cuda' if torch.cuda.is_available() else 'mps'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def multimodal_understanding(image, question, seed, top_p, temperature):\n", + " # Clear CUDA cache before generating\n", + " torch.cuda.empty_cache()\n", + " \n", + " # set seed\n", + " torch.manual_seed(seed)\n", + " np.random.seed(seed)\n", + " torch.cuda.manual_seed(seed)\n", + "\n", + " torch.cuda.empty_cache()\n", + "\n", + " conversation = [\n", + " {\n", + " \"role\": \"<|User|>\",\n", + " \"content\": f\"\\n{question}\",\n", + " \"images\": [image],\n", + " },\n", + " {\"role\": \"<|Assistant|>\", \"content\": \"\"},\n", + " ]\n", + " \n", + " pil_images = [Image.fromarray(image)]\n", + " prepare_inputs = vl_chat_processor(\n", + " conversations=conversation, images=pil_images, force_batchify=True\n", + " ).to(cuda_device, dtype=dtype)\n", + " \n", + "\n", + "\n", + " \n", + " inputs_embeds = vl_gpt.prepare_inputs_embeds(**prepare_inputs)\n", + " tokens = prepare_inputs.input_ids\n", + " img_token_positions = prepare_inputs.images_seq_mask\n", + "\n", + " # print(\"tokens:\", tokens)\n", + " # print(\"prepared inputs\", prepare_inputs)\n", + " print(\"img_token_positions_shape:\", img_token_positions.shape)\n", + " \n", + "\n", + " outputs = vl_gpt.language_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " attention_mask=prepare_inputs.attention_mask,\n", + " pad_token_id=tokenizer.eos_token_id,\n", + " bos_token_id=tokenizer.bos_token_id,\n", + " eos_token_id=tokenizer.eos_token_id,\n", + " max_new_tokens=512,\n", + " do_sample=False if temperature == 0 else True,\n", + " use_cache=True,\n", + " temperature=temperature,\n", + " top_p=top_p,\n", + " return_dict_in_generate=True,\n", + " output_attentions=True\n", + " )\n", + "\n", + "\n", + " sequences = outputs.sequences.cpu().tolist()\n", + " decoded, tokenized = decode(sequences[0], tokenizer)\n", + " # print(\"answer generated\")\n", + "\n", + " attentions_raw = outputs.attentions\n", + " # attn_selected = attentions_raw[selected_token_idx]\n", + " # attn_m = heterogenous_stack([\n", + " # torch.tensor([\n", + " # 1 if i == j else 0\n", + " # for j, token in enumerate(tokens[0])\n", + " # ]).to(cuda_device)\n", + " # for i, token in enumerate(tokens[0])\n", + " # ] + list(map(aggregate_attention, attentions_raw)))\n", + "\n", + " \n", + "\n", + " return outputs, attentions_raw, decoded, tokenized, img_token_positions\n", + " \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Select Feature Methodology: same\n", + "img_token_positions_shape: torch.Size([1, 631])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Austi\\anaconda3\\envs\\janus_env\\lib\\site-packages\\transformers\\generation\\configuration_utils.py:628: UserWarning: `do_sample` is set to `False`. However, `temperature` is set to `0` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `temperature`.\n", + " warnings.warn(\n", + "c:\\Users\\Austi\\anaconda3\\envs\\janus_env\\lib\\site-packages\\transformers\\generation\\configuration_utils.py:633: UserWarning: `do_sample` is set to `False`. However, `top_p` is set to `0.95` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `top_p`.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# IMG_PATH = \"../images/doge.png\"\n", + "# question = \"Find the Visual Encoding text.\"\n", + "\n", + "# IMG_PATH = \"../images/AreaChart.png\"\n", + "# question = \"What is the coffee price in April 2019?\"\n", + "\n", + "IMG_PATH = \"../images/PieChart.png\"\n", + "question = \"What is the percentage of Xiaomi\"\n", + "\n", + "# IMG_PATH = \"../images/pie_chart.png\"\n", + "# question = \"dog\"\n", + "\n", + "# IMG_PATH = \"../images/cat_dog.png\"\n", + "# question = \"cat\"\n", + "\n", + "\n", + "# question = \"Text including coffee\"\n", + "\n", + "image = Image.open(IMG_PATH)\n", + "image_arr = np.array(image)\n", + "\n", + "\n", + "outputs, attn_m, decoded, tokenized, img_token_positions = multimodal_understanding(image_arr, question, 100, 0.95, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "23" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(attn_m) # number of output tokens" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selected_token_idx = 0\n", + "attn_m_token = attn_m[selected_token_idx]\n", + "len(attn_m_token) # 24 transformer blocks" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'The percentage of Xiaomi in the global smartphone market share in 2021 is 10%.<|end▁of▁sentence|>'" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "decoded" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['The',\n", + " ' percentage',\n", + " ' of',\n", + " ' Xia',\n", + " 'omi',\n", + " ' in',\n", + " ' the',\n", + " ' global',\n", + " ' smartphone',\n", + " ' market',\n", + " ' share',\n", + " ' in',\n", + " ' ',\n", + " '2',\n", + " '0',\n", + " '2',\n", + " '1',\n", + " ' is',\n", + " ' ',\n", + " '1',\n", + " '0',\n", + " '%.',\n", + " '<|end▁of▁sentence|>']" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenized" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'The'" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenized[selected_token_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 16, 627, 627])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "block = 0\n", + "attn_m_token[block].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "mask = img_token_positions[0]\n", + "\n", + "tg = attn_m_token[1][:, :, :, :len(mask)]\n", + "\n", + "tg = tg[:, :, :, mask]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating Grad-CAM with shape: torch.Size([24, 24])\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "head = 0\n", + "\n", + "# res = tg[0, head, 0].to(torch.float32)\n", + "res, _ = tg.max(dim=1)\n", + "# res = tg.sum(dim=1)\n", + "res = res.to(torch.float32)\n", + "grid_size = (int)(res.shape[-1] ** 0.5)\n", + "res = res.view(grid_size, grid_size)\n", + "\n", + "generate_gradcam(res, image)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "janus_env", + "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.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}