File size: 224,736 Bytes
84bfc2b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2024-09-10 11:23:42.358210: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
"To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
"2024-09-10 11:23:43.031780: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
]
}
],
"source": [
"from base64 import b64encode\n",
"\n",
"import numpy\n",
"import torch\n",
"from diffusers import AutoencoderKL, LMSDiscreteScheduler, UNet2DConditionModel\n",
"from huggingface_hub import notebook_login\n",
"\n",
"# For video display:\n",
"from IPython.display import HTML\n",
"from matplotlib import pyplot as plt\n",
"from pathlib import Path\n",
"from PIL import Image\n",
"from torch import autocast\n",
"from torchvision import transforms as tfms\n",
"from tqdm.auto import tqdm\n",
"from transformers import CLIPTextModel, CLIPTokenizer, logging\n",
"import os\n",
"import os\n",
"os.environ['HF_HOME'] = '/raid/users/mohammadibrahim-st/ModelCache'\n",
"torch.manual_seed(1)\n",
"if not (Path.home()/'.cache/huggingface'/'token').exists(): notebook_login()\n",
"\n",
"# Supress some unnecessary warnings when loading the CLIPTextModel\n",
"logging.set_verbosity_error()\n",
"\n",
"# Set device\n",
"torch_device = \"cuda\" if torch.cuda.is_available() else \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n",
"if \"mps\" == torch_device: os.environ['PYTORCH_ENABLE_MPS_FALLBACK'] = \"1\""
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/mohammadibrahim-st/.local/lib/python3.8/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
" warnings.warn(\n"
]
}
],
"source": [
"# Load the autoencoder model which will be used to decode the latents into image space.\n",
"import os\n",
"os.environ[\"https_proxy\"] = \"http://185.46.212.90:80\"\n",
"os.environ[\"http_proxy\"] = \"http://185.46.212.90:80\"\n",
"vae = AutoencoderKL.from_pretrained(\"CompVis/stable-diffusion-v1-4\", subfolder=\"vae\")\n",
"\n",
"# Load the tokenizer and text encoder to tokenize and encode the text.\n",
"tokenizer = CLIPTokenizer.from_pretrained(\"openai/clip-vit-large-patch14\")\n",
"text_encoder = CLIPTextModel.from_pretrained(\"openai/clip-vit-large-patch14\")\n",
"\n",
"# The UNet model for generating the latents.\n",
"unet = UNet2DConditionModel.from_pretrained(\"CompVis/stable-diffusion-v1-4\", subfolder=\"unet\")\n",
"\n",
"# The noise scheduler\n",
"scheduler = LMSDiscreteScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule=\"scaled_linear\", num_train_timesteps=1000)\n",
"\n",
"# To the GPU we go!\n",
"vae = vae.to(torch_device)\n",
"text_encoder = text_encoder.to(torch_device)\n",
"unet = unet.to(torch_device);"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def pil_to_latent(input_im):\n",
" # Single image -> single latent in a batch (so size 1, 4, 64, 64)\n",
" with torch.no_grad():\n",
" latent = vae.encode(tfms.ToTensor()(input_im).unsqueeze(0).to(torch_device)*2-1) # Note scaling\n",
" return 0.18215 * latent.latent_dist.sample()\n",
"\n",
"def latents_to_pil(latents):\n",
" # bath of latents -> list of images\n",
" latents = (1 / 0.18215) * latents\n",
" with torch.no_grad():\n",
" image = vae.decode(latents).sample\n",
" image = (image / 2 + 0.5).clamp(0, 1)\n",
" image = image.detach().cpu().permute(0, 2, 3, 1).numpy()\n",
" images = (image * 255).round().astype(\"uint8\")\n",
" pil_images = [Image.fromarray(image) for image in images]\n",
" # pil_images[0].save('/raid/users/mohammadibrahim-st/TSAI/Assignment24/Depth/mouseseed64bright.png')\n",
" return pil_images"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def set_timesteps(scheduler, num_inference_steps):\n",
" scheduler.set_timesteps(num_inference_steps)\n",
" scheduler.timesteps = scheduler.timesteps.to(torch.float32)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def brightness_loss(images, target_brightness=0.9):\n",
" # Convert images to grayscale to calculate brightness\n",
" grayscale_images = images.mean(dim=1, keepdim=True)\n",
" error = torch.abs(grayscale_images - target_brightness).mean()\n",
" return error\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"def generate_with_embs(text_embeddings):\n",
" height = 512 # default height of Stable Diffusion\n",
" width = 512 # default width of Stable Diffusion\n",
" num_inference_steps = 30 # Number of denoising steps\n",
" guidance_scale = 7.5 # Scale for classifier-free guidance\n",
" generator = torch.manual_seed(164) # Seed generator to create the inital latent noise\n",
" batch_size = 1\n",
" blue_loss_scale=200\n",
"\n",
" max_length = text_input.input_ids.shape[-1]\n",
" uncond_input = tokenizer(\n",
" [\"\"] * batch_size, padding=\"max_length\", max_length=max_length, return_tensors=\"pt\"\n",
" )\n",
" with torch.no_grad():\n",
" uncond_embeddings = text_encoder(uncond_input.input_ids.to(torch_device))[0]\n",
" text_embeddings = torch.cat([uncond_embeddings, text_embeddings])\n",
"\n",
" # Prep Scheduler\n",
" set_timesteps(scheduler, num_inference_steps)\n",
"\n",
" # Prep latents\n",
" latents = torch.randn(\n",
" (batch_size, unet.in_channels, height // 8, width // 8),\n",
" generator=generator,\n",
" )\n",
" latents = latents.to(torch_device)\n",
" latents = latents * scheduler.init_noise_sigma\n",
"\n",
" # Loop\n",
" for i, t in tqdm(enumerate(scheduler.timesteps), total=len(scheduler.timesteps)):\n",
" # expand the latents if we are doing classifier-free guidance to avoid doing two forward passes.\n",
" latent_model_input = torch.cat([latents] * 2)\n",
" sigma = scheduler.sigmas[i]\n",
" latent_model_input = scheduler.scale_model_input(latent_model_input, t)\n",
"\n",
" # predict the noise residual\n",
" with torch.no_grad():\n",
" noise_pred = unet(latent_model_input, t, encoder_hidden_states=text_embeddings)[\"sample\"]\n",
"\n",
" # perform guidance\n",
" noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)\n",
" noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\n",
"\n",
" # compute the previous noisy sample x_t -> x_t-1\n",
" if i%5 == 0:\n",
" # Requires grad on the latents\n",
" latents = latents.detach().requires_grad_()\n",
"\n",
" # Get the predicted x0:\n",
" latents_x0 = latents - sigma * noise_pred\n",
" # latents_x0 = scheduler.step(noise_pred, t, latents).pred_original_sample\n",
"\n",
" # Decode to image space\n",
" denoised_images = vae.decode((1 / 0.18215) * latents_x0).sample / 2 + 0.5 # range (0, 1)\n",
"\n",
" # Calculate loss\n",
" loss = brightness_loss(denoised_images) * blue_loss_scale\n",
"\n",
" # Occasionally print it out\n",
" if i%10==0:\n",
" print(i, 'loss:', loss.item())\n",
"\n",
" # Get gradient\n",
" cond_grad = torch.autograd.grad(loss, latents)[0]\n",
"\n",
" # Modify the latents based on this gradient\n",
" latents = latents.detach() - cond_grad * sigma**2\n",
"\n",
" # Now step with scheduler\n",
" latents = scheduler.step(noise_pred, t, latents).prev_sample\n",
" return latents_to_pil(latents)[0]"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"def build_causal_attention_mask(bsz, seq_len, dtype):\n",
" # lazily create causal attention mask, with full attention between the vision tokens\n",
" # pytorch uses additive attention mask; fill with -inf\n",
" mask = torch.empty(bsz, seq_len, seq_len, dtype=dtype)\n",
" mask.fill_(torch.tensor(torch.finfo(dtype).min))\n",
" mask.triu_(1) # zero out the lower diagonal\n",
" mask = mask.unsqueeze(1) # expand mask\n",
" return mask\n",
"def get_output_embeds(input_embeddings):\n",
" # CLIP's text model uses causal mask, so we prepare it here:\n",
" bsz, seq_len = input_embeddings.shape[:2]\n",
" causal_attention_mask = build_causal_attention_mask(bsz, seq_len, dtype=input_embeddings.dtype)\n",
"\n",
" # Getting the output embeddings involves calling the model with passing output_hidden_states=True\n",
" # so that it doesn't just return the pooled final predictions:\n",
" encoder_outputs = text_encoder.text_model.encoder(\n",
" inputs_embeds=input_embeddings,\n",
" attention_mask=None, # We aren't using an attention mask so that can be None\n",
" causal_attention_mask=causal_attention_mask.to(torch_device),\n",
" output_attentions=None,\n",
" output_hidden_states=True, # We want the output embs not the final output\n",
" return_dict=None,\n",
" )\n",
"\n",
" # We're interested in the output hidden state only\n",
" output = encoder_outputs[0]\n",
"\n",
" # There is a final layer norm we need to pass these through\n",
" output = text_encoder.text_model.final_layer_norm(output)\n",
"\n",
" # And now they're ready!\n",
" return output\n",
"\n",
"# out_embs_test = get_output_embeds(input_embeddings) # Feed through the model with our new function\n",
"# print(out_embs_test.shape) # Check the output shape\n",
"# out_embs_test # Inspect the output"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_keys(['<depthmap>'])\n",
"dict_keys(['<jerrymouse>'])\n",
"dict_keys(['<moebius>'])\n",
"dict_keys(['oil_style'])\n",
"dict_keys(['<low-poly-hd-logos-icons>'])\n"
]
}
],
"source": [
"current_directory = os.path.dirname(__file__)\n",
"\n",
"# Construct the paths dynamically\n",
"birb_embed = torch.load(os.path.join(current_directory, 'Depth', 'learned_embeds.bin'))\n",
"\n",
"birb_embedjerry = torch.load(os.path.join(current_directory, 'Jerry mouse', 'learned_embeds.bin'))\n",
"\n",
"birb_embedmobius = torch.load(os.path.join(current_directory, 'Mobius', 'learned_embeds.bin'))\n",
"\n",
"birb_embedoilpaint = torch.load(os.path.join(current_directory, 'Oil paint', 'learned_embeds.bin'))\n",
"\n",
"birb_embedpolygon = torch.load(os.path.join(current_directory, 'Polygon', 'learned_embeds.bin'))\n",
"\n",
"print(birb_embed.keys())\n",
"print(birb_embedjerry.keys())\n",
"print(birb_embedmobius.keys())\n",
"print(birb_embedoilpaint.keys())\n",
"print(birb_embedpolygon.keys())\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_1959221/3185483617.py:23: FutureWarning: Accessing config attribute `in_channels` directly via 'UNet2DConditionModel' object attribute is deprecated. Please access 'in_channels' over 'UNet2DConditionModel's config object instead, e.g. 'unet.config.in_channels'.\n",
" (batch_size, unet.in_channels, height // 8, width // 8),\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "7a30a6f43b3442668ab8569e9e7a8fda",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/30 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 loss: 85.86473846435547\n",
"10 loss: 24.20591926574707\n",
"20 loss: 24.945316314697266\n"
]
},
{
"data": {
"image/jpeg": "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",
"image/png": "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",
"text/plain": [
"<PIL.Image.Image image mode=RGB size=512x512>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"prompt = 'A mouse in the style of puppy'\n",
"token_emb_layer = text_encoder.text_model.embeddings.token_embedding\n",
"pos_emb_layer = text_encoder.text_model.embeddings.position_embedding\n",
"position_ids = text_encoder.text_model.embeddings.position_ids[:, :77]\n",
"position_embeddings = pos_emb_layer(position_ids)\n",
"# Tokenize\n",
"text_input = tokenizer(prompt, padding=\"max_length\", max_length=tokenizer.model_max_length, truncation=True, return_tensors=\"pt\")\n",
"input_ids = text_input.input_ids.to(torch_device)\n",
"\n",
"# Get token embeddings\n",
"token_embeddings = token_emb_layer(input_ids)\n",
"\n",
"# The new embedding - our special birb word\n",
"replacement_token_embedding = birb_embed['<depthmap>'].to(torch_device)\n",
"\n",
"# Insert this into the token embeddings\n",
"token_embeddings[0, torch.where(input_ids[0]==6829)] = replacement_token_embedding.to(torch_device)\n",
"\n",
"# Combine with pos embs\n",
"input_embeddings = token_embeddings + position_embeddings\n",
"\n",
"# Feed through to get final output embs\n",
"modified_output_embeddings = get_output_embeds(input_embeddings)\n",
"\n",
"# And generate an image with this:\n",
"a = generate_with_embs(modified_output_embeddings)\n",
"display(a)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Running on local URL: http://127.0.0.1:7865\n",
"IMPORTANT: You are using gradio version 4.24.0, however version 4.29.0 is available, please upgrade.\n",
"--------\n",
"Running on public URL: https://25baf7d4fc18ef497d.gradio.live\n",
"\n",
"This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from Terminal to deploy to Spaces (https://huggingface.co/spaces)\n"
]
},
{
"data": {
"text/html": [
"<div><iframe src=\"https://25baf7d4fc18ef497d.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
],
"text/plain": [
"<IPython.core.display.HTML object>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": []
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_1959221/3185483617.py:23: FutureWarning: Accessing config attribute `in_channels` directly via 'UNet2DConditionModel' object attribute is deprecated. Please access 'in_channels' over 'UNet2DConditionModel's config object instead, e.g. 'unet.config.in_channels'.\n",
" (batch_size, unet.in_channels, height // 8, width // 8),\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9762c8b63e5b49bba277e7dc2ca9d99e",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/30 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 loss: 49.29018783569336\n",
"10 loss: 14.723957061767578\n",
"20 loss: 14.416694641113281\n"
]
}
],
"source": [
"import torch\n",
"import os\n",
"import gradio as gr\n",
"\n",
"# Load the embeddings\n",
"# birb_embed = torch.load('/raid/users/mohammadibrahim-st/TSAI/Assignment24/Depth/learned_embeds.bin')\n",
"# birb_embedjerry = torch.load(\"/raid/users/mohammadibrahim-st/TSAI/Assignment24/Jerry mouse/learned_embeds.bin\")\n",
"# birb_embedmobius = torch.load('/raid/users/mohammadibrahim-st/TSAI/Assignment24/Mobius/learned_embeds.bin')\n",
"# birb_embedoilpaint = torch.load('/raid/users/mohammadibrahim-st/TSAI/Assignment24/Oil paint/learned_embeds.bin')\n",
"# birb_embedpolygon = torch.load('/raid/users/mohammadibrahim-st/TSAI/Assignment24/Polygon/learned_embeds.bin')\n",
"\n",
"# Set GRADIO temp directory\n",
"os.environ[\"GRADIO_TEMP_DIR\"] = \"/raid/users/mohammadibrahim-st/inpaintAppMemoryOptimised/tmp\"\n",
"\n",
"def generate_image(prompt, selected_embedding):\n",
" # Map selected_embedding to corresponding embedding file and key\n",
" embedding_dict = {\n",
" \"Depth\": (birb_embed, '<depthmap>'),\n",
" \"Jerry mouse\": (birb_embedjerry, '<jerrymouse>'),\n",
" \"Mobius\": (birb_embedmobius, '<moebius>'),\n",
" \"Oil paint\": (birb_embedoilpaint, 'oil_style'),\n",
" \"Polygon\": (birb_embedpolygon, '<low-poly-hd-logos-icons>')\n",
" }\n",
" \n",
" token_emb_layer = text_encoder.text_model.embeddings.token_embedding\n",
" pos_emb_layer = text_encoder.text_model.embeddings.position_embedding\n",
" position_ids = text_encoder.text_model.embeddings.position_ids[:, :77]\n",
" position_embeddings = pos_emb_layer(position_ids)\n",
"\n",
" # Tokenize\n",
" text_input = tokenizer(prompt, padding=\"max_length\", max_length=tokenizer.model_max_length, truncation=True, return_tensors=\"pt\")\n",
" input_ids = text_input.input_ids.to(torch_device)\n",
"\n",
" # Get token embeddings\n",
" token_embeddings = token_emb_layer(input_ids)\n",
"\n",
" # Select the appropriate birb embedding and key based on user input\n",
" selected_embedding_file, embedding_key = embedding_dict[selected_embedding]\n",
" replacement_token_embedding = selected_embedding_file[embedding_key].to(torch_device)\n",
"\n",
" # Insert this into the token embeddings\n",
" token_embeddings[0, torch.where(input_ids[0] == 6829)] = replacement_token_embedding.to(torch_device)\n",
"\n",
" # Combine with pos embs\n",
" input_embeddings = token_embeddings + position_embeddings\n",
"\n",
" # Feed through to get final output embs\n",
" modified_output_embeddings = get_output_embeds(input_embeddings)\n",
"\n",
" # Generate an image with this and return it\n",
" generated_image = generate_with_embs(modified_output_embeddings)\n",
" return generated_image\n",
"\n",
"# Define options for the dropdown\n",
"embedding_options = [\"Depth\", \"Jerry mouse\", \"Mobius\", \"Oil paint\", \"Polygon\"]\n",
"\n",
"# Create Gradio interface\n",
"iface = gr.Interface(\n",
" fn=generate_image, \n",
" inputs=[\n",
" \"text\", \n",
" gr.Dropdown(choices=embedding_options, label=\"Select Style\")\n",
" ],\n",
" outputs=\"image\",\n",
" title=\"Image Generation App (Please use the word 'puppy' in the prompt)\"\n",
")\n",
"\n",
"iface.launch(share=True)\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.8.10"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
|